// Create a new task.
message CreateTask {
    TaskId id = 1; // assumed `required`
    string name = 2 [(required) = true];
    string description = 3;
}

// A new task has been created.
message TaskCreated {
    TaskId task = 1 [(required) = true];
    string name = 2 [(required) = true];
    string description = 3;
    spine.core.UserId owner = 4 [(required) = true];
}

// A task which can be assigned to a user.
message Task {
    option (entity).kind = AGGREGATE;
    TaskId id = 1; // assumed `required`
    string name = 2 [(required) = true];
    string description = 3;
    spine.core.UserId owner = 4 [(required) = true];
    spine.core.UserId assignee = 5;
}

final class TaskAggregate extends Aggregate<TaskId, Task, Task.Builder> {

    @Assign
    TaskCreated handle(CreateTask cmd, CommandContext ctx) {
        return TaskCreated.newBuilder()
                    .setTask(cmd.getId())
                    .setName(cmd.getName())
                    .setDescription(cmd.getDescription())
                    .setOwner(ctx.getActorContext().getActor())
                    .vBuild(); // validate the event
    }

    @Apply
    private void event(TaskCreated e) {
        builder().setName(e.getName())
                 .setDescription(e.getDescription())
                 .setOwner(e.getOwner());
    }
}

@DisplayName("Handling `CreateTask` command should")
public class TaskCreationTest extends ContextAwareTest {

    private TaskId task;
    private String name;
    private String description;
    ...
    @BeforeEach
    void postCommand() {
        CreateTask cmd = generateCommand();
        context().receivesCommand(cmd);
    }

    @Test
    @DisplayName("generate `TaskCreated` event")
    void eventGenerated() {
        TaskCreated expected = expectedEvent();
        context().assertEvent(TaskCreated.class)
                 .comparingExpectedFieldsOnly()
                 .isEqualTo(expected);
    }

    @Test
    @DisplayName("create a `Task`")
    void aggregateCreation() {
        Task expected = expectedAggregateState();
        context().assertEntityWithState(task, Task.class)
                 .hasStateThat()
                 .comparingExpectedFieldsOnly()
                 .isEqualTo(expected);
    }
}

static void configureEnvironment() {
    StorageFactory rdbms = JdbcStorageFactory.newBuilder()
        .setDataSource(dataSource())
        .build();
    StorageFactory datastore = DatastoreStorageFactory.newBuilder()
        .setDatastore(datastoreService())
        .build();

    ServerEnvironment
        .when(Production.class)
        .use(datastore);
    ServerEnvironment
        .when(Tests.class)
        .use(rdbms); // use RDBMS instead of default In-Memory storage for tests.
}

./gradlew build deploy