Check actual restriction class instead of inheritance distance

This makes it possible to use non-relaxed created restriction beans
and produced restriction beans that do only have Restriction as type
of the proxy but not the real class of the contextual instance.

Author: Vampire

src/javacordIntegTest/groovy/net/kautler/command/integ/test/javacord/restriction/ProducedRestrictionIntegTest.groovy

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2022 Björn Kautler
+ *
+ * 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
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.kautler.command.integ.test.javacord.restriction
+
+import javax.enterprise.context.ApplicationScoped
+import javax.enterprise.event.ObservesAsync
+import javax.enterprise.inject.Produces
+import javax.enterprise.inject.Vetoed
+
+import net.kautler.command.api.CommandContext
+import net.kautler.command.api.annotation.RestrictedTo
+import net.kautler.command.api.event.javacord.CommandNotAllowedEventJavacord
+import net.kautler.command.api.restriction.Restriction
+import net.kautler.command.integ.test.javacord.PingIntegTest
+import net.kautler.command.integ.test.spock.AddBean
+import net.kautler.command.restriction.RestrictionLookup
+import org.javacord.api.entity.channel.ServerTextChannel
+import org.javacord.api.entity.message.Message
+import spock.lang.Specification
+import spock.lang.Subject
+import spock.util.concurrent.BlockingVariable
+
+@Subject(RestrictionLookup)
+class ProducedRestrictionIntegTest extends Specification {
+    @AddBean(RestrictionProducer)
+    @AddBean(PingCommand)
+    def 'produced restrictions should be usable'(ServerTextChannel serverTextChannelAsUser) {
+        given:
+            def commandNotAllowedEventReceived = new BlockingVariable<Boolean>(System.properties.testResponseTimeout as double)
+            PingCommand.commandNotAllowedEventReceived = commandNotAllowedEventReceived
+
+        when:
+            serverTextChannelAsUser
+                    .sendMessage('!ping')
+                    .join()
+
+        then:
+            commandNotAllowedEventReceived.get()
+    }
+
+    @RestrictedTo(Restriction1)
+    static class PingCommand extends PingIntegTest.PingCommand {
+        static commandNotAllowedEventReceived
+
+        void handleCommandNotAllowedEvent(@ObservesAsync CommandNotAllowedEventJavacord commandNotAllowedEvent) {
+            commandNotAllowedEventReceived?.set(commandNotAllowedEvent)
+        }
+    }
+
+    static class Restriction1 implements Restriction<Message> {
+        @Override
+        boolean allowCommand(CommandContext<? extends Message> commandContext) {
+            false
+        }
+    }
+
+    @Vetoed
+    @ApplicationScoped
+    static class RestrictionProducer {
+        @Produces
+        @ApplicationScoped
+        Restriction<Message> restriction = new Restriction1()
+    }
+}

src/main/java/net/kautler/command/api/restriction/Restriction.java

@@ -24,6 +24,17 @@
  * @param <M> the class of the messages for which this restriction can check allowance
  */
 public interface Restriction<M> {
+    /**
+     * Returns the real class of this restriction. Subclasses usually do not need to overwrite this method as the
+     * default implementation should be appropriate. This is necessary as CDI implementations that create
+     * proxies might not provide the real class that is necessary for restriction lookup.
+     *
+     * @return the real class of this restriction
+     */
+    default Class<?> getRealClass() {
+        return this.getClass();
+    }
+
     /**
      * Returns whether a command caused by the given command context should be allowed by this restriction or not.
      *

src/main/java/net/kautler/command/restriction/RestrictionLookup.java

@@ -16,8 +16,6 @@
 
 package net.kautler.command.restriction;
 
-import net.kautler.command.api.restriction.Restriction;
-
 import java.util.Collection;
 import java.util.Map;
 import java.util.Objects;
@@ -26,7 +24,7 @@
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CopyOnWriteArraySet;
 
-import static java.util.Comparator.comparingInt;
+import net.kautler.command.api.restriction.Restriction;
 
 /**
  * A directory of restrictions that can be looked up by their type.
@@ -40,8 +38,7 @@ public class RestrictionLookup<M> {
     private final Set<Restriction<? super M>> restrictions = new CopyOnWriteArraySet<>();
 
     /**
-     * The restrictions by class. As the actual restriction instances are proxied by CDI, this map cannot be
-     * built automatically from the available restrictions, but only on the fly.
+     * The restrictions by real class.
      */
     private final Map<Class<?>, Restriction<? super M>> restrictionByClass = new ConcurrentHashMap<>();
 
@@ -52,7 +49,7 @@ public class RestrictionLookup<M> {
      */
     public void addAllRestrictions(Collection<Restriction<? super M>> restrictions) {
         this.restrictions.addAll(restrictions);
-        restrictionByClass.clear();
+        restrictions.forEach(restriction -> restrictionByClass.put(restriction.getRealClass(), restriction));
     }
 
     /**
@@ -62,30 +59,7 @@ public void addAllRestrictions(Collection<Restriction<? super M>> restrictions)
      * @return the restriction instance that fits to the given class or {@code null}
      */
     public Restriction<? super M> getRestriction(Class<?> restrictionClass) {
-        return restrictionByClass
-                .computeIfAbsent(restrictionClass,
-                        key -> restrictions.stream()
-                                // we cannot use a map as the classes are proxied by CDI
-                                .filter(key::isInstance)
-                                .min(comparingInt(restriction -> getInheritanceDistance(restriction, key)))
-                                .orElse(null));
-    }
-
-    /**
-     * Calculates the distance between the class of the given restriction and one of its ancestors or itself.
-     *
-     * @param restriction      the restriction to check
-     * @param restrictionClass the ancestor or self to calculate distance from
-     * @return the distance between the class of the given restriction and the given class
-     */
-    private static int getInheritanceDistance(Restriction<?> restriction, Class<?> restrictionClass) {
-        int distance = 0;
-        for (Class<?> clazz = restriction.getClass();
-             !clazz.equals(restrictionClass) && restrictionClass.isAssignableFrom(clazz);
-             clazz = clazz.getSuperclass()) {
-            distance++;
-        }
-        return distance;
+        return restrictionByClass.get(restrictionClass);
     }
 
     @Override

src/pitest/java/net/kautler/test/pitest/ExplicitMutationFilter.java

@@ -133,13 +133,6 @@ public class ExplicitMutationFilter implements MutationInterceptor {
                     "()V",
                     "org.pitest.mutationtest.engine.gregor.mutators.InlineConstantMutator",
                     "Substituted 3 with 4"),
-            // this causes an endless for-loop
-            new ExplicitMutationFilterDetails(
-                    "net.kautler.command.restriction.RestrictionLookup",
-                    "getInheritanceDistance",
-                    "(Lnet/kautler/command/api/restriction/Restriction;Ljava/lang/Class;)I",
-                    "org.pitest.mutationtest.engine.gregor.mutators.experimental.NakedReceiverMutator",
-                    "replaced call to java/lang/Class::getSuperclass with receiver"),
             // giving a 4 instead of 3 element array to String.format cannot be killed
             new ExplicitMutationFilterDetails(
                     "net.kautler.command.usage.UsageErrorListener",

src/test/groovy/net/kautler/command/api/CommandHandlerTest.groovy

@@ -66,9 +66,15 @@ class CommandHandlerTest extends Specification {
 
     CommandHandler<Object> commandHandlerDelegate = Mock()
 
-    Restriction<Object> restriction1 = Stub()
+    Restriction<Object> restriction1 = Stub {
+        it.realClass >> { callRealMethod() }
+    }
 
-    Restriction<Object> restriction2 = Stub()
+    // additional interface is just that the two restrictions have different
+    // classes, so that the restriction lookup can handle them properly
+    Restriction<Object> restriction2 = Stub(additionalInterfaces: [Serializable]) {
+        it.realClass >> { callRealMethod() }
+    }
 
     Command<Object> command1 = Mock()
 
@@ -364,7 +370,7 @@ class CommandHandlerTest extends Specification {
         commandsInstance.eachWithIndex { command, i ->
             with(command.ci()) {
                 it.aliases >> ["test$i" as String]
-                it.restrictionChain >> new RestrictionChainElement(Restriction)
+                it.restrictionChain >> new RestrictionChainElement(restriction1.getClass())
             }
         }
         commandHandler.doSetCommands(commandsInstance)

src/test/groovy/net/kautler/command/api/restriction/RestrictionChainElementTest.groovy

@@ -24,11 +24,15 @@ import spock.lang.Subject
 import static org.powermock.reflect.Whitebox.getAllInstanceFields
 
 class RestrictionChainElementTest extends Specification {
-    Restriction<Object> restriction1 = Stub()
+    Restriction<Object> restriction1 = Stub {
+        it.realClass >> { callRealMethod() }
+    }
 
     // additional interface is just that the two restrictions have different
     // classes, so that the restriction lookup can handle them properly
-    Restriction<Object> restriction2 = Stub(additionalInterfaces: [Serializable])
+    Restriction<Object> restriction2 = Stub(additionalInterfaces: [Serializable]) {
+        it.realClass >> { callRealMethod() }
+    }
 
     @Subject
     RestrictionChainElement restrictionChainElement = new RestrictionChainElement(restriction1.getClass())
@@ -348,8 +352,8 @@ class RestrictionChainElementTest extends Specification {
         then:
             toStringResult.contains("$field.name=")
             field.type == String ?
-                    toStringResult.contains("'${field.get(testee)}'") :
-                    toStringResult.contains(String.valueOf(field.get(testee)))
+            toStringResult.contains("'${field.get(testee)}'") :
+            toStringResult.contains(String.valueOf(field.get(testee)))
 
         where:
             [testee, field] << [

src/test/groovy/net/kautler/command/handler/CommandHandlerJavacordTest.groovy

@@ -77,12 +77,13 @@ class CommandHandlerJavacordTest extends Specification {
     }
 
     Restriction<Object> restriction = Stub {
+        it.realClass >> { callRealMethod() }
         allowCommand(_) >> false
     }
 
     Command<Object> command = Stub {
         it.aliases >> ['test']
-        it.restrictionChain >> new RestrictionChainElement(Restriction)
+        it.restrictionChain >> new RestrictionChainElement(restriction.getClass())
     }
 
     TestEventReceiver testEventReceiverDelegate = Mock()

src/test/groovy/net/kautler/command/handler/CommandHandlerJdaTest.groovy

@@ -66,12 +66,13 @@ class CommandHandlerJdaTest extends Specification {
     ShardManager shardManagerInCollection2 = Mock()
 
     Restriction<Object> restriction = Stub {
+        it.realClass >> { callRealMethod() }
         allowCommand(_) >> false
     }
 
     Command<Object> command = Stub {
         it.aliases >> ['test']
-        it.restrictionChain >> new RestrictionChainElement(Restriction)
+        it.restrictionChain >> new RestrictionChainElement(restriction.getClass())
     }
 
     TestEventReceiver testEventReceiverDelegate = Mock()