Implement tests

Author: yevhenii.nadtochii

server/src/test/java/io/spine/server/aggregate/AggregateTest.java

@@ -48,6 +48,7 @@
 import io.spine.server.aggregate.given.aggregate.TaskAggregateRepository;
 import io.spine.server.aggregate.given.aggregate.TestAggregate;
 import io.spine.server.aggregate.given.aggregate.TestAggregateRepository;
+import io.spine.server.aggregate.given.salary.EmployeeAgg;
 import io.spine.server.aggregate.given.thermometer.SafeThermometer;
 import io.spine.server.aggregate.given.thermometer.SafeThermometerRepo;
 import io.spine.server.aggregate.given.thermometer.Thermometer;
@@ -79,6 +80,7 @@
 import io.spine.test.aggregate.event.AggUserNotified;
 import io.spine.test.aggregate.rejection.Rejections.AggCannotReassignUnassignedTask;
 import io.spine.testing.logging.mute.MuteLogging;
+import io.spine.testing.server.blackbox.BlackBox;
 import io.spine.testing.server.blackbox.ContextAwareTest;
 import io.spine.testing.server.model.ModelTests;
 import io.spine.time.testing.BackToTheFuture;
@@ -111,6 +113,9 @@
 import static io.spine.server.aggregate.given.aggregate.AggregateTestEnv.newTenantId;
 import static io.spine.server.aggregate.given.aggregate.AggregateTestEnv.reassignTask;
 import static io.spine.server.aggregate.given.dispatch.AggregateMessageDispatcher.dispatchCommand;
+import static io.spine.server.aggregate.given.salary.Employees.employ;
+import static io.spine.server.aggregate.given.salary.Employees.newEmployee;
+import static io.spine.server.aggregate.given.salary.Employees.shakeUpSalary;
 import static io.spine.server.aggregate.model.AggregateClass.asAggregateClass;
 import static io.spine.server.tenant.TenantAwareRunner.with;
 import static io.spine.testing.server.Assertions.assertCommandClasses;
@@ -444,13 +449,54 @@ void restoreSnapshot() {
         assertEquals(aggregate, anotherAggregate);
     }
 
+    @Test
+    @DisplayName("add events to `UncommittedHistory` only if they were successfully applied")
+    void addEventsToUncommittedOnlyIfApplied() {
+        var jack = newEmployee();
+        var employeeAgg = new EmployeeAgg(jack);
+
+        employeeAgg.dispatchCommands(
+                employ(jack, 215),
+                shakeUpSalary(jack)
+        );
+
+        Aggregate<?, ?, ?> aggregate = employeeAgg;
+        var uncommitted = aggregate.getUncommittedEvents().list();
+        assertThat(uncommitted.size()).isEqualTo(1);
+    }
+
+    @Test
+    @DisplayName("add events to `UncommittedHistory` only if they were successfully applied")
+    void addEventsToUncommittedOnlyIfApplied2() {
+        var repository = new DefaultAggregateRepository<>(EmployeeAgg.class);
+        var context = BlackBox.from(
+                BoundedContextBuilder.assumingTests()
+                                     .add(repository)
+        );
+        repository.aggregateStorage().enableStateQuerying();
+
+        var jack = newEmployee();
+        context.tolerateFailures()
+               .receivesCommands(
+                       employ(jack, 2150),
+                       shakeUpSalary(jack)
+               );
+
+        var storedEvents = repository.aggregateStorage()
+                                     .read(jack)
+                                     .orElseThrow()
+                                     .getEventList();
+
+        assertThat(storedEvents.size()).isEqualTo(1);
+    }
+
     @Nested
     @DisplayName("after dispatch, return event records")
     class ReturnEventRecords {
 
         @Test
         @DisplayName("which are uncommitted")
-        void uncommitedAfterDispatch() {
+        void uncommittedAfterDispatch() {
             aggregate.dispatchCommands(command(createProject),
                                        command(addTask),
                                        command(startProject));
@@ -493,7 +539,7 @@ class NotHaveEventRecords {
 
         @Test
         @DisplayName("which are uncommitted")
-        void uncommitedByDefault() {
+        void uncommittedByDefault() {
             var events = aggregate().getUncommittedEvents();
 
             assertFalse(events.nonEmpty());

server/src/test/java/io/spine/server/aggregate/given/salary/EmployeeAgg.java

@@ -25,43 +25,100 @@
  */
 package io.spine.server.aggregate.given.salary;
 
+import io.spine.base.CommandMessage;
+import io.spine.base.EventMessage;
+import io.spine.server.BoundedContextBuilder;
 import io.spine.server.aggregate.Aggregate;
 import io.spine.server.aggregate.Apply;
-import io.spine.server.aggregate.given.command.DecreaseSalary;
-import io.spine.server.aggregate.given.command.IncreaseSalary;
+import io.spine.server.aggregate.DefaultAggregateRepository;
+import io.spine.server.aggregate.given.command.Employ;
+import io.spine.server.aggregate.given.command.ShakeUpSalary;
+import io.spine.server.aggregate.given.dispatch.AggregateMessageDispatcher;
+import io.spine.server.aggregate.given.salary.event.NewEmployed;
 import io.spine.server.aggregate.given.salary.event.SalaryDecreased;
 import io.spine.server.aggregate.given.salary.event.SalaryIncreased;
 import io.spine.server.command.Assign;
+import io.spine.testing.server.blackbox.BlackBox;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.spine.server.aggregate.given.aggregate.AggregateTestEnv.env;
+import static io.spine.server.aggregate.given.salary.Employees.employ;
+import static io.spine.server.aggregate.given.salary.Employees.newEmployee;
+import static io.spine.server.aggregate.given.salary.Employees.shakeUpSalary;
 
 public class EmployeeAgg extends Aggregate<EmployeeId, Employee, Employee.Builder> {
 
+    public EmployeeAgg(EmployeeId id) {
+        super(id);
+    }
+
     @Assign
-    SalaryIncreased handle(IncreaseSalary cmd) {
-        return SalaryIncreased.newBuilder()
+    NewEmployed handle(Employ cmd) {
+        return NewEmployed.newBuilder()
                 .setEmployee(cmd.getEmployee())
-                .setAmount(cmd.getAmount())
+                .setSalary(cmd.getSalary())
                 .vBuild();
     }
 
     @Apply
-    void on(SalaryIncreased event) {
+    private void on(NewEmployed event) {
         builder()
                 .setId(event.getEmployee())
-                .setSalary(state().getSalary() + event.getAmount());
+                .setSalary(event.getSalary());
     }
 
-    @Assign
-    SalaryDecreased handle(DecreaseSalary cmd) {
-        return SalaryDecreased.newBuilder()
-                .setEmployee(cmd.getEmployee())
-                .setAmount(cmd.getAmount())
-                .vBuild();
+    @Apply
+    private void on(SalaryIncreased event) {
+        builder()
+                .setId(event.getEmployee())
+                .setSalary(state().getSalary() + event.getAmount());
     }
 
     @Apply
-    void on(SalaryDecreased event) {
+    private void on(SalaryDecreased event) {
         builder()
                 .setId(event.getEmployee())
                 .setSalary(state().getSalary() - event.getAmount());
     }
+
+    @Assign
+    Iterable<EventMessage> handle(ShakeUpSalary cmd) {
+        var employee = cmd.getEmployee();
+        return List.of(
+
+                // we need several events to make them processed as a batch.
+                salaryDecreased(employee, 15),
+                salaryIncreased(employee, 50),
+                salaryIncreased(employee, 75),
+                salaryIncreased(employee, 100),
+
+                // this one would make the aggregate's state invalid.
+                // employee's can not be paid less than 200.
+                salaryDecreased(employee, 1000)
+        );
+    }
+
+    private static SalaryIncreased salaryIncreased(EmployeeId employee, int amount) {
+        return SalaryIncreased.newBuilder()
+                .setEmployee(employee)
+                .setAmount(amount)
+                .vBuild();
+    }
+
+    private static SalaryDecreased salaryDecreased(EmployeeId employee, int amount) {
+        return SalaryDecreased.newBuilder()
+                .setEmployee(employee)
+                .setAmount(amount)
+                .vBuild();
+    }
+
+    public void dispatchCommands(CommandMessage... commands) {
+        for (var cmd : commands) {
+            AggregateMessageDispatcher.dispatchCommand(this, env(cmd));
+        }
+    }
 }

server/src/test/java/io/spine/server/aggregate/given/salary/Employees.java

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2022, TeamDev. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package io.spine.server.aggregate.given.salary;
+
+import io.spine.server.aggregate.given.command.Employ;
+import io.spine.server.aggregate.given.command.ShakeUpSalary;
+
+public class Employees {
+
+    private Employees() {
+    }
+
+    public static EmployeeId newEmployee() {
+        return EmployeeId.generate();
+    }
+
+    public static Employ employ(EmployeeId employee, int salary) {
+        return Employ.newBuilder()
+                .setEmployee(employee)
+                .setSalary(salary)
+                .vBuild();
+    }
+
+    public static ShakeUpSalary shakeUpSalary(EmployeeId employee) {
+        return ShakeUpSalary.newBuilder()
+                .setEmployee(employee)
+                .vBuild();
+    }
+}

server/src/test/proto/spine/test/aggregate/salary/commands.proto

@@ -35,12 +35,14 @@ option java_multiple_files = true;
 
 import "spine/test/aggregate/salary/employee.proto";
 
-message IncreaseSalary {
+message Employ {
     EmployeeId employee = 1 [(required) = true];
-    int32 amount = 2 [(required) = true];
+    int32 salary = 2 [(required) = true];
 }
 
-message DecreaseSalary {
+// Triggers multiple modifications (increases\decreases) of an employee's salary.
+//
+// Used to reach an invalid state of the aggregate in tests.
+message ShakeUpSalary {
     EmployeeId employee = 1 [(required) = true];
-    int32 amount = 2 [(required) = true];
 }

server/src/test/proto/spine/test/aggregate/salary/employee.proto

@@ -43,6 +43,8 @@ message Employee {
 
   EmployeeId id = 1 [(required) = true];
 
+  // Employee's remuneration for their work.
+  //
   // Let's take 200$ as the lowest remuneration
   // which employers can legally pay their employees.
   double salary = 2 [(min).value = "200"];

server/src/test/proto/spine/test/aggregate/salary/events.proto

@@ -35,6 +35,11 @@ option java_multiple_files = true;
 
 import "spine/test/aggregate/salary/employee.proto";
 
+message NewEmployed {
+    EmployeeId employee = 1 [(required) = true];
+    int32 salary = 2 [(required) = true];
+}
+
 message SalaryIncreased {
     EmployeeId employee = 1 [(required) = true];
     int32 amount = 2 [(required) = true];