Make sure test runs with mocked instance of capability

core/src/test/java/feign/BaseBuilderTest.java

@@ -17,10 +17,12 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertNotSame;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.RETURNS_MOCKS;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
 
-import feign.codec.Decoder;
-import feign.codec.Encoder;
-import feign.codec.ErrorDecoder;
 import java.lang.reflect.Field;
 import java.util.List;
 import org.junit.jupiter.api.Test;
@@ -31,26 +33,37 @@ class BaseBuilderTest {
   @Test
   void checkEnrichTouchesAllAsyncBuilderFields()
       throws IllegalArgumentException, IllegalAccessException {
-    test(
-        AsyncFeign.builder()
-            .requestInterceptor(template -> {})
-            .responseInterceptor((ic, c) -> c.next(ic)),
-        14);
+    Capability mockingCapability =
+        test(
+            AsyncFeign.builder()
+                .requestInterceptor(template -> {})
+                .responseInterceptor((ic, c) -> c.next(ic)),
+            14);
+
+    // make sure capability was invoked only once
+    verify(mockingCapability).enrich(any(AsyncClient.class));
   }
 
   @Test
   void checkEnrichTouchesAllBuilderFields()
       throws IllegalArgumentException, IllegalAccessException {
-    test(
-        Feign.builder()
-            .requestInterceptor(template -> {})
-            .responseInterceptor((ic, c) -> c.next(ic)),
-        12);
+    Capability mockingCapability =
+        test(
+            Feign.builder()
+                .requestInterceptor(template -> {})
+                .responseInterceptor((ic, c) -> c.next(ic)),
+            12);
+
+    // make sure capability was invoked only once
+    verify(mockingCapability).enrich(any(Client.class));
   }
 
-  private void test(BaseBuilder<?, ?> builder, int expectedFieldsCount)
+  private Capability test(BaseBuilder<?, ?> builder, int expectedFieldsCount)
       throws IllegalArgumentException, IllegalAccessException {
-    Capability mockingCapability = new MockingCapability();
+    Capability mockingCapability = mock(Capability.class, RETURNS_MOCKS);
+    doAnswer(inv -> inv.getArgument(0, BaseBuilder.class))
+        .when(mockingCapability)
+        .beforeBuild(any(BaseBuilder.class));
 
     BaseBuilder<?, ?> enriched = builder.addCapability(mockingCapability).enrich();
 
@@ -69,100 +82,10 @@ private void test(BaseBuilder<?, ?> builder, int expectedFieldsCount)
           .isTrue();
       assertNotSame(builder, enriched);
     }
-  }
-
-  private final class MockingCapability implements Capability {
-
-    @Override
-    @SuppressWarnings("unchecked")
-    public <C> AsyncContextSupplier<C> enrich(AsyncContextSupplier<C> asyncContextSupplier) {
-      return (AsyncContextSupplier<C>) Mockito.mock(AsyncContextSupplier.class);
-    }
-
-    @Override
-    public AsyncResponseHandler enrich(AsyncResponseHandler asyncResponseHandler) {
-      return Mockito.mock(AsyncResponseHandler.class);
-    }
-
-    @Override
-    public ResponseInterceptor.Chain enrich(ResponseInterceptor.Chain chain) {
-      return Mockito.mock(ResponseInterceptor.Chain.class);
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    public AsyncClient<Object> enrich(AsyncClient<Object> client) {
-      return (AsyncClient<Object>) Mockito.mock(AsyncClient.class);
-    }
-
-    @Override
-    public Client enrich(Client client) {
-      return Mockito.mock(Client.class);
-    }
-
-    @Override
-    public Contract enrich(Contract contract) {
-      return Mockito.mock(Contract.class);
-    }
-
-    @Override
-    public Decoder enrich(Decoder decoder) {
-      return Mockito.mock(Decoder.class);
-    }
-
-    @Override
-    public ErrorDecoder enrich(ErrorDecoder decoder) {
-      return Mockito.mock(ErrorDecoder.class);
-    }
 
-    @Override
-    public Encoder enrich(Encoder encoder) {
-      return Mockito.mock(Encoder.class);
-    }
-
-    @Override
-    public InvocationHandlerFactory enrich(InvocationHandlerFactory invocationHandlerFactory) {
-      return Mockito.mock(InvocationHandlerFactory.class);
-    }
-
-    @Override
-    public Logger.Level enrich(Logger.Level level) {
-      return Mockito.mock(Logger.Level.class);
-    }
-
-    @Override
-    public Logger enrich(Logger logger) {
-      return Mockito.mock(Logger.class);
-    }
-
-    @Override
-    public MethodInfoResolver enrich(MethodInfoResolver methodInfoResolver) {
-      return Mockito.mock(MethodInfoResolver.class);
-    }
+    // make sure capability was invoked only once
+    verify(mockingCapability).beforeBuild(any(BaseBuilder.class));
 
-    @Override
-    public Request.Options enrich(Request.Options options) {
-      return Mockito.mock(Request.Options.class);
-    }
-
-    @Override
-    public QueryMapEncoder enrich(QueryMapEncoder queryMapEncoder) {
-      return Mockito.mock(QueryMapEncoder.class);
-    }
-
-    @Override
-    public RequestInterceptor enrich(RequestInterceptor requestInterceptor) {
-      return Mockito.mock(RequestInterceptor.class);
-    }
-
-    @Override
-    public ResponseInterceptor enrich(ResponseInterceptor responseInterceptor) {
-      return Mockito.mock(ResponseInterceptor.class);
-    }
-
-    @Override
-    public Retryer enrich(Retryer retryer) {
-      return Mockito.mock(Retryer.class);
-    }
+    return mockingCapability;
   }
 }