From f7b184c4c37921e871e2a85e850dcfd8e8f5f9bb Mon Sep 17 00:00:00 2001 From: Dave Syer Date: Mon, 17 Sep 2018 14:48:40 +0100 Subject: [PATCH] Revert to more convenient signature in FunctionCatalog --- .../function/context/FunctionCatalog.java | 2 +- .../catalog/InMemoryFunctionCatalog.java | 2 +- ...ntextFunctionCatalogAutoConfiguration.java | 2 +- .../context/FunctionRegistrationTests.java | 8 +- .../function/context/FunctionTypeTests.java | 2 +- .../BeanFactoryFunctionCatalogTests.java | 29 +++--- ...FunctionCatalogAutoConfigurationTests.java | 95 +++++++++---------- ...ontextFunctionCatalogInitializerTests.java | 8 +- .../ContextFunctionPostProcessorTests.java | 23 +++-- .../FunctionCreatorConfiguration.java | 3 +- .../deployer/SingleEntryFunctionRegistry.java | 2 +- 11 files changed, 84 insertions(+), 92 deletions(-) diff --git a/spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/FunctionCatalog.java b/spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/FunctionCatalog.java index d5f005c5d..c8632c85d 100644 --- a/spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/FunctionCatalog.java +++ b/spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/FunctionCatalog.java @@ -43,7 +43,7 @@ public interface FunctionCatalog { * @param name the name of the functional interface. Must not be null; * @return instance of the functional interface registered with this catalog */ - T lookup(Class type, String name); + T lookup(Class type, String name); Set getNames(Class type); diff --git a/spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/catalog/InMemoryFunctionCatalog.java b/spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/catalog/InMemoryFunctionCatalog.java index 6841bcea8..f31875f0e 100644 --- a/spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/catalog/InMemoryFunctionCatalog.java +++ b/spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/catalog/InMemoryFunctionCatalog.java @@ -118,7 +118,7 @@ public class InMemoryFunctionCatalog @Override @SuppressWarnings("unchecked") - public T lookup(Class type, String name) { + public T lookup(Class type, String name) { T function = null; if (type == null) { function = (T) functions.values().stream().filter(map -> map.get(name) != null).map(map -> map.get(name)).findFirst().orElse(null); diff --git a/spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/config/ContextFunctionCatalogAutoConfiguration.java b/spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/config/ContextFunctionCatalogAutoConfiguration.java index 7582c41b1..fbc252484 100644 --- a/spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/config/ContextFunctionCatalogAutoConfiguration.java +++ b/spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/config/ContextFunctionCatalogAutoConfiguration.java @@ -119,7 +119,7 @@ public class ContextFunctionCatalogAutoConfiguration { @Override @SuppressWarnings("unchecked") - public T lookup(Class type, String name) { + public T lookup(Class type, String name) { T function = null; if (type == null) { function = (T) processor.lookupFunction(name); diff --git a/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/FunctionRegistrationTests.java b/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/FunctionRegistrationTests.java index 62a592e0c..cf30ca2ef 100644 --- a/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/FunctionRegistrationTests.java +++ b/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/FunctionRegistrationTests.java @@ -29,16 +29,16 @@ public class FunctionRegistrationTests { @Test public void noTypeByDefault() { - FunctionRegistration registration = new FunctionRegistration<>(new Foos()) - .names("foos"); + FunctionRegistration registration = new FunctionRegistration<>(new Foos(), + "foos"); assertThat(registration.getType()).isNull(); assertThat(registration.getNames()).contains("foos"); } @Test public void wrap() { - FunctionRegistration registration = new FunctionRegistration<>(new Foos()) - .names("foos").type(FunctionType.of(Foos.class).getType()); + FunctionRegistration registration = new FunctionRegistration<>(new Foos(), + "foos").type(FunctionType.of(Foos.class).getType()); FunctionRegistration other = registration.wrap(); assertThat(registration.getType().isWrapper()).isFalse(); assertThat(other.getType().isWrapper()).isTrue(); diff --git a/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/FunctionTypeTests.java b/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/FunctionTypeTests.java index 5534ae794..5f0411788 100644 --- a/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/FunctionTypeTests.java +++ b/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/FunctionTypeTests.java @@ -250,7 +250,7 @@ public class FunctionTypeTests { private static class SupplierOfRegistrationOfIntegerToString implements Supplier>> { @Override public FunctionRegistration> get() { - return new FunctionRegistration>(new IntegerToString()); + return new FunctionRegistration>(new IntegerToString(), "ints"); } } diff --git a/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/config/BeanFactoryFunctionCatalogTests.java b/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/config/BeanFactoryFunctionCatalogTests.java index 55e0fdac5..22029971e 100644 --- a/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/config/BeanFactoryFunctionCatalogTests.java +++ b/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/config/BeanFactoryFunctionCatalogTests.java @@ -47,7 +47,7 @@ public class BeanFactoryFunctionCatalogTests { @Test public void basicRegistrationFeatures() { - processor.register(new FunctionRegistration<>(new Foos()).names("foos")); + processor.register(new FunctionRegistration<>(new Foos(), "foos")); Function, Flux> foos = processor.lookup(Function.class, "foos"); assertThat(foos.apply(Flux.just(2)).blockFirst()).isEqualTo("4"); @@ -55,7 +55,7 @@ public class BeanFactoryFunctionCatalogTests { @Test public void lookupFunctionWithEmptyName() { - processor.register(new FunctionRegistration<>(new Foos()).names("foos")); + processor.register(new FunctionRegistration<>(new Foos(), "foos")); Function, Flux> foos = processor.lookup(Function.class, ""); assertThat(foos.apply(Flux.just(2)).blockFirst()).isEqualTo("4"); } @@ -70,7 +70,7 @@ public class BeanFactoryFunctionCatalogTests { @Test public void registerFunctionWithType() { processor.register(new FunctionRegistration>( - (Integer i) -> "i=" + i).names("foos").type( + (Integer i) -> "i=" + i, "foos").type( FunctionType.from(Integer.class).to(String.class).getType())); Function, Flux> foos = processor.lookup(Function.class, ""); assertThat(foos.apply(Flux.just(2)).blockFirst()).isEqualTo("i=2"); @@ -80,7 +80,7 @@ public class BeanFactoryFunctionCatalogTests { public void registerFunctionWithFluxType() { processor .register(new FunctionRegistration, Flux>>( - ints -> ints.map(i -> "i=" + i)).names("foos") + ints -> ints.map(i -> "i=" + i), "foos") .type(FunctionType.from(Integer.class).to(String.class) .wrap(Flux.class).getType())); Function, Flux> foos = processor.lookup(Function.class, ""); @@ -92,8 +92,7 @@ public class BeanFactoryFunctionCatalogTests { processor.register( new FunctionRegistration, Mono>>>( flux -> flux.collect(HashMap::new, - (map, word) -> map.merge(word, 1, Integer::sum))) - .names("foos") + (map, word) -> map.merge(word, 1, Integer::sum)), "foos") .type(FunctionType.from(String.class) .to(Map.class) .wrap(Flux.class, Mono.class).getType())); @@ -105,15 +104,15 @@ public class BeanFactoryFunctionCatalogTests { @Test public void lookupNonExistentConsumerWithEmptyName() { - processor.register(new FunctionRegistration<>(new Foos()).names("foos")); + processor.register(new FunctionRegistration<>(new Foos(), "foos")); Consumer> foos = processor.lookup(Consumer.class, ""); assertThat(foos).isNull(); } @Test public void composeFunction() { - processor.register(new FunctionRegistration<>(new Foos()).names("foos")); - processor.register(new FunctionRegistration<>(new Bars()).names("bars")); + processor.register(new FunctionRegistration<>(new Foos(), "foos")); + processor.register(new FunctionRegistration<>(new Bars(), "bars")); Function, Flux> foos = processor.lookup(Function.class, "foos,bars"); assertThat(foos.apply(Flux.just(2)).blockFirst()).isEqualTo("Hello 4"); @@ -121,24 +120,24 @@ public class BeanFactoryFunctionCatalogTests { @Test public void composeSupplier() { - processor.register(new FunctionRegistration<>(new Source()).names("numbers")); - processor.register(new FunctionRegistration<>(new Foos()).names("foos")); + processor.register(new FunctionRegistration<>(new Source(), "numbers")); + processor.register(new FunctionRegistration<>(new Foos(), "foos")); Supplier> foos = processor.lookup(Supplier.class, "numbers,foos"); assertThat(foos.get().blockFirst()).isEqualTo("6"); } @Test public void composeUniqueSupplier() { - processor.register(new FunctionRegistration<>(new Source()).names("numbers")); + processor.register(new FunctionRegistration<>(new Source(), "numbers")); Supplier> foos = processor.lookup(Supplier.class, ""); assertThat(foos.get().blockFirst()).isEqualTo(3); } @Test public void composeConsumer() { - processor.register(new FunctionRegistration<>(new Foos()).names("foos")); + processor.register(new FunctionRegistration<>(new Foos(), "foos")); Sink sink = new Sink(); - processor.register(new FunctionRegistration<>(sink).names("sink")); + processor.register(new FunctionRegistration<>(sink, "sink")); Function, Mono> foos = processor.lookup(Function.class, "foos,sink"); foos.apply(Flux.just(2)).subscribe(); @@ -148,7 +147,7 @@ public class BeanFactoryFunctionCatalogTests { @Test public void composeUniqueConsumer() { Sink sink = new Sink(); - processor.register(new FunctionRegistration<>(sink).names("sink")); + processor.register(new FunctionRegistration<>(sink, "sink")); Function, Mono> foos = processor.lookup(Function.class, ""); foos.apply(Flux.just("2")).subscribe(); assertThat(sink.values).contains("2"); diff --git a/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/config/ContextFunctionCatalogAutoConfigurationTests.java b/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/config/ContextFunctionCatalogAutoConfigurationTests.java index f83303d68..4539fbd81 100644 --- a/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/config/ContextFunctionCatalogAutoConfigurationTests.java +++ b/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/config/ContextFunctionCatalogAutoConfigurationTests.java @@ -27,8 +27,6 @@ import java.util.function.Function; import java.util.function.Supplier; import java.util.stream.Collectors; -import kotlin.jvm.functions.Function0; -import kotlin.jvm.functions.Function1; import org.junit.After; import org.junit.Test; import org.reactivestreams.Publisher; @@ -69,6 +67,8 @@ import org.springframework.util.StreamUtils; import static org.assertj.core.api.Assertions.assertThat; +import kotlin.jvm.functions.Function0; +import kotlin.jvm.functions.Function1; import reactor.core.publisher.Flux; import reactor.core.publisher.Mono; @@ -92,15 +92,14 @@ public class ContextFunctionCatalogAutoConfigurationTests { ContextFunctionCatalogAutoConfigurationTests.value = null; } - @SuppressWarnings("unchecked") @Test public void lookUps() { create(SimpleConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(Function.class); - assertThat(catalog.lookup(Function.class, "function")) + assertThat((Function)catalog.lookup(Function.class, "function")) .isInstanceOf(Function.class); assertThat(context.getBean("function2")).isInstanceOf(Function.class); - assertThat(catalog.lookup(Function.class, "function,function2")) + assertThat((Function)catalog.lookup(Function.class, "function,function2")) .isInstanceOf(Function.class); Function, Flux> f = catalog.lookup(Function.class, "function,function2,function3"); @@ -108,10 +107,10 @@ public class ContextFunctionCatalogAutoConfigurationTests { assertThat(f.apply(Flux.just("hello")).blockFirst()) .isEqualTo("HELLOfunction2function3"); assertThat(context.getBean("supplierFoo")).isInstanceOf(Supplier.class); - assertThat(catalog.lookup(Supplier.class, "supplierFoo")) + assertThat((Supplier)catalog.lookup(Supplier.class, "supplierFoo")) .isInstanceOf(Supplier.class); assertThat(context.getBean("supplier_Foo")).isInstanceOf(Supplier.class); - assertThat(catalog.lookup(Supplier.class, "supplier_Foo")) + assertThat((Supplier)catalog.lookup(Supplier.class, "supplier_Foo")) .isInstanceOf(Supplier.class); } @@ -119,9 +118,9 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void ambiguousFunction() { create(AmbiguousConfiguration.class); assertThat(context.getBean("foos")).isInstanceOf(Function.class); - assertThat(catalog.lookup(Function.class, "foos")) + assertThat((Function)catalog.lookup(Function.class, "foos")) .isInstanceOf(Function.class); - assertThat(catalog.lookup(Supplier.class, "foos")) + assertThat((Supplier)catalog.lookup(Supplier.class, "foos")) .isInstanceOf(Supplier.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos"))) .isEqualTo(String.class); @@ -133,7 +132,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void configurationFunction() { create(FunctionConfiguration.class); assertThat(context.getBean("foos")).isInstanceOf(Function.class); - assertThat(catalog.lookup(Function.class, "foos")) + assertThat((Function)catalog.lookup(Function.class, "foos")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos"))) .isEqualTo(String.class); @@ -147,7 +146,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void dependencyInjection() { create(DependencyInjectionConfiguration.class); assertThat(context.getBean("foos")).isInstanceOf(Function.class); - assertThat(catalog.lookup(Function.class, "foos")) + assertThat((Function)catalog.lookup(Function.class, "foos")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos"))) .isEqualTo(String.class); @@ -157,7 +156,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void externalDependencyInjection() { create(ExternalDependencyConfiguration.class); assertThat(context.getBean("foos")).isInstanceOf(Function.class); - assertThat(catalog.lookup(Function.class, "foos")) + assertThat((Function)catalog.lookup(Function.class, "foos")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos"))) .isEqualTo(String.class); @@ -166,9 +165,9 @@ public class ContextFunctionCatalogAutoConfigurationTests { @Test public void composedFunction() { create(MultipleConfiguration.class); - assertThat(catalog.lookup(Function.class, "foos,bars")) + assertThat((Function)catalog.lookup(Function.class, "foos,bars")) .isInstanceOf(Function.class); - assertThat(catalog.lookup(Function.class, "names,foos")).isNull(); + assertThat((Function)catalog.lookup(Function.class, "names,foos")).isNull(); assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos,bars"))) .isAssignableFrom(String.class); assertThat(inspector.getOutputType(catalog.lookup(Function.class, "foos,bars"))) @@ -178,9 +177,9 @@ public class ContextFunctionCatalogAutoConfigurationTests { @Test public void composedSupplier() { create(MultipleConfiguration.class); - assertThat(catalog.lookup(Supplier.class, "names,foos")) + assertThat((Supplier)catalog.lookup(Supplier.class, "names,foos")) .isInstanceOf(Supplier.class); - assertThat(catalog.lookup(Function.class, "names,foos")).isNull(); + assertThat((Function)catalog.lookup(Function.class, "names,foos")).isNull(); assertThat(inspector.getOutputType(catalog.lookup(Supplier.class, "names,foos"))) .isAssignableFrom(Foo.class); // The input type is the same as the input type of the first element in the chain @@ -191,8 +190,8 @@ public class ContextFunctionCatalogAutoConfigurationTests { @Test public void composedConsumer() { create(MultipleConfiguration.class); - assertThat(catalog.lookup(Consumer.class, "foos,print")).isNull(); - assertThat(catalog.lookup(Function.class, "foos,print")) + assertThat((Consumer)catalog.lookup(Consumer.class, "foos,print")).isNull(); + assertThat((Function)catalog.lookup(Function.class, "foos,print")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos,print"))) .isAssignableFrom(String.class); @@ -205,7 +204,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void genericFunction() { create(GenericConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(Function.class); - assertThat(catalog.lookup(Function.class, "function")) + assertThat((Function)catalog.lookup(Function.class, "function")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "function"))) .isAssignableFrom(Map.class); @@ -217,7 +216,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void fluxMessageFunction() { create(FluxMessageConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(Function.class); - assertThat(catalog.lookup(Function.class, "function")) + assertThat((Function)catalog.lookup(Function.class, "function")) .isInstanceOf(Function.class); assertThat(inspector.isMessage(catalog.lookup(Function.class, "function"))) .isTrue(); @@ -231,7 +230,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void publisherMessageFunction() { create(PublisherMessageConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(Function.class); - assertThat(catalog.lookup(Function.class, "function")) + assertThat((Function)catalog.lookup(Function.class, "function")) .isInstanceOf(Function.class); assertThat(inspector.isMessage(catalog.lookup(Function.class, "function"))) .isTrue(); @@ -245,7 +244,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void monoFunction() { create(MonoConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(Function.class); - assertThat(catalog.lookup(Function.class, "function")) + assertThat((Function)catalog.lookup(Function.class, "function")) .isInstanceOf(Function.class); assertThat(inspector.isMessage(catalog.lookup(Function.class, "function"))) .isFalse(); @@ -261,7 +260,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void messageFunction() { create(MessageConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(Function.class); - assertThat(catalog.lookup(Function.class, "function")) + assertThat((Function)catalog.lookup(Function.class, "function")) .isInstanceOf(Function.class); assertThat(inspector.isMessage(catalog.lookup(Function.class, "function"))) .isTrue(); @@ -275,7 +274,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void genericFluxFunction() { create(GenericFluxConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(Function.class); - assertThat(catalog.lookup(Function.class, "function")) + assertThat((Function)catalog.lookup(Function.class, "function")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "function"))) .isAssignableFrom(Map.class); @@ -287,7 +286,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void externalFunction() { create(ExternalConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(Function.class); - assertThat(catalog.lookup(Function.class, "function")) + assertThat((Function)catalog.lookup(Function.class, "function")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "function"))) .isAssignableFrom(Map.class); @@ -299,7 +298,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void singletonFunction() { create(SingletonConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(Function.class); - assertThat(catalog.lookup(Function.class, "function")) + assertThat((Function)catalog.lookup(Function.class, "function")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "function"))) .isAssignableFrom(Integer.class); @@ -311,7 +310,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void singletonMessageFunction() { create(SingletonMessageConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(Function.class); - assertThat(catalog.lookup(Function.class, "function")) + assertThat((Function)catalog.lookup(Function.class, "function")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "function"))) .isAssignableFrom(Integer.class); @@ -325,7 +324,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void nonParametericTypeFunction() { create(NonParametricTypeSingletonConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(Function.class); - assertThat(catalog.lookup(Function.class, "function")) + assertThat((Function)catalog.lookup(Function.class, "function")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "function"))) .isAssignableFrom(Integer.class); @@ -337,7 +336,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void componentScanBeanFunction() { create(ComponentScanBeanConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(Function.class); - assertThat(catalog.lookup(Function.class, "function")) + assertThat((Function)catalog.lookup(Function.class, "function")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "function"))) .isAssignableFrom(Map.class); @@ -349,7 +348,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void componentScanFunction() { create(ComponentScanConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(Function.class); - assertThat(catalog.lookup(Function.class, "function")) + assertThat((Function)catalog.lookup(Function.class, "function")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "function"))) .isAssignableFrom(Map.class); @@ -362,7 +361,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { try { create("greeter.jar", ComponentScanJarConfiguration.class); assertThat(context.getBean("greeter")).isInstanceOf(Function.class); - assertThat(catalog.lookup(Function.class, "greeter")) + assertThat((Function)catalog.lookup(Function.class, "greeter")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "greeter"))) .isAssignableFrom(String.class); @@ -381,7 +380,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { assertThat(context.getBean("kotlinFunction")).isInstanceOf(Function.class); assertThat(context.getBean("kotlinFunction")).isInstanceOf(Function1.class); - assertThat(catalog.lookup(Function.class, "kotlinFunction")) + assertThat((Function)catalog.lookup(Function.class, "kotlinFunction")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "kotlinFunction"))) .isAssignableFrom(String.class); @@ -390,7 +389,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { assertThat(context.getBean("kotlinConsumer")).isInstanceOf(Consumer.class); assertThat(context.getBean("kotlinConsumer")).isInstanceOf(Function1.class); - assertThat(catalog.lookup(Function.class, "kotlinConsumer")) + assertThat((Function)catalog.lookup(Function.class, "kotlinConsumer")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "kotlinConsumer"))) .isAssignableFrom(String.class); @@ -399,7 +398,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { assertThat(context.getBean("kotlinSupplier")).isInstanceOf(Function0.class); Supplier> supplier = catalog.lookup(Supplier.class, "kotlinSupplier"); supplier.get().subscribe(System.out::println); - assertThat(catalog.lookup(Supplier.class, "kotlinSupplier")) + assertThat((Supplier)catalog.lookup(Supplier.class, "kotlinSupplier")) .isInstanceOf(Supplier.class); assertThat(inspector.getOutputType(catalog.lookup(Supplier.class, "kotlinSupplier"))) .isAssignableFrom(String.class); @@ -417,7 +416,6 @@ public class ContextFunctionCatalogAutoConfigurationTests { } } - @SuppressWarnings("unchecked") @Test public void simpleFunction() { create(SimpleConfiguration.class); @@ -432,7 +430,6 @@ public class ContextFunctionCatalogAutoConfigurationTests { .isEqualTo(inspector.getRegistration(function).getType()); } - @SuppressWarnings("unchecked") @Test public void simpleSupplier() { create(SimpleConfiguration.class); @@ -441,7 +438,6 @@ public class ContextFunctionCatalogAutoConfigurationTests { assertThat(supplier.get().blockFirst()).isEqualTo("hello"); } - @SuppressWarnings("unchecked") @Test public void simpleConsumer() { create(SimpleConfiguration.class); @@ -456,8 +452,8 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void qualifiedBean() { create(QualifiedConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(Function.class); - assertThat(catalog.lookup(Function.class, "function")).isNull(); - assertThat(catalog.lookup(Function.class, "other")) + assertThat((Function)catalog.lookup(Function.class, "function")).isNull(); + assertThat((Function)catalog.lookup(Function.class, "other")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "other"))) .isEqualTo(String.class); @@ -467,9 +463,9 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void aliasBean() { create(AliasConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(Function.class); - assertThat(catalog.lookup(Function.class, "function")) + assertThat((Function)catalog.lookup(Function.class, "function")) .isNotNull(); - assertThat(catalog.lookup(Function.class, "other")) + assertThat((Function)catalog.lookup(Function.class, "other")) .isInstanceOf(Function.class); } @@ -477,10 +473,10 @@ public class ContextFunctionCatalogAutoConfigurationTests { public void registrationBean() { create(RegistrationConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(Function.class); - assertThat(catalog.lookup(Function.class, "function")).isNull(); - assertThat(catalog.lookup(Function.class, "registration")) + assertThat((Function)catalog.lookup(Function.class, "function")).isNull(); + assertThat((Function)catalog.lookup(Function.class, "registration")) .isNull(); - assertThat(catalog.lookup(Function.class, "other")) + assertThat((Function)catalog.lookup(Function.class, "other")) .isInstanceOf(Function.class); } @@ -491,7 +487,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { "spring.cloud.function.compile.foos.inputType=String", "spring.cloud.function.compile.foos.outputType=String"); assertThat(context.getBean("foos")).isInstanceOf(Function.class); - assertThat(catalog.lookup(Function.class, "foos")) + assertThat((Function)catalog.lookup(Function.class, "foos")) .isInstanceOf(Function.class); assertThat(inspector.getInputWrapper(catalog.lookup(Function.class, "foos"))) .isEqualTo(String.class); @@ -507,7 +503,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { create(EmptyConfiguration.class, "spring.cloud.function.imports.foos.location=file:./target/foos.fun"); assertThat(context.getBean("foos")).isInstanceOf(Function.class); - assertThat(catalog.lookup(Function.class, "foos")) + assertThat((Function)catalog.lookup(Function.class, "foos")) .isInstanceOf(Function.class); assertThat(inspector.getInputWrapper(catalog.lookup(Function.class, "foos"))) .isEqualTo(String.class); @@ -520,7 +516,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { + "::set", "spring.cloud.function.compile.foos.type=consumer", "spring.cloud.function.compile.foos.inputType=String"); - assertThat(catalog.lookup(Function.class, "foos")) + assertThat((Function)catalog.lookup(Function.class, "foos")) .isInstanceOf(Function.class); assertThat(inspector.getInputWrapper(catalog.lookup(Function.class, "foos"))) .isEqualTo(String.class); @@ -536,7 +532,7 @@ public class ContextFunctionCatalogAutoConfigurationTests { "spring.cloud.function.compile.foos.lambda=f -> f.subscribe(" + getClass().getName() + "::set)", "spring.cloud.function.compile.foos.type=consumer"); - assertThat(catalog.lookup(Consumer.class, "foos")) + assertThat((Consumer)catalog.lookup(Consumer.class, "foos")) .isInstanceOf(Consumer.class); assertThat(inspector.getInputWrapper(catalog.lookup(Consumer.class, "foos"))) .isEqualTo(Flux.class); @@ -547,12 +543,11 @@ public class ContextFunctionCatalogAutoConfigurationTests { assertThat(ContextFunctionCatalogAutoConfigurationTests.value).isEqualTo("hello"); } - @SuppressWarnings("unchecked") @Test public void factoryBeanFunction() { create(FactoryBeanConfiguration.class); assertThat(this.context.getBean("function")).isInstanceOf(Function.class); - assertThat(this.catalog.lookup(Function.class, "function")) + assertThat((Function)catalog.lookup(Function.class, "function")) .isInstanceOf(Function.class); Function, Flux> f = this.catalog.lookup(Function.class, "function"); diff --git a/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/config/ContextFunctionCatalogInitializerTests.java b/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/config/ContextFunctionCatalogInitializerTests.java index 7e27c1807..337faa73a 100644 --- a/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/config/ContextFunctionCatalogInitializerTests.java +++ b/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/config/ContextFunctionCatalogInitializerTests.java @@ -64,7 +64,7 @@ public class ContextFunctionCatalogInitializerTests { public void lookUps() { create(SimpleConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(FunctionRegistration.class); - assertThat(catalog.lookup(Function.class, "function")) + assertThat((Function)catalog.lookup(Function.class, "function")) .isInstanceOf(Function.class); // TODO: support for function composition } @@ -73,7 +73,7 @@ public class ContextFunctionCatalogInitializerTests { public void missingType() { create(MissingTypeConfiguration.class); assertThat(context.getBean("function")).isInstanceOf(FunctionRegistration.class); - assertThat(catalog.lookup(Function.class, "function")) + assertThat((Function)catalog.lookup(Function.class, "function")) .isInstanceOf(Function.class); // TODO: support for type inference from functional bean regsitrations } @@ -82,7 +82,7 @@ public class ContextFunctionCatalogInitializerTests { public void configurationFunction() { create(FunctionConfiguration.class); assertThat(context.getBean("foos")).isInstanceOf(Function.class); - assertThat(catalog.lookup(Function.class, "foos")) + assertThat((Function)catalog.lookup(Function.class, "foos")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos"))) .isEqualTo(String.class); @@ -96,7 +96,7 @@ public class ContextFunctionCatalogInitializerTests { public void dependencyInjection() { create(DependencyInjectionConfiguration.class); assertThat(context.getBean("foos")).isInstanceOf(FunctionRegistration.class); - assertThat(catalog.lookup(Function.class, "foos")) + assertThat((Function)catalog.lookup(Function.class, "foos")) .isInstanceOf(Function.class); assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos"))) .isEqualTo(String.class); diff --git a/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/config/ContextFunctionPostProcessorTests.java b/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/config/ContextFunctionPostProcessorTests.java index b6aaf6897..0c46fec09 100644 --- a/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/config/ContextFunctionPostProcessorTests.java +++ b/spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/config/ContextFunctionPostProcessorTests.java @@ -62,7 +62,7 @@ public class ContextFunctionPostProcessorTests { @Test public void basicRegistrationFeatures() { - processor.register(new FunctionRegistration<>(new Foos()).names("foos")); + processor.register(new FunctionRegistration<>(new Foos(), "foos")); @SuppressWarnings("unchecked") Function, Flux> foos = (Function, Flux>) processor .lookupFunction("foos"); @@ -71,8 +71,7 @@ public class ContextFunctionPostProcessorTests { @Test public void registrationThroughMerge() { - FunctionRegistration registration = new FunctionRegistration<>(new Foos()) - .names("foos"); + FunctionRegistration registration = new FunctionRegistration<>(new Foos(), "foos"); processor.merge(Collections.singletonMap("foos", registration), Collections.emptyMap(), Collections.emptyMap(), Collections.emptyMap()); @SuppressWarnings("unchecked") @@ -93,8 +92,8 @@ public class ContextFunctionPostProcessorTests { @Test public void composeWithComma() { - processor.register(new FunctionRegistration<>(new Foos()).names("foos")); - processor.register(new FunctionRegistration<>(new Bars()).names("bars")); + processor.register(new FunctionRegistration<>(new Foos(), "foos")); + processor.register(new FunctionRegistration<>(new Bars(), "bars")); @SuppressWarnings("unchecked") Function, Flux> foos = (Function, Flux>) processor .lookupFunction("foos,bars"); @@ -105,8 +104,8 @@ public class ContextFunctionPostProcessorTests { @Test public void compose() { - processor.register(new FunctionRegistration<>(new Foos()).names("foos")); - processor.register(new FunctionRegistration<>(new Bars()).names("bars")); + processor.register(new FunctionRegistration<>(new Foos(), "foos")); + processor.register(new FunctionRegistration<>(new Bars(), "bars")); @SuppressWarnings("unchecked") Function, Flux> foos = (Function, Flux>) processor .lookupFunction("foos|bars"); @@ -117,8 +116,8 @@ public class ContextFunctionPostProcessorTests { @Test public void composeWrapper() { - processor.register(new FunctionRegistration<>(new WrappedSource()).names("ints")); - processor.register(new FunctionRegistration<>(new Foos()).names("foos")); + processor.register(new FunctionRegistration<>(new WrappedSource(), "ints")); + processor.register(new FunctionRegistration<>(new Foos(), "foos")); @SuppressWarnings("unchecked") Supplier> foos = (Supplier>) processor .lookupSupplier("ints|foos"); @@ -133,7 +132,7 @@ public class ContextFunctionPostProcessorTests { public void isolatedFunction() { contextClassLoader = ClassUtils .overrideThreadContextClassLoader(getClass().getClassLoader()); - processor.register(new FunctionRegistration<>(create(Foos.class)).names("foos")); + processor.register(new FunctionRegistration<>(create(Foos.class), "foos")); @SuppressWarnings("unchecked") Function, Flux> foos = (Function, Flux>) processor .lookupFunction("foos"); @@ -145,7 +144,7 @@ public class ContextFunctionPostProcessorTests { contextClassLoader = ClassUtils .overrideThreadContextClassLoader(getClass().getClassLoader()); processor.register( - new FunctionRegistration<>(create(Source.class)).names("source")); + new FunctionRegistration<>(create(Source.class), "source")); @SuppressWarnings("unchecked") Supplier> source = (Supplier>) processor .lookupSupplier("source"); @@ -157,7 +156,7 @@ public class ContextFunctionPostProcessorTests { contextClassLoader = ClassUtils .overrideThreadContextClassLoader(getClass().getClassLoader()); Object target = create(Sink.class); - processor.register(new FunctionRegistration<>(target).names("sink")); + processor.register(new FunctionRegistration<>(target, "sink")); @SuppressWarnings("unchecked") Function, Mono> sink = (Function, Mono>) processor .lookupFunction("sink"); diff --git a/spring-cloud-function-deployer/src/main/java/org/springframework/cloud/function/deployer/FunctionCreatorConfiguration.java b/spring-cloud-function-deployer/src/main/java/org/springframework/cloud/function/deployer/FunctionCreatorConfiguration.java index f31298d8a..3b5b867b0 100644 --- a/spring-cloud-function-deployer/src/main/java/org/springframework/cloud/function/deployer/FunctionCreatorConfiguration.java +++ b/spring-cloud-function-deployer/src/main/java/org/springframework/cloud/function/deployer/FunctionCreatorConfiguration.java @@ -379,8 +379,7 @@ class FunctionCreatorConfiguration { return; } FunctionRegistration registration = new FunctionRegistration( - bean).names( - FunctionProperties.functionName(counter.getAndIncrement())); + bean, FunctionProperties.functionName(counter.getAndIncrement())); if (this.runner != null) { if (this.runner.containsBean(FunctionInspector.class.getName())) { Object inspector = this.runner diff --git a/spring-cloud-function-deployer/src/main/java/org/springframework/cloud/function/deployer/SingleEntryFunctionRegistry.java b/spring-cloud-function-deployer/src/main/java/org/springframework/cloud/function/deployer/SingleEntryFunctionRegistry.java index b398e25db..8703e8849 100644 --- a/spring-cloud-function-deployer/src/main/java/org/springframework/cloud/function/deployer/SingleEntryFunctionRegistry.java +++ b/spring-cloud-function-deployer/src/main/java/org/springframework/cloud/function/deployer/SingleEntryFunctionRegistry.java @@ -37,7 +37,7 @@ public class SingleEntryFunctionRegistry implements FunctionRegistry { } @Override - public T lookup(Class type, String name) { + public T lookup(Class type, String name) { return this.name.equals(name) ? this.delegate.lookup(type, name) : null; }