Command handler contract enforcement

model/model-verifier/src/main/java/io/spine/model/verify/ModelVerifier.java

@@ -97,7 +97,6 @@ private URLClassLoader createClassLoader(Project project) {
         }
     }
 
-
     private static Collection<JavaCompile> allJavaCompile(Project project) {
         Collection<JavaCompile> tasks = newArrayList();
         ProjectHierarchy.applyToAll(project.getRootProject(),

model/model-verifier/src/test/java/io/spine/model/verify/ModelVerifierTest.java

@@ -21,13 +21,19 @@
 package io.spine.model.verify;
 
 import com.google.common.io.Files;
+import io.spine.logging.Logging;
 import io.spine.model.CommandHandlers;
 import io.spine.model.verify.ModelVerifier.GetDestinationDir;
 import io.spine.model.verify.given.DuplicateCommandHandler;
 import io.spine.model.verify.given.EditAggregate;
+import io.spine.model.verify.given.InvalidDeleteAggregate;
+import io.spine.model.verify.given.InvalidEnhanceAggregate;
+import io.spine.model.verify.given.InvalidRestoreAggregate;
 import io.spine.model.verify.given.RenameProcMan;
 import io.spine.model.verify.given.UploadCommandHandler;
 import io.spine.server.model.DuplicateCommandHandlerError;
+import io.spine.server.model.declare.MethodSignature;
+import io.spine.server.model.declare.SignatureMismatchException;
 import io.spine.testing.logging.MuteLogging;
 import org.gradle.api.Project;
 import org.gradle.api.initialization.dsl.ScriptHandler;
@@ -37,13 +43,23 @@
 import org.gradle.internal.impldep.com.google.common.collect.Iterators;
 import org.gradle.testfixtures.ProjectBuilder;
 import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.slf4j.event.Level;
+import org.slf4j.event.SubstituteLoggingEvent;
+import org.slf4j.helpers.SubstituteLogger;
 
 import java.io.File;
 import java.net.MalformedURLException;
 import java.net.URL;
+import java.util.ArrayDeque;
+import java.util.Queue;
 import java.util.function.Function;
+import java.util.stream.Stream;
 
 import static io.spine.tools.gradle.TaskName.COMPILE_JAVA;
 import static java.util.Collections.emptySet;
@@ -105,6 +121,24 @@ void verifyModel() {
         verifier.verify(spineModel);
     }
 
+    @ParameterizedTest
+    @DisplayName("throw when attempting to verify a model that declares an invalid command handler")
+    @MethodSource("getBadHandlers")
+    void throwOnSignatureMismatch(String badHandlerName) {
+        ModelVerifier verifier = new ModelVerifier(project);
+        CommandHandlers model = CommandHandlers
+                .newBuilder()
+                .addCommandHandlingTypes(badHandlerName)
+                .build();
+        assertThrows(SignatureMismatchException.class, () -> verifier.verify(model));
+    }
+
+    private static Stream<Arguments> getBadHandlers() {
+        return Stream.of(
+                Arguments.of(InvalidDeleteAggregate.class.getName()),
+                Arguments.of(InvalidEnhanceAggregate.class.getName()));
+    }
+
     @Test
     @DisplayName("fail on duplicate command handlers")
     void failOnDuplicateHandlers() {
@@ -120,6 +154,30 @@ void failOnDuplicateHandlers() {
         assertThrows(DuplicateCommandHandlerError.class, () -> verifier.verify(spineModel));
     }
 
+    @Disabled("until Gradle wrapper version is updated to at least 5.0")
+    ///TODO:2018-01-04:serhii.lekariev: enable when https://github.com/SpineEventEngine/core-java/issues/932 is resolved
+    @Test
+    @DisplayName("produce a warning on private command handling methods")
+    void warnOnPrivateHandlers(){
+        ModelVerifier verifier = new ModelVerifier(project);
+        Queue<SubstituteLoggingEvent> loggedMessages = redirectLogging();
+        CommandHandlers model = CommandHandlers
+                .newBuilder()
+                .addCommandHandlingTypes(InvalidRestoreAggregate.class.getName())
+                .build();
+        verifier.verify(model);
+        assertEquals(1, loggedMessages.size());
+        SubstituteLoggingEvent event = loggedMessages.poll();
+        assertEquals(event.getLevel(), Level.WARN);
+    }
+
+    /** Redirects logging produced by model verifier to a {@code Queue} that is returned. */
+    private static Queue<SubstituteLoggingEvent> redirectLogging() {
+        Queue<SubstituteLoggingEvent> loggedMessages = new ArrayDeque<>();
+        Logging.redirect((SubstituteLogger) Logging.get(MethodSignature.class), loggedMessages);
+        return loggedMessages;
+    }
+
     @Test
     @MuteLogging
     @DisplayName("ignore invalid class names")

model/model-verifier/src/test/java/io/spine/model/verify/given/InvalidDeleteAggregate.java

@@ -0,0 +1,48 @@
+///*
+// * Copyright 2018, TeamDev. All rights reserved.
+// *
+// * 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.model.verify.given;
+
+import io.spine.server.aggregate.Aggregate;
+import io.spine.server.command.Assign;
+import io.spine.test.model.verify.command.DeletePhoto;
+import io.spine.test.model.verify.event.PhotoDeleted;
+import io.spine.test.model.verify.given.EditState;
+import io.spine.test.model.verify.given.EditStateVBuilder;
+
+/**
+ * This aggregate declares a command handling method that breaks the contract imposed by
+ * {@link Assign}, by accepting a first parameter of type that cannot be derived from
+ * {@link io.spine.base.CommandMessage}.
+ */
+public class InvalidDeleteAggregate extends Aggregate<String, EditState, EditStateVBuilder> {
+
+    protected InvalidDeleteAggregate(String id) {
+        super(id);
+    }
+
+    @Assign
+    PhotoDeleted handle(String unnecessaryString, DeletePhoto delete) {
+        return PhotoDeleted
+                .newBuilder()
+                .setTitle(delete.getTitle())
+                .build();
+    }
+}

model/model-verifier/src/test/java/io/spine/model/verify/given/InvalidEnhanceAggregate.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2018, TeamDev. All rights reserved.
+ *
+ * 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.model.verify.given;
+
+import io.spine.server.aggregate.Aggregate;
+import io.spine.server.command.Assign;
+import io.spine.test.model.verify.command.EnhancePhoto;
+import io.spine.test.model.verify.given.EditState;
+import io.spine.test.model.verify.given.EditStateVBuilder;
+
+/**
+ * This aggregate declares a command handling method that breaks the contract imposed by
+ * {@link Assign}, by having a return value that cannot be derived from
+ * {@link io.spine.base.EventMessage}.
+ */
+public class InvalidEnhanceAggregate extends Aggregate<String, EditState, EditStateVBuilder> {
+
+    protected InvalidEnhanceAggregate(String id) {
+        super(id);
+    }
+
+    @Assign
+    String handle(EnhancePhoto delete) {
+        return delete.getTitle();
+    }
+}

model/model-verifier/src/test/java/io/spine/model/verify/given/InvalidRestoreAggregate.java

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2018, TeamDev. All rights reserved.
+ *
+ * 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.model.verify.given;
+
+import io.spine.server.aggregate.Aggregate;
+import io.spine.server.command.Assign;
+import io.spine.test.model.verify.command.RestorePhoto;
+import io.spine.test.model.verify.event.PhotoRestored;
+import io.spine.test.model.verify.given.EditState;
+import io.spine.test.model.verify.given.EditStateVBuilder;
+
+/**
+ * This aggregate declares a command handling method that breaks the contract imposed by
+ * {@link Assign}, by having a {@code private} access modifier.
+ *
+ * <p>This should result in a warning.
+ */
+public class InvalidRestoreAggregate extends Aggregate<String, EditState, EditStateVBuilder> {
+
+    protected InvalidRestoreAggregate(String id) {
+        super(id);
+    }
+
+    @Assign
+    private PhotoRestored handle(RestorePhoto restore){
+        return PhotoRestored.newBuilder()
+                .setTitle(restore.getTitle())
+                .build();
+    }
+}

model/model-verifier/src/test/proto/spine/test/model/verify/commands.proto

@@ -21,3 +21,15 @@ message EditPhoto {
 message ChangeTitle {
     string new_title = 1;
 }
+
+message DeletePhoto {
+    string title = 1;
+}
+
+message RestorePhoto {
+    string title = 1;
+}
+
+message EnhancePhoto {
+    string title = 1;
+}

model/model-verifier/src/test/proto/spine/test/model/verify/events.proto

@@ -22,3 +22,15 @@ message PhotoEdited {
 message TitleChanged {
     string new_title = 1;
 }
+
+message PhotoDeleted {
+    string title = 1;
+}
+
+message PhotoEnhanced {
+    string title = 1;
+}
+
+message PhotoRestored {
+    string title = 1;
+}

model/model-verifier/src/test/resources/build.gradle

@@ -23,12 +23,12 @@
 buildscript {
 
     // Apply the script created by `GradleProject.createTestEnvExt()` which defines
-    // `enclosingRootDir` variable that we use below. 
+    // `enclosingRootDir` variable that we use below.
     apply from: "$rootDir/testEnv.gradle"
 
     // Apply shared dependencies.
     apply from: "$enclosingRootDir/config/gradle/dependencies.gradle"
-    
+
     // Applying from `version.gradle` inside the `buildscript` section to reuse the properties.
     //
     // As long as `buildscript` section is always evaluated first, we need to apply

server/src/main/java/io/spine/server/model/declare/MethodSignature.java

@@ -22,17 +22,18 @@
 
 import com.google.common.collect.ImmutableSet;
 import io.spine.core.MessageEnvelope;
+import io.spine.logging.Logging;
 import io.spine.server.model.HandlerMethod;
 
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Method;
 import java.util.Collection;
+import java.util.List;
 import java.util.Optional;
 import java.util.stream.Stream;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 import static io.spine.server.model.declare.MethodParams.findMatching;
-import static io.spine.server.model.declare.SignatureMismatch.Severity.ERROR;
 import static java.util.stream.Collectors.toList;
 
 /**
@@ -43,16 +44,12 @@
  *
  * <p>By extending this base class, descendants define the number of requirements:
  * <ul>
- *     <li>{@linkplain #MethodSignature(Class) the method annotation},</li>
- *
- *      <li>{@linkplain #getParamSpecs() the specification of method parameters},</li>
- *
- *      <li>{@linkplain #getAllowedModifiers() the set of allowed access modifiers},</li>
- *
- *      <li>{@linkplain #getValidReturnTypes() the set of valid return types},</li>
- *
- *      <li>{@linkplain #getAllowedExceptions() the set of allowed exceptions}, that the method
- *      declares to throw (empty by default),</li>
+ *     <li>{@linkplain #MethodSignature(Class) the method annotation},
+ *     <li>{@linkplain #getParamSpecs() the specification of method parameters},
+ *     <li>{@linkplain #getAllowedModifiers() the set of allowed access modifiers},
+ *     <li>{@linkplain #getValidReturnTypes() the set of valid return types},
+ *     <li>{@linkplain #getAllowedExceptions() the set of allowed exceptions}, that the method
+ * declares to throw (empty by default),
  * </ul>
  *
  * @param <H> the type of the handler method
@@ -61,7 +58,7 @@
  * @author Alex Tymchenko
  */
 public abstract class MethodSignature<H extends HandlerMethod<?, ?, E, ?>,
-                                      E extends MessageEnvelope<?, ?, ?>> {
+                                      E extends MessageEnvelope<?, ?, ?>> implements Logging {
 
     private final Class<? extends Annotation> annotation;
 
@@ -118,10 +115,18 @@ public boolean matches(Method method) throws SignatureMismatchException {
         }
         Collection<SignatureMismatch> mismatches = match(method);
         boolean hasErrors = mismatches.stream()
-                                      .anyMatch(mismatch -> ERROR == mismatch.getSeverity());
+                                      .anyMatch(SignatureMismatch::isError);
+        List<SignatureMismatch> warnings =  mismatches.stream()
+                                                      .filter(SignatureMismatch::isWarning)
+                                                      .collect(toList());
         if (hasErrors) {
             throw new SignatureMismatchException(mismatches);
         }
+        if (!warnings.isEmpty()) {
+            warnings.stream()
+                    .map(SignatureMismatch::toString)
+                    .forEach(this::_warn);
+        }
         return true;
     }
 

server/src/main/java/io/spine/server/model/declare/SignatureMismatch.java

@@ -61,11 +61,14 @@ private SignatureMismatch(MatchCriterion criterion, Object[] values) {
         message = criterion.formatMsg(values);
     }
 
-    /**
-     * Returns the severity of the mismatch.
-     */
-    Severity getSeverity() {
-        return severity;
+    /** Returns whether this mismatch is of {@code ERROR} severity. */
+    boolean isError() {
+        return severity == Severity.ERROR;
+    }
+
+    /** Returns whether this mismatch is of {@code WARN} severity. */
+    boolean isWarning() {
+        return severity == Severity.WARN;
     }
 
     /**