Implementing Value Entities

@Override
public Effect<Empty> increase(
    CounterDomain.CounterState currentState, CounterApi.IncreaseValue command) {
  if (command.getValue() < 0) { (1)
    return effects().error("Increase requires a positive value. It was [" +
        command.getValue() + "].");
  }
  CounterDomain.CounterState newState =  (2)
      currentState.toBuilder().setValue(currentState.getValue() +
          command.getValue()).build();
  return effects()
      .updateState(newState) (3)
      .thenReply(Empty.getDefaultInstance());  (4)
}

override def increase(currentState: CounterState, command: example.IncreaseValue): ValueEntity.Effect[Empty] =
  if (command.value < 0) (1)
    effects.error(s"Increase requires a positive value. It was [${command.value}].")
  else {
    val newState = currentState.copy(value = currentState.value + command.value) (2)
    effects
      .updateState(newState) (3)
      .thenReply(Empty.defaultInstance) (4)
  }

@Override
public Effect<CounterApi.CurrentCounter> getCurrentCounter(
    CounterDomain.CounterState currentState, (1)
    CounterApi.GetCounter command) {
  CounterApi.CurrentCounter current =
      CounterApi.CurrentCounter.newBuilder()
          .setValue(currentState.getValue()).build(); (2)
  return effects().reply(current);
}

override def getCurrentCounter(
    currentState: CounterState, (1)
    command: example.GetCounter): ValueEntity.Effect[example.CurrentCounter] =
  effects.reply(CurrentCounter(currentState.value)) (2)

@Override
public Effect<Empty> delete(CounterDomain.CounterState currentState,
                            CounterApi.DeleteCounter deleteCounter) {
  return effects()
      .deleteEntity() (1)
      .thenReply(Empty.getDefaultInstance());
}

override def delete(currentState: CounterState, deleteCounter: DeleteCounter): ValueEntity.Effect[Empty] =
  effects
    .deleteEntity() (1)
    .thenReply(Empty.defaultInstance)

import kalix.javasdk.Metadata;
import kalix.javasdk.testkit.ValueEntityResult;
import com.example.CounterApi;
import com.google.protobuf.Empty;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

public class CounterTest {

  @Test
  public void increaseCounterTest() {
    CounterTestKit testKit = CounterTestKit.of(Counter::new);

    CounterApi.IncreaseValue increaseValueCommand = CounterApi.IncreaseValue.newBuilder()
        .setValue(1)
        .build();
    ValueEntityResult<Empty> result1 = testKit.increase(increaseValueCommand);
    assertEquals(Empty.getDefaultInstance(), result1.getReply());
    assertEquals(1, testKit.getState().getValue());

    // one more time
    ValueEntityResult<Empty> result2 = testKit.increase(increaseValueCommand);
    assertEquals(Empty.getDefaultInstance(), result2.getReply());
    assertEquals(2, testKit.getState().getValue());
  }

class CounterSpec extends AnyWordSpec with Matchers {

  "Counter" must {

    "handle command Increase" in {
      val testKit = CounterTestKit(new Counter(_))

      val result1 = testKit.increase(IncreaseValue(value = 1))
      result1.reply shouldBe Empty.defaultInstance

      // one more time
      val result2 = testKit.increase(IncreaseValue(value = 1))
      result2.reply shouldBe Empty.defaultInstance
      testKit.currentState().value shouldBe 2
    }

import kalix.javasdk.testkit.junit.jupiter.KalixTestKitExtension;
// ...

public class CounterIntegrationTest {

  /**
   * The test kit starts both the service container and the Kalix Runtime.
   */
  @RegisterExtension
  public static final KalixTestKitExtension testKit =
      new KalixTestKitExtension(Main.createKalix()); (1)

  /**
   * Use the generated gRPC client to call the service through the Kalix Runtime.
   */
  private final CounterService client;

  public CounterIntegrationTest() {
    client = testKit.getGrpcClient(CounterService.class); (2)
  }

  @Test
  public void increaseOnNonExistingEntity() throws Exception {
    String entityId = "new-id";
    client.increase(CounterApi.IncreaseValue.newBuilder().setCounterId(entityId).setValue(42).build()) (3)
        .toCompletableFuture().get(5, SECONDS);
    CounterApi.CurrentCounter reply = client.getCurrentCounter(CounterApi.GetCounter.newBuilder().setCounterId(entityId).build())
        .toCompletableFuture().get(5, SECONDS);
    assertThat(reply.getValue(), is(42));
  }
}

import kalix.scalasdk.testkit.KalixTestKit
// ...

class CounterServiceIntegrationSpec
    extends AnyWordSpec
    with Matchers
    with BeforeAndAfterAll
    with ScalaFutures {

  implicit private val patience: PatienceConfig =
    PatienceConfig(Span(5, Seconds), Span(500, Millis))

  private val testKit = KalixTestKit(Main.createKalix()).start() (1)
  import testKit.executionContext

  private val client = testKit.getGrpcClient(classOf[CounterService]) (2)

  "CounterService" must {

    "Increase and decrease a counter" in {
      val counterId = "42"

      val updateResult =
        for {
          _ <- client.increase(IncreaseValue(counterId, 42))
          done <- client.decrease(DecreaseValue(counterId, 32))
        } yield done

      updateResult.futureValue

      val getResult = client.getCurrentCounter(GetCounter(counterId)) (3)
      getResult.futureValue.value shouldBe(42-32)
    }

  }

  override def afterAll(): Unit = { (4)
    testKit.stop()
    super.afterAll()
  }
}