Introduce Error Prone

client/src/test/java/io/spine/client/ActorRequestFactoryTest.java

@@ -95,42 +95,38 @@ void passNullToleranceCheck() {
                 .testInstanceMethods(factory(), NullPointerTester.Visibility.PUBLIC);
     }
 
-    @Nested
-    @DisplayName("in Builder")
-    class BuilderTest {
+    @Test
+    @DisplayName("require actor in Builder")
+    void requireActorInBuilder() {
+        assertThrows(NullPointerException.class, () -> builder().setZoneOffset(zoneOffset)
+                                                                .build());
+    }
 
-        @Test
-        @DisplayName("require actor")
-        void requireActor() {
-            assertThrows(NullPointerException.class, () -> builder().setZoneOffset(zoneOffset)
-                                                                    .build());
-        }
+    @Test
+    @DisplayName("return values set in Builder")
+    void returnValuesSetInBuilder() {
+        final ActorRequestFactory.Builder builder = builder()
+                .setActor(actor)
+                .setZoneOffset(zoneOffset);
+        assertNotNull(builder.getActor());
+        assertNotNull(builder.getZoneOffset());
+        assertNull(builder.getTenantId());
+    }
 
-        @Test
-        @DisplayName("return set values")
-        void returnSetValues() {
-            final ActorRequestFactory.Builder builder = builder()
-                    .setActor(actor)
-                    .setZoneOffset(zoneOffset);
-            assertNotNull(builder.getActor());
-            assertNotNull(builder.getZoneOffset());
-            assertNull(builder.getTenantId());
-        }
+    @Test
+    @DisplayName("be single tenant by default")
+    void beSingleTenant() {
+        assertNull(factory().getTenantId());
     }
 
+    @SuppressWarnings("unused") // Used via reflection by JUnit.
     @Nested
-    @DisplayName("when created")
-    class WhenCreatedTest {
-
-        @Test
-        @DisplayName("be single tenant")
-        void beSingleTenant() {
-            assertNull(factory().getTenantId());
-        }
+    @DisplayName("when created, store")
+    class Store {
 
         @Test
-        @DisplayName("store given user")
-        void storeUser() {
+        @DisplayName("given user")
+        void givenUser() {
             final int currentOffset = ZoneOffsets.getDefault()
                                                  .getAmountSeconds();
             final ActorRequestFactory aFactory = builder()
@@ -143,8 +139,8 @@ void storeUser() {
         }
 
         @Test
-        @DisplayName("store given user and timezone")
-        void storeUserAndTimezone() {
+        @DisplayName("given user and timezone")
+        void givenUserAndTimezone() {
             assertEquals(actor, factory().getActor());
             assertEquals(zoneOffset, factory().getZoneOffset());
         }

client/src/test/java/io/spine/client/ColumnFiltersTest.java

@@ -39,8 +39,6 @@
 import static io.spine.client.ColumnFilter.Operator.GREATER_THAN;
 import static io.spine.client.ColumnFilter.Operator.LESS_OR_EQUAL;
 import static io.spine.client.ColumnFilter.Operator.LESS_THAN;
-import static io.spine.client.ColumnFilters.all;
-import static io.spine.client.ColumnFilters.either;
 import static io.spine.client.ColumnFilters.eq;
 import static io.spine.client.ColumnFilters.ge;
 import static io.spine.client.ColumnFilters.gt;
@@ -87,42 +85,42 @@ void passNullToleranceCheck() {
     }
 
     @Nested
-    @DisplayName("when creating column filter")
-    class CreateFilterTest {
+    @DisplayName("create column filter of type")
+    class CreateFilterOfType {
 
         @Test
-        @DisplayName("successfully create `equals` filter")
-        void createEquals() {
+        @DisplayName("`equals`")
+        void equals() {
             checkCreatesInstance(eq(COLUMN_NAME, COLUMN_VALUE), EQUAL);
         }
 
         @Test
-        @DisplayName("successfully create `greater than` filter")
-        void createGreaterThan() {
+        @DisplayName("`greater than`")
+        void greaterThan() {
             checkCreatesInstance(gt(COLUMN_NAME, COLUMN_VALUE), GREATER_THAN);
         }
 
         @Test
-        @DisplayName("successfully create `greater than or equals` filter")
-        void createGreaterOrEqual() {
+        @DisplayName("`greater than or equals`")
+        void greaterOrEqual() {
             checkCreatesInstance(ge(COLUMN_NAME, COLUMN_VALUE), GREATER_OR_EQUAL);
         }
 
         @Test
-        @DisplayName("successfully create `less than` filter")
-        void createLessThan() {
+        @DisplayName("`less than`")
+        void lessThan() {
             checkCreatesInstance(lt(COLUMN_NAME, COLUMN_VALUE), LESS_THAN);
         }
 
         @Test
-        @DisplayName("successfully create `less than or equals` filter")
-        void createLessOrEqual() {
+        @DisplayName("`less than or equals`")
+        void lessOrEqual() {
             checkCreatesInstance(le(COLUMN_NAME, COLUMN_VALUE), LESS_OR_EQUAL);
         }
 
         @Test
-        @DisplayName("successfully create `equals` filter for enumerated types")
-        void createEqualsForEnum() {
+        @DisplayName("`equals` for enumerated types")
+        void equalsForEnum() {
             final ColumnFilter filter = eq(ENUM_COLUMN_NAME, ENUM_COLUMN_VALUE);
             assertEquals(ENUM_COLUMN_NAME, filter.getColumnName());
             assertEquals(toAny(ENUM_COLUMN_VALUE), filter.getValue());
@@ -138,27 +136,27 @@ private void checkCreatesInstance(ColumnFilter filter,
     }
 
     @Nested
-    @DisplayName("when creating composite column filter")
-    class CreateCompositeFilterTest {
+    @DisplayName("create composite column filter of type")
+    class CreateCompositeFilterOfType {
 
         @Test
-        @DisplayName("successfully create `all` grouping")
-        void createAll() {
+        @DisplayName("`all`")
+        void all() {
             final ColumnFilter[] filters = {
                     le(COLUMN_NAME, COLUMN_VALUE),
                     ge(COLUMN_NAME, COLUMN_VALUE)
             };
-            checkCreatesInstance(all(filters[0], filters[1]), ALL, filters);
+            checkCreatesInstance(ColumnFilters.all(filters[0], filters[1]), ALL, filters);
         }
 
         @Test
-        @DisplayName("successfully create `either` grouping")
-        void createEither() {
+        @DisplayName("`either`")
+        void either() {
             final ColumnFilter[] filters = {
                     lt(COLUMN_NAME, COLUMN_VALUE),
                     gt(COLUMN_NAME, COLUMN_VALUE)
             };
-            checkCreatesInstance(either(filters[0], filters[1]), EITHER, filters);
+            checkCreatesInstance(ColumnFilters.either(filters[0], filters[1]), EITHER, filters);
         }
 
         private void checkCreatesInstance(CompositeColumnFilter filter,
@@ -170,12 +168,12 @@ private void checkCreatesInstance(CompositeColumnFilter filter,
     }
 
     @Nested
-    @DisplayName("when creating ordering filter")
-    class CreateOrderingFilterTest {
+    @DisplayName("create ordering filter")
+    class CreateOrderingFilter {
 
         @Test
-        @DisplayName("successfully create ordering filter for numbers")
-        void createForNumber() {
+        @DisplayName("for numbers")
+        void forNumbers() {
             final double number = 3.14;
             final ColumnFilter filter = le("doubleColumn", number);
             assertNotNull(filter);
@@ -185,33 +183,38 @@ void createForNumber() {
         }
 
         @Test
-        @DisplayName("successfully create ordering filter for strings")
-        void createForString() {
+        @DisplayName("for strings")
+        void forStrings() {
             final String theString = "abc";
             final ColumnFilter filter = gt("stringColumn", theString);
             assertNotNull(filter);
             assertEquals(GREATER_THAN, filter.getOperator());
             final StringValue value = AnyPacker.unpack(filter.getValue());
             assertEquals(theString, value.getValue());
         }
+    }
+
+    @Nested
+    @DisplayName("fail to create ordering filter")
+    class FailToCreateOrderingFilter {
 
         @Test
-        @DisplayName("fail to create ordering filter for enumerated types")
-        void failForEnum() {
+        @DisplayName("for enumerated types")
+        void forEnums() {
             assertThrows(IllegalArgumentException.class,
                          () -> ge(ENUM_COLUMN_NAME, ENUM_COLUMN_VALUE));
         }
 
         @Test
-        @DisplayName("fail to create ordering filter for non primitive number types")
-        void failForNonPrimitiveNumber() {
+        @DisplayName("for non primitive number types")
+        void forNonPrimitiveNumbers() {
             final AtomicInteger number = new AtomicInteger(42);
             assertThrows(IllegalArgumentException.class, () -> ge("atomicColumn", number));
         }
 
         @Test
-        @DisplayName("fail to create ordering filter for not supported types")
-        void failForNotSupportedType() {
+        @DisplayName("for not supported types")
+        void forUnsupportedTypes() {
             final Comparable<?> value = Calendar.getInstance(); // Comparable but not supported
             assertThrows(IllegalArgumentException.class, () -> le("invalidColumn", value));
         }

client/src/test/java/io/spine/client/CommandFactoryTest.java

@@ -68,12 +68,12 @@ void createCommandContext() {
     }
 
     @Nested
-    @DisplayName("on command instance creation")
-    class CreateCommandTest {
+    @DisplayName("create command")
+    class CreateCommand {
 
         @Test
-        @DisplayName("assign current time to command")
-        void createWithTimestamp() {
+        @DisplayName("with current time")
+        void withTimestamp() {
             // We are creating a range of +/- second between the call to make sure the timestamp
             // would fit into this range. The purpose of this test is to make sure it works with
             // this precision and to add coverage.
@@ -89,8 +89,8 @@ void createWithTimestamp() {
         }
 
         @Test
-        @DisplayName("assign given entity version to command")
-        void createWithEntityVersion() {
+        @DisplayName("with given entity version")
+        void withEntityVersion() {
             final Command command = factory().command()
                                              .create(StringValue.getDefaultInstance(), 2);
 
@@ -99,8 +99,8 @@ void createWithEntityVersion() {
         }
 
         @Test
-        @DisplayName("assign own tenant ID to command")
-        void createWithTenantID() {
+        @DisplayName("with own tenant ID")
+        void withOwnTenantID() {
             final TenantId tenantId = TenantId.newBuilder()
                                               .setValue(getClass().getSimpleName())
                                               .build();
@@ -116,18 +116,23 @@ void createWithTenantID() {
                                           .getActorContext()
                                           .getTenantId());
         }
+    }
+
+    @Nested
+    @DisplayName("throw ValidationException when creating command")
+    class NotAccept {
 
         @Test
-        @DisplayName("throw ValidationException if supplied with invalid Message")
-        void failForInvalidMessage() {
+        @DisplayName("from invalid Message")
+        void invalidMessage() {
             final RequiredFieldCommand invalidCommand = RequiredFieldCommand.getDefaultInstance();
             assertThrows(ValidationException.class, () -> factory().command()
                                                                    .create(invalidCommand));
         }
 
         @Test
-        @DisplayName("throw ValidationException if supplied with invalid Message with version")
-        void failForInvalidMessageWithVersion() {
+        @DisplayName("from invalid Message with version")
+        void invalidMessageWithVersion() {
             final RequiredFieldCommand invalidCommand = RequiredFieldCommand.getDefaultInstance();
             assertThrows(ValidationException.class, () -> factory().command()
                                                                    .create(invalidCommand, 42));