SpringCloud/spring-cloud-function
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Revert to more convenient signature in FunctionCatalog

Browse Source
This commit is contained in:
Dave Syer
2018-09-17 14:48:40 +01:00
parent 033ab38579
commit f7b184c4c3
11 changed files with 84 additions and 92 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/FunctionCatalog.java
View File

@@ -43,7 +43,7 @@ public interface FunctionCatalog {
* @param name the name of the functional interface. Must not be null; * @param name the name of the functional interface. Must not be null;
* @return instance of the functional interface registered with this catalog * @return instance of the functional interface registered with this catalog
*/ */
<T> T lookup(Class<T> type, String name); <T> T lookup(Class<?> type, String name);
Set<String> getNames(Class<?> type); Set<String> getNames(Class<?> type);

2
spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/catalog/InMemoryFunctionCatalog.java
View File

@@ -118,7 +118,7 @@ public class InMemoryFunctionCatalog
@Override @Override
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public <T> T lookup(Class<T> type, String name) { public <T> T lookup(Class<?> type, String name) {
T function = null; T function = null;
if (type == null) { if (type == null) {
function = (T) functions.values().stream().filter(map -> map.get(name) != null).map(map -> map.get(name)).findFirst().orElse(null); function = (T) functions.values().stream().filter(map -> map.get(name) != null).map(map -> map.get(name)).findFirst().orElse(null);

2
spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/config/ContextFunctionCatalogAutoConfiguration.java
View File

@@ -119,7 +119,7 @@ public class ContextFunctionCatalogAutoConfiguration {
@Override @Override
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public <T> T lookup(Class<T> type, String name) { public <T> T lookup(Class<?> type, String name) {
T function = null; T function = null;
if (type == null) { if (type == null) {
function = (T) processor.lookupFunction(name); function = (T) processor.lookupFunction(name);

8
spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/FunctionRegistrationTests.java
View File

@@ -29,16 +29,16 @@ public class FunctionRegistrationTests {
@Test @Test
public void noTypeByDefault() { public void noTypeByDefault() {
FunctionRegistration<?> registration = new FunctionRegistration<>(new Foos()) FunctionRegistration<?> registration = new FunctionRegistration<>(new Foos(),
.names("foos"); "foos");
assertThat(registration.getType()).isNull(); assertThat(registration.getType()).isNull();
assertThat(registration.getNames()).contains("foos"); assertThat(registration.getNames()).contains("foos");
} }
@Test @Test
public void wrap() { public void wrap() {
FunctionRegistration<Foos> registration = new FunctionRegistration<>(new Foos()) FunctionRegistration<Foos> registration = new FunctionRegistration<>(new Foos(),
.names("foos").type(FunctionType.of(Foos.class).getType()); "foos").type(FunctionType.of(Foos.class).getType());
FunctionRegistration<?> other = registration.wrap(); FunctionRegistration<?> other = registration.wrap();
assertThat(registration.getType().isWrapper()).isFalse(); assertThat(registration.getType().isWrapper()).isFalse();
assertThat(other.getType().isWrapper()).isTrue(); assertThat(other.getType().isWrapper()).isTrue();

2
spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/FunctionTypeTests.java
View File

@@ -250,7 +250,7 @@ public class FunctionTypeTests {
private static class SupplierOfRegistrationOfIntegerToString implements Supplier<FunctionRegistration<Function<Integer, String>>> { private static class SupplierOfRegistrationOfIntegerToString implements Supplier<FunctionRegistration<Function<Integer, String>>> {
@Override @Override
public FunctionRegistration<Function<Integer, String>> get() { public FunctionRegistration<Function<Integer, String>> get() {
return new FunctionRegistration<Function<Integer,String>>(new IntegerToString()); return new FunctionRegistration<Function<Integer,String>>(new IntegerToString(), "ints");
} }
} }

29
spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/config/BeanFactoryFunctionCatalogTests.java
View File

@@ -47,7 +47,7 @@ public class BeanFactoryFunctionCatalogTests {
@Test @Test
public void basicRegistrationFeatures() { public void basicRegistrationFeatures() {
processor.register(new FunctionRegistration<>(new Foos()).names("foos")); processor.register(new FunctionRegistration<>(new Foos(), "foos"));
Function<Flux<Integer>, Flux<String>> foos = processor.lookup(Function.class, Function<Flux<Integer>, Flux<String>> foos = processor.lookup(Function.class,
"foos"); "foos");
assertThat(foos.apply(Flux.just(2)).blockFirst()).isEqualTo("4"); assertThat(foos.apply(Flux.just(2)).blockFirst()).isEqualTo("4");
@@ -55,7 +55,7 @@ public class BeanFactoryFunctionCatalogTests {
@Test @Test
public void lookupFunctionWithEmptyName() { public void lookupFunctionWithEmptyName() {
processor.register(new FunctionRegistration<>(new Foos()).names("foos")); processor.register(new FunctionRegistration<>(new Foos(), "foos"));
Function<Flux<Integer>, Flux<String>> foos = processor.lookup(Function.class, ""); Function<Flux<Integer>, Flux<String>> foos = processor.lookup(Function.class, "");
assertThat(foos.apply(Flux.just(2)).blockFirst()).isEqualTo("4"); assertThat(foos.apply(Flux.just(2)).blockFirst()).isEqualTo("4");
} }
@@ -70,7 +70,7 @@ public class BeanFactoryFunctionCatalogTests {
@Test @Test
public void registerFunctionWithType() { public void registerFunctionWithType() {
processor.register(new FunctionRegistration<Function<Integer, String>>( processor.register(new FunctionRegistration<Function<Integer, String>>(
(Integer i) -> "i=" + i).names("foos").type( (Integer i) -> "i=" + i, "foos").type(
FunctionType.from(Integer.class).to(String.class).getType())); FunctionType.from(Integer.class).to(String.class).getType()));
Function<Flux<Integer>, Flux<String>> foos = processor.lookup(Function.class, ""); Function<Flux<Integer>, Flux<String>> foos = processor.lookup(Function.class, "");
assertThat(foos.apply(Flux.just(2)).blockFirst()).isEqualTo("i=2"); assertThat(foos.apply(Flux.just(2)).blockFirst()).isEqualTo("i=2");
@@ -80,7 +80,7 @@ public class BeanFactoryFunctionCatalogTests {
public void registerFunctionWithFluxType() { public void registerFunctionWithFluxType() {
processor processor
.register(new FunctionRegistration<Function<Flux<Integer>, Flux<String>>>( .register(new FunctionRegistration<Function<Flux<Integer>, Flux<String>>>(
ints -> ints.map(i -> "i=" + i)).names("foos") ints -> ints.map(i -> "i=" + i), "foos")
.type(FunctionType.from(Integer.class).to(String.class) .type(FunctionType.from(Integer.class).to(String.class)
.wrap(Flux.class).getType())); .wrap(Flux.class).getType()));
Function<Flux<Integer>, Flux<String>> foos = processor.lookup(Function.class, ""); Function<Flux<Integer>, Flux<String>> foos = processor.lookup(Function.class, "");
@@ -92,8 +92,7 @@ public class BeanFactoryFunctionCatalogTests {
processor.register( processor.register(
new FunctionRegistration<Function<Flux<String>, Mono<Map<String, Integer>>>>( new FunctionRegistration<Function<Flux<String>, Mono<Map<String, Integer>>>>(
flux -> flux.collect(HashMap::new, flux -> flux.collect(HashMap::new,
(map, word) -> map.merge(word, 1, Integer::sum))) (map, word) -> map.merge(word, 1, Integer::sum)), "foos")
.names("foos")
.type(FunctionType.from(String.class) .type(FunctionType.from(String.class)
.to(Map.class) .to(Map.class)
.wrap(Flux.class, Mono.class).getType())); .wrap(Flux.class, Mono.class).getType()));
@@ -105,15 +104,15 @@ public class BeanFactoryFunctionCatalogTests {
@Test @Test
public void lookupNonExistentConsumerWithEmptyName() { public void lookupNonExistentConsumerWithEmptyName() {
processor.register(new FunctionRegistration<>(new Foos()).names("foos")); processor.register(new FunctionRegistration<>(new Foos(), "foos"));
Consumer<Flux<String>> foos = processor.lookup(Consumer.class, ""); Consumer<Flux<String>> foos = processor.lookup(Consumer.class, "");
assertThat(foos).isNull(); assertThat(foos).isNull();
} }
@Test @Test
public void composeFunction() { public void composeFunction() {
processor.register(new FunctionRegistration<>(new Foos()).names("foos")); processor.register(new FunctionRegistration<>(new Foos(), "foos"));
processor.register(new FunctionRegistration<>(new Bars()).names("bars")); processor.register(new FunctionRegistration<>(new Bars(), "bars"));
Function<Flux<Integer>, Flux<String>> foos = processor.lookup(Function.class, Function<Flux<Integer>, Flux<String>> foos = processor.lookup(Function.class,
"foos,bars"); "foos,bars");
assertThat(foos.apply(Flux.just(2)).blockFirst()).isEqualTo("Hello 4"); assertThat(foos.apply(Flux.just(2)).blockFirst()).isEqualTo("Hello 4");
@@ -121,24 +120,24 @@ public class BeanFactoryFunctionCatalogTests {
@Test @Test
public void composeSupplier() { public void composeSupplier() {
processor.register(new FunctionRegistration<>(new Source()).names("numbers")); processor.register(new FunctionRegistration<>(new Source(), "numbers"));
processor.register(new FunctionRegistration<>(new Foos()).names("foos")); processor.register(new FunctionRegistration<>(new Foos(), "foos"));
Supplier<Flux<String>> foos = processor.lookup(Supplier.class, "numbers,foos"); Supplier<Flux<String>> foos = processor.lookup(Supplier.class, "numbers,foos");
assertThat(foos.get().blockFirst()).isEqualTo("6"); assertThat(foos.get().blockFirst()).isEqualTo("6");
} }
@Test @Test
public void composeUniqueSupplier() { public void composeUniqueSupplier() {
processor.register(new FunctionRegistration<>(new Source()).names("numbers")); processor.register(new FunctionRegistration<>(new Source(), "numbers"));
Supplier<Flux<Integer>> foos = processor.lookup(Supplier.class, ""); Supplier<Flux<Integer>> foos = processor.lookup(Supplier.class, "");
assertThat(foos.get().blockFirst()).isEqualTo(3); assertThat(foos.get().blockFirst()).isEqualTo(3);
} }
@Test @Test
public void composeConsumer() { public void composeConsumer() {
processor.register(new FunctionRegistration<>(new Foos()).names("foos")); processor.register(new FunctionRegistration<>(new Foos(), "foos"));
Sink sink = new Sink(); Sink sink = new Sink();
processor.register(new FunctionRegistration<>(sink).names("sink")); processor.register(new FunctionRegistration<>(sink, "sink"));
Function<Flux<Integer>, Mono<Void>> foos = processor.lookup(Function.class, Function<Flux<Integer>, Mono<Void>> foos = processor.lookup(Function.class,
"foos,sink"); "foos,sink");
foos.apply(Flux.just(2)).subscribe(); foos.apply(Flux.just(2)).subscribe();
@@ -148,7 +147,7 @@ public class BeanFactoryFunctionCatalogTests {
@Test @Test
public void composeUniqueConsumer() { public void composeUniqueConsumer() {
Sink sink = new Sink(); Sink sink = new Sink();
processor.register(new FunctionRegistration<>(sink).names("sink")); processor.register(new FunctionRegistration<>(sink, "sink"));
Function<Flux<String>, Mono<Void>> foos = processor.lookup(Function.class, ""); Function<Flux<String>, Mono<Void>> foos = processor.lookup(Function.class, "");
foos.apply(Flux.just("2")).subscribe(); foos.apply(Flux.just("2")).subscribe();
assertThat(sink.values).contains("2"); assertThat(sink.values).contains("2");

95
spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/config/ContextFunctionCatalogAutoConfigurationTests.java
View File

@@ -27,8 +27,6 @@ import java.util.function.Function;
import java.util.function.Supplier; import java.util.function.Supplier;
import java.util.stream.Collectors; import java.util.stream.Collectors;
import kotlin.jvm.functions.Function0;
import kotlin.jvm.functions.Function1;
import org.junit.After; import org.junit.After;
import org.junit.Test; import org.junit.Test;
import org.reactivestreams.Publisher; import org.reactivestreams.Publisher;
@@ -69,6 +67,8 @@ import org.springframework.util.StreamUtils;
import static org.assertj.core.api.Assertions.assertThat; 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.Flux;
import reactor.core.publisher.Mono; import reactor.core.publisher.Mono;
@@ -92,15 +92,14 @@ public class ContextFunctionCatalogAutoConfigurationTests {
ContextFunctionCatalogAutoConfigurationTests.value = null; ContextFunctionCatalogAutoConfigurationTests.value = null;
} }
@SuppressWarnings("unchecked")
@Test @Test
public void lookUps() { public void lookUps() {
create(SimpleConfiguration.class); create(SimpleConfiguration.class);
assertThat(context.getBean("function")).isInstanceOf(Function.class); assertThat(context.getBean("function")).isInstanceOf(Function.class);
assertThat(catalog.lookup(Function.class, "function")) assertThat((Function<?,?>)catalog.lookup(Function.class, "function"))
.isInstanceOf(Function.class); .isInstanceOf(Function.class);
assertThat(context.getBean("function2")).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); .isInstanceOf(Function.class);
Function<Flux<String>, Flux<String>> f = catalog.lookup(Function.class, Function<Flux<String>, Flux<String>> f = catalog.lookup(Function.class,
"function,function2,function3"); "function,function2,function3");
@@ -108,10 +107,10 @@ public class ContextFunctionCatalogAutoConfigurationTests {
assertThat(f.apply(Flux.just("hello")).blockFirst()) assertThat(f.apply(Flux.just("hello")).blockFirst())
.isEqualTo("HELLOfunction2function3"); .isEqualTo("HELLOfunction2function3");
assertThat(context.getBean("supplierFoo")).isInstanceOf(Supplier.class); assertThat(context.getBean("supplierFoo")).isInstanceOf(Supplier.class);
assertThat(catalog.lookup(Supplier.class, "supplierFoo")) assertThat((Supplier<?>)catalog.lookup(Supplier.class, "supplierFoo"))
.isInstanceOf(Supplier.class); .isInstanceOf(Supplier.class);
assertThat(context.getBean("supplier_Foo")).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); .isInstanceOf(Supplier.class);
} }
@@ -119,9 +118,9 @@ public class ContextFunctionCatalogAutoConfigurationTests {
public void ambiguousFunction() { public void ambiguousFunction() {
create(AmbiguousConfiguration.class); create(AmbiguousConfiguration.class);
assertThat(context.getBean("foos")).isInstanceOf(Function.class); assertThat(context.getBean("foos")).isInstanceOf(Function.class);
assertThat(catalog.lookup(Function.class, "foos")) assertThat((Function<?,?>)catalog.lookup(Function.class, "foos"))
.isInstanceOf(Function.class); .isInstanceOf(Function.class);
assertThat(catalog.lookup(Supplier.class, "foos")) assertThat((Supplier<?>)catalog.lookup(Supplier.class, "foos"))
.isInstanceOf(Supplier.class); .isInstanceOf(Supplier.class);
assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos"))) assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos")))
.isEqualTo(String.class); .isEqualTo(String.class);
@@ -133,7 +132,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
public void configurationFunction() { public void configurationFunction() {
create(FunctionConfiguration.class); create(FunctionConfiguration.class);
assertThat(context.getBean("foos")).isInstanceOf(Function.class); assertThat(context.getBean("foos")).isInstanceOf(Function.class);
assertThat(catalog.lookup(Function.class, "foos")) assertThat((Function<?,?>)catalog.lookup(Function.class, "foos"))
.isInstanceOf(Function.class); .isInstanceOf(Function.class);
assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos"))) assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos")))
.isEqualTo(String.class); .isEqualTo(String.class);
@@ -147,7 +146,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
public void dependencyInjection() { public void dependencyInjection() {
create(DependencyInjectionConfiguration.class); create(DependencyInjectionConfiguration.class);
assertThat(context.getBean("foos")).isInstanceOf(Function.class); assertThat(context.getBean("foos")).isInstanceOf(Function.class);
assertThat(catalog.lookup(Function.class, "foos")) assertThat((Function<?,?>)catalog.lookup(Function.class, "foos"))
.isInstanceOf(Function.class); .isInstanceOf(Function.class);
assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos"))) assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos")))
.isEqualTo(String.class); .isEqualTo(String.class);
@@ -157,7 +156,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
public void externalDependencyInjection() { public void externalDependencyInjection() {
create(ExternalDependencyConfiguration.class); create(ExternalDependencyConfiguration.class);
assertThat(context.getBean("foos")).isInstanceOf(Function.class); assertThat(context.getBean("foos")).isInstanceOf(Function.class);
assertThat(catalog.lookup(Function.class, "foos")) assertThat((Function<?,?>)catalog.lookup(Function.class, "foos"))
.isInstanceOf(Function.class); .isInstanceOf(Function.class);
assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos"))) assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos")))
.isEqualTo(String.class); .isEqualTo(String.class);
@@ -166,9 +165,9 @@ public class ContextFunctionCatalogAutoConfigurationTests {
@Test @Test
public void composedFunction() { public void composedFunction() {
create(MultipleConfiguration.class); create(MultipleConfiguration.class);
assertThat(catalog.lookup(Function.class, "foos,bars")) assertThat((Function<?,?>)catalog.lookup(Function.class, "foos,bars"))
.isInstanceOf(Function.class); .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"))) assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos,bars")))
.isAssignableFrom(String.class); .isAssignableFrom(String.class);
assertThat(inspector.getOutputType(catalog.lookup(Function.class, "foos,bars"))) assertThat(inspector.getOutputType(catalog.lookup(Function.class, "foos,bars")))
@@ -178,9 +177,9 @@ public class ContextFunctionCatalogAutoConfigurationTests {
@Test @Test
public void composedSupplier() { public void composedSupplier() {
create(MultipleConfiguration.class); create(MultipleConfiguration.class);
assertThat(catalog.lookup(Supplier.class, "names,foos")) assertThat((Supplier<?>)catalog.lookup(Supplier.class, "names,foos"))
.isInstanceOf(Supplier.class); .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"))) assertThat(inspector.getOutputType(catalog.lookup(Supplier.class, "names,foos")))
.isAssignableFrom(Foo.class); .isAssignableFrom(Foo.class);
// The input type is the same as the input type of the first element in the chain // 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 @Test
public void composedConsumer() { public void composedConsumer() {
create(MultipleConfiguration.class); create(MultipleConfiguration.class);
assertThat(catalog.lookup(Consumer.class, "foos,print")).isNull(); assertThat((Consumer<?>)catalog.lookup(Consumer.class, "foos,print")).isNull();
assertThat(catalog.lookup(Function.class, "foos,print")) assertThat((Function<?,?>)catalog.lookup(Function.class, "foos,print"))
.isInstanceOf(Function.class); .isInstanceOf(Function.class);
assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos,print"))) assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos,print")))
.isAssignableFrom(String.class); .isAssignableFrom(String.class);
@@ -205,7 +204,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
public void genericFunction() { public void genericFunction() {
create(GenericConfiguration.class); create(GenericConfiguration.class);
assertThat(context.getBean("function")).isInstanceOf(Function.class); assertThat(context.getBean("function")).isInstanceOf(Function.class);
assertThat(catalog.lookup(Function.class, "function")) assertThat((Function<?,?>)catalog.lookup(Function.class, "function"))
.isInstanceOf(Function.class); .isInstanceOf(Function.class);
assertThat(inspector.getInputType(catalog.lookup(Function.class, "function"))) assertThat(inspector.getInputType(catalog.lookup(Function.class, "function")))
.isAssignableFrom(Map.class); .isAssignableFrom(Map.class);
@@ -217,7 +216,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
public void fluxMessageFunction() { public void fluxMessageFunction() {
create(FluxMessageConfiguration.class); create(FluxMessageConfiguration.class);
assertThat(context.getBean("function")).isInstanceOf(Function.class); assertThat(context.getBean("function")).isInstanceOf(Function.class);
assertThat(catalog.lookup(Function.class, "function")) assertThat((Function<?,?>)catalog.lookup(Function.class, "function"))
.isInstanceOf(Function.class); .isInstanceOf(Function.class);
assertThat(inspector.isMessage(catalog.lookup(Function.class, "function"))) assertThat(inspector.isMessage(catalog.lookup(Function.class, "function")))
.isTrue(); .isTrue();
@@ -231,7 +230,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
public void publisherMessageFunction() { public void publisherMessageFunction() {
create(PublisherMessageConfiguration.class); create(PublisherMessageConfiguration.class);
assertThat(context.getBean("function")).isInstanceOf(Function.class); assertThat(context.getBean("function")).isInstanceOf(Function.class);
assertThat(catalog.lookup(Function.class, "function")) assertThat((Function<?,?>)catalog.lookup(Function.class, "function"))
.isInstanceOf(Function.class); .isInstanceOf(Function.class);
assertThat(inspector.isMessage(catalog.lookup(Function.class, "function"))) assertThat(inspector.isMessage(catalog.lookup(Function.class, "function")))
.isTrue(); .isTrue();
@@ -245,7 +244,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
public void monoFunction() { public void monoFunction() {
create(MonoConfiguration.class); create(MonoConfiguration.class);
assertThat(context.getBean("function")).isInstanceOf(Function.class); assertThat(context.getBean("function")).isInstanceOf(Function.class);
assertThat(catalog.lookup(Function.class, "function")) assertThat((Function<?,?>)catalog.lookup(Function.class, "function"))
.isInstanceOf(Function.class); .isInstanceOf(Function.class);
assertThat(inspector.isMessage(catalog.lookup(Function.class, "function"))) assertThat(inspector.isMessage(catalog.lookup(Function.class, "function")))
.isFalse(); .isFalse();
@@ -261,7 +260,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
public void messageFunction() { public void messageFunction() {
create(MessageConfiguration.class); create(MessageConfiguration.class);
assertThat(context.getBean("function")).isInstanceOf(Function.class); assertThat(context.getBean("function")).isInstanceOf(Function.class);
assertThat(catalog.lookup(Function.class, "function")) assertThat((Function<?,?>)catalog.lookup(Function.class, "function"))
.isInstanceOf(Function.class); .isInstanceOf(Function.class);
assertThat(inspector.isMessage(catalog.lookup(Function.class, "function"))) assertThat(inspector.isMessage(catalog.lookup(Function.class, "function")))
.isTrue(); .isTrue();
@@ -275,7 +274,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
public void genericFluxFunction() { public void genericFluxFunction() {
create(GenericFluxConfiguration.class); create(GenericFluxConfiguration.class);
assertThat(context.getBean("function")).isInstanceOf(Function.class); assertThat(context.getBean("function")).isInstanceOf(Function.class);
assertThat(catalog.lookup(Function.class, "function")) assertThat((Function<?,?>)catalog.lookup(Function.class, "function"))
.isInstanceOf(Function.class); .isInstanceOf(Function.class);
assertThat(inspector.getInputType(catalog.lookup(Function.class, "function"))) assertThat(inspector.getInputType(catalog.lookup(Function.class, "function")))
.isAssignableFrom(Map.class); .isAssignableFrom(Map.class);
@@ -287,7 +286,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
public void externalFunction() { public void externalFunction() {
create(ExternalConfiguration.class); create(ExternalConfiguration.class);
assertThat(context.getBean("function")).isInstanceOf(Function.class); assertThat(context.getBean("function")).isInstanceOf(Function.class);
assertThat(catalog.lookup(Function.class, "function")) assertThat((Function<?,?>)catalog.lookup(Function.class, "function"))
.isInstanceOf(Function.class); .isInstanceOf(Function.class);
assertThat(inspector.getInputType(catalog.lookup(Function.class, "function"))) assertThat(inspector.getInputType(catalog.lookup(Function.class, "function")))
.isAssignableFrom(Map.class); .isAssignableFrom(Map.class);
@@ -299,7 +298,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
public void singletonFunction() { public void singletonFunction() {
create(SingletonConfiguration.class); create(SingletonConfiguration.class);
assertThat(context.getBean("function")).isInstanceOf(Function.class); assertThat(context.getBean("function")).isInstanceOf(Function.class);
assertThat(catalog.lookup(Function.class, "function")) assertThat((Function<?,?>)catalog.lookup(Function.class, "function"))
.isInstanceOf(Function.class); .isInstanceOf(Function.class);
assertThat(inspector.getInputType(catalog.lookup(Function.class, "function"))) assertThat(inspector.getInputType(catalog.lookup(Function.class, "function")))
.isAssignableFrom(Integer.class); .isAssignableFrom(Integer.class);
@@ -311,7 +310,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
public void singletonMessageFunction() { public void singletonMessageFunction() {
create(SingletonMessageConfiguration.class); create(SingletonMessageConfiguration.class);
assertThat(context.getBean("function")).isInstanceOf(Function.class); assertThat(context.getBean("function")).isInstanceOf(Function.class);
assertThat(catalog.lookup(Function.class, "function")) assertThat((Function<?,?>)catalog.lookup(Function.class, "function"))
.isInstanceOf(Function.class); .isInstanceOf(Function.class);
assertThat(inspector.getInputType(catalog.lookup(Function.class, "function"))) assertThat(inspector.getInputType(catalog.lookup(Function.class, "function")))
.isAssignableFrom(Integer.class); .isAssignableFrom(Integer.class);
@@ -325,7 +324,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
public void nonParametericTypeFunction() { public void nonParametericTypeFunction() {
create(NonParametricTypeSingletonConfiguration.class); create(NonParametricTypeSingletonConfiguration.class);
assertThat(context.getBean("function")).isInstanceOf(Function.class); assertThat(context.getBean("function")).isInstanceOf(Function.class);
assertThat(catalog.lookup(Function.class, "function")) assertThat((Function<?,?>)catalog.lookup(Function.class, "function"))
.isInstanceOf(Function.class); .isInstanceOf(Function.class);
assertThat(inspector.getInputType(catalog.lookup(Function.class, "function"))) assertThat(inspector.getInputType(catalog.lookup(Function.class, "function")))
.isAssignableFrom(Integer.class); .isAssignableFrom(Integer.class);
@@ -337,7 +336,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
public void componentScanBeanFunction() { public void componentScanBeanFunction() {
create(ComponentScanBeanConfiguration.class); create(ComponentScanBeanConfiguration.class);
assertThat(context.getBean("function")).isInstanceOf(Function.class); assertThat(context.getBean("function")).isInstanceOf(Function.class);
assertThat(catalog.lookup(Function.class, "function")) assertThat((Function<?,?>)catalog.lookup(Function.class, "function"))
.isInstanceOf(Function.class); .isInstanceOf(Function.class);
assertThat(inspector.getInputType(catalog.lookup(Function.class, "function"))) assertThat(inspector.getInputType(catalog.lookup(Function.class, "function")))
.isAssignableFrom(Map.class); .isAssignableFrom(Map.class);
@@ -349,7 +348,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
public void componentScanFunction() { public void componentScanFunction() {
create(ComponentScanConfiguration.class); create(ComponentScanConfiguration.class);
assertThat(context.getBean("function")).isInstanceOf(Function.class); assertThat(context.getBean("function")).isInstanceOf(Function.class);
assertThat(catalog.lookup(Function.class, "function")) assertThat((Function<?,?>)catalog.lookup(Function.class, "function"))
.isInstanceOf(Function.class); .isInstanceOf(Function.class);
assertThat(inspector.getInputType(catalog.lookup(Function.class, "function"))) assertThat(inspector.getInputType(catalog.lookup(Function.class, "function")))
.isAssignableFrom(Map.class); .isAssignableFrom(Map.class);
@@ -362,7 +361,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
try { try {
create("greeter.jar", ComponentScanJarConfiguration.class); create("greeter.jar", ComponentScanJarConfiguration.class);
assertThat(context.getBean("greeter")).isInstanceOf(Function.class); assertThat(context.getBean("greeter")).isInstanceOf(Function.class);
assertThat(catalog.lookup(Function.class, "greeter")) assertThat((Function<?,?>)catalog.lookup(Function.class, "greeter"))
.isInstanceOf(Function.class); .isInstanceOf(Function.class);
assertThat(inspector.getInputType(catalog.lookup(Function.class, "greeter"))) assertThat(inspector.getInputType(catalog.lookup(Function.class, "greeter")))
.isAssignableFrom(String.class); .isAssignableFrom(String.class);
@@ -381,7 +380,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
assertThat(context.getBean("kotlinFunction")).isInstanceOf(Function.class); assertThat(context.getBean("kotlinFunction")).isInstanceOf(Function.class);
assertThat(context.getBean("kotlinFunction")).isInstanceOf(Function1.class); assertThat(context.getBean("kotlinFunction")).isInstanceOf(Function1.class);
assertThat(catalog.lookup(Function.class, "kotlinFunction")) assertThat((Function<?,?>)catalog.lookup(Function.class, "kotlinFunction"))
.isInstanceOf(Function.class); .isInstanceOf(Function.class);
assertThat(inspector.getInputType(catalog.lookup(Function.class, "kotlinFunction"))) assertThat(inspector.getInputType(catalog.lookup(Function.class, "kotlinFunction")))
.isAssignableFrom(String.class); .isAssignableFrom(String.class);
@@ -390,7 +389,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
assertThat(context.getBean("kotlinConsumer")).isInstanceOf(Consumer.class); assertThat(context.getBean("kotlinConsumer")).isInstanceOf(Consumer.class);
assertThat(context.getBean("kotlinConsumer")).isInstanceOf(Function1.class); assertThat(context.getBean("kotlinConsumer")).isInstanceOf(Function1.class);
assertThat(catalog.lookup(Function.class, "kotlinConsumer")) assertThat((Function<?,?>)catalog.lookup(Function.class, "kotlinConsumer"))
.isInstanceOf(Function.class); .isInstanceOf(Function.class);
assertThat(inspector.getInputType(catalog.lookup(Function.class, "kotlinConsumer"))) assertThat(inspector.getInputType(catalog.lookup(Function.class, "kotlinConsumer")))
.isAssignableFrom(String.class); .isAssignableFrom(String.class);
@@ -399,7 +398,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
assertThat(context.getBean("kotlinSupplier")).isInstanceOf(Function0.class); assertThat(context.getBean("kotlinSupplier")).isInstanceOf(Function0.class);
Supplier<Flux<String>> supplier = catalog.lookup(Supplier.class, "kotlinSupplier"); Supplier<Flux<String>> supplier = catalog.lookup(Supplier.class, "kotlinSupplier");
supplier.get().subscribe(System.out::println); supplier.get().subscribe(System.out::println);
assertThat(catalog.lookup(Supplier.class, "kotlinSupplier")) assertThat((Supplier<?>)catalog.lookup(Supplier.class, "kotlinSupplier"))
.isInstanceOf(Supplier.class); .isInstanceOf(Supplier.class);
assertThat(inspector.getOutputType(catalog.lookup(Supplier.class, "kotlinSupplier"))) assertThat(inspector.getOutputType(catalog.lookup(Supplier.class, "kotlinSupplier")))
.isAssignableFrom(String.class); .isAssignableFrom(String.class);
@@ -417,7 +416,6 @@ public class ContextFunctionCatalogAutoConfigurationTests {
} }
} }
@SuppressWarnings("unchecked")
@Test @Test
public void simpleFunction() { public void simpleFunction() {
create(SimpleConfiguration.class); create(SimpleConfiguration.class);
@@ -432,7 +430,6 @@ public class ContextFunctionCatalogAutoConfigurationTests {
.isEqualTo(inspector.getRegistration(function).getType()); .isEqualTo(inspector.getRegistration(function).getType());
} }
@SuppressWarnings("unchecked")
@Test @Test
public void simpleSupplier() { public void simpleSupplier() {
create(SimpleConfiguration.class); create(SimpleConfiguration.class);
@@ -441,7 +438,6 @@ public class ContextFunctionCatalogAutoConfigurationTests {
assertThat(supplier.get().blockFirst()).isEqualTo("hello"); assertThat(supplier.get().blockFirst()).isEqualTo("hello");
} }
@SuppressWarnings("unchecked")
@Test @Test
public void simpleConsumer() { public void simpleConsumer() {
create(SimpleConfiguration.class); create(SimpleConfiguration.class);
@@ -456,8 +452,8 @@ public class ContextFunctionCatalogAutoConfigurationTests {
public void qualifiedBean() { public void qualifiedBean() {
create(QualifiedConfiguration.class); create(QualifiedConfiguration.class);
assertThat(context.getBean("function")).isInstanceOf(Function.class); assertThat(context.getBean("function")).isInstanceOf(Function.class);
assertThat(catalog.lookup(Function.class, "function")).isNull(); assertThat((Function<?,?>)catalog.lookup(Function.class, "function")).isNull();
assertThat(catalog.lookup(Function.class, "other")) assertThat((Function<?,?>)catalog.lookup(Function.class, "other"))
.isInstanceOf(Function.class); .isInstanceOf(Function.class);
assertThat(inspector.getInputType(catalog.lookup(Function.class, "other"))) assertThat(inspector.getInputType(catalog.lookup(Function.class, "other")))
.isEqualTo(String.class); .isEqualTo(String.class);
@@ -467,9 +463,9 @@ public class ContextFunctionCatalogAutoConfigurationTests {
public void aliasBean() { public void aliasBean() {
create(AliasConfiguration.class); create(AliasConfiguration.class);
assertThat(context.getBean("function")).isInstanceOf(Function.class); assertThat(context.getBean("function")).isInstanceOf(Function.class);
assertThat(catalog.lookup(Function.class, "function")) assertThat((Function<?,?>)catalog.lookup(Function.class, "function"))
.isNotNull(); .isNotNull();
assertThat(catalog.lookup(Function.class, "other")) assertThat((Function<?,?>)catalog.lookup(Function.class, "other"))
.isInstanceOf(Function.class); .isInstanceOf(Function.class);
} }
@@ -477,10 +473,10 @@ public class ContextFunctionCatalogAutoConfigurationTests {
public void registrationBean() { public void registrationBean() {
create(RegistrationConfiguration.class); create(RegistrationConfiguration.class);
assertThat(context.getBean("function")).isInstanceOf(Function.class); assertThat(context.getBean("function")).isInstanceOf(Function.class);
assertThat(catalog.lookup(Function.class, "function")).isNull(); assertThat((Function<?,?>)catalog.lookup(Function.class, "function")).isNull();
assertThat(catalog.lookup(Function.class, "registration")) assertThat((Function<?,?>)catalog.lookup(Function.class, "registration"))
.isNull(); .isNull();
assertThat(catalog.lookup(Function.class, "other")) assertThat((Function<?,?>)catalog.lookup(Function.class, "other"))
.isInstanceOf(Function.class); .isInstanceOf(Function.class);
} }
@@ -491,7 +487,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
"spring.cloud.function.compile.foos.inputType=String", "spring.cloud.function.compile.foos.inputType=String",
"spring.cloud.function.compile.foos.outputType=String"); "spring.cloud.function.compile.foos.outputType=String");
assertThat(context.getBean("foos")).isInstanceOf(Function.class); assertThat(context.getBean("foos")).isInstanceOf(Function.class);
assertThat(catalog.lookup(Function.class, "foos")) assertThat((Function<?,?>)catalog.lookup(Function.class, "foos"))
.isInstanceOf(Function.class); .isInstanceOf(Function.class);
assertThat(inspector.getInputWrapper(catalog.lookup(Function.class, "foos"))) assertThat(inspector.getInputWrapper(catalog.lookup(Function.class, "foos")))
.isEqualTo(String.class); .isEqualTo(String.class);
@@ -507,7 +503,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
create(EmptyConfiguration.class, create(EmptyConfiguration.class,
"spring.cloud.function.imports.foos.location=file:./target/foos.fun"); "spring.cloud.function.imports.foos.location=file:./target/foos.fun");
assertThat(context.getBean("foos")).isInstanceOf(Function.class); assertThat(context.getBean("foos")).isInstanceOf(Function.class);
assertThat(catalog.lookup(Function.class, "foos")) assertThat((Function<?,?>)catalog.lookup(Function.class, "foos"))
.isInstanceOf(Function.class); .isInstanceOf(Function.class);
assertThat(inspector.getInputWrapper(catalog.lookup(Function.class, "foos"))) assertThat(inspector.getInputWrapper(catalog.lookup(Function.class, "foos")))
.isEqualTo(String.class); .isEqualTo(String.class);
@@ -520,7 +516,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
+ "::set", + "::set",
"spring.cloud.function.compile.foos.type=consumer", "spring.cloud.function.compile.foos.type=consumer",
"spring.cloud.function.compile.foos.inputType=String"); "spring.cloud.function.compile.foos.inputType=String");
assertThat(catalog.lookup(Function.class, "foos")) assertThat((Function<?,?>)catalog.lookup(Function.class, "foos"))
.isInstanceOf(Function.class); .isInstanceOf(Function.class);
assertThat(inspector.getInputWrapper(catalog.lookup(Function.class, "foos"))) assertThat(inspector.getInputWrapper(catalog.lookup(Function.class, "foos")))
.isEqualTo(String.class); .isEqualTo(String.class);
@@ -536,7 +532,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
"spring.cloud.function.compile.foos.lambda=f -> f.subscribe(" "spring.cloud.function.compile.foos.lambda=f -> f.subscribe("
+ getClass().getName() + "::set)", + getClass().getName() + "::set)",
"spring.cloud.function.compile.foos.type=consumer"); "spring.cloud.function.compile.foos.type=consumer");
assertThat(catalog.lookup(Consumer.class, "foos")) assertThat((Consumer<?>)catalog.lookup(Consumer.class, "foos"))
.isInstanceOf(Consumer.class); .isInstanceOf(Consumer.class);
assertThat(inspector.getInputWrapper(catalog.lookup(Consumer.class, "foos"))) assertThat(inspector.getInputWrapper(catalog.lookup(Consumer.class, "foos")))
.isEqualTo(Flux.class); .isEqualTo(Flux.class);
@@ -547,12 +543,11 @@ public class ContextFunctionCatalogAutoConfigurationTests {
assertThat(ContextFunctionCatalogAutoConfigurationTests.value).isEqualTo("hello"); assertThat(ContextFunctionCatalogAutoConfigurationTests.value).isEqualTo("hello");
} }
@SuppressWarnings("unchecked")
@Test @Test
public void factoryBeanFunction() { public void factoryBeanFunction() {
create(FactoryBeanConfiguration.class); create(FactoryBeanConfiguration.class);
assertThat(this.context.getBean("function")).isInstanceOf(Function.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); .isInstanceOf(Function.class);
Function<Flux<String>, Flux<String>> f = this.catalog.lookup(Function.class, Function<Flux<String>, Flux<String>> f = this.catalog.lookup(Function.class,
"function"); "function");

8
spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/config/ContextFunctionCatalogInitializerTests.java
View File

@@ -64,7 +64,7 @@ public class ContextFunctionCatalogInitializerTests {
public void lookUps() { public void lookUps() {
create(SimpleConfiguration.class); create(SimpleConfiguration.class);
assertThat(context.getBean("function")).isInstanceOf(FunctionRegistration.class); assertThat(context.getBean("function")).isInstanceOf(FunctionRegistration.class);
assertThat(catalog.lookup(Function.class, "function")) assertThat((Function<?,?>)catalog.lookup(Function.class, "function"))
.isInstanceOf(Function.class); .isInstanceOf(Function.class);
// TODO: support for function composition // TODO: support for function composition
} }
@@ -73,7 +73,7 @@ public class ContextFunctionCatalogInitializerTests {
public void missingType() { public void missingType() {
create(MissingTypeConfiguration.class); create(MissingTypeConfiguration.class);
assertThat(context.getBean("function")).isInstanceOf(FunctionRegistration.class); assertThat(context.getBean("function")).isInstanceOf(FunctionRegistration.class);
assertThat(catalog.lookup(Function.class, "function")) assertThat((Function<?,?>)catalog.lookup(Function.class, "function"))
.isInstanceOf(Function.class); .isInstanceOf(Function.class);
// TODO: support for type inference from functional bean regsitrations // TODO: support for type inference from functional bean regsitrations
} }
@@ -82,7 +82,7 @@ public class ContextFunctionCatalogInitializerTests {
public void configurationFunction() { public void configurationFunction() {
create(FunctionConfiguration.class); create(FunctionConfiguration.class);
assertThat(context.getBean("foos")).isInstanceOf(Function.class); assertThat(context.getBean("foos")).isInstanceOf(Function.class);
assertThat(catalog.lookup(Function.class, "foos")) assertThat((Function<?,?>)catalog.lookup(Function.class, "foos"))
.isInstanceOf(Function.class); .isInstanceOf(Function.class);
assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos"))) assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos")))
.isEqualTo(String.class); .isEqualTo(String.class);
@@ -96,7 +96,7 @@ public class ContextFunctionCatalogInitializerTests {
public void dependencyInjection() { public void dependencyInjection() {
create(DependencyInjectionConfiguration.class); create(DependencyInjectionConfiguration.class);
assertThat(context.getBean("foos")).isInstanceOf(FunctionRegistration.class); assertThat(context.getBean("foos")).isInstanceOf(FunctionRegistration.class);
assertThat(catalog.lookup(Function.class, "foos")) assertThat((Function<?,?>)catalog.lookup(Function.class, "foos"))
.isInstanceOf(Function.class); .isInstanceOf(Function.class);
assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos"))) assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos")))
.isEqualTo(String.class); .isEqualTo(String.class);

23
spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/config/ContextFunctionPostProcessorTests.java
View File

@@ -62,7 +62,7 @@ public class ContextFunctionPostProcessorTests {
@Test @Test
public void basicRegistrationFeatures() { public void basicRegistrationFeatures() {
processor.register(new FunctionRegistration<>(new Foos()).names("foos")); processor.register(new FunctionRegistration<>(new Foos(), "foos"));
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
Function<Flux<Integer>, Flux<String>> foos = (Function<Flux<Integer>, Flux<String>>) processor Function<Flux<Integer>, Flux<String>> foos = (Function<Flux<Integer>, Flux<String>>) processor
.lookupFunction("foos"); .lookupFunction("foos");
@@ -71,8 +71,7 @@ public class ContextFunctionPostProcessorTests {
@Test @Test
public void registrationThroughMerge() { public void registrationThroughMerge() {
FunctionRegistration<Foos> registration = new FunctionRegistration<>(new Foos()) FunctionRegistration<Foos> registration = new FunctionRegistration<>(new Foos(), "foos");
.names("foos");
processor.merge(Collections.singletonMap("foos", registration), processor.merge(Collections.singletonMap("foos", registration),
Collections.emptyMap(), Collections.emptyMap(), Collections.emptyMap()); Collections.emptyMap(), Collections.emptyMap(), Collections.emptyMap());
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
@@ -93,8 +92,8 @@ public class ContextFunctionPostProcessorTests {
@Test @Test
public void composeWithComma() { public void composeWithComma() {
processor.register(new FunctionRegistration<>(new Foos()).names("foos")); processor.register(new FunctionRegistration<>(new Foos(), "foos"));
processor.register(new FunctionRegistration<>(new Bars()).names("bars")); processor.register(new FunctionRegistration<>(new Bars(), "bars"));
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
Function<Flux<Integer>, Flux<String>> foos = (Function<Flux<Integer>, Flux<String>>) processor Function<Flux<Integer>, Flux<String>> foos = (Function<Flux<Integer>, Flux<String>>) processor
.lookupFunction("foos,bars"); .lookupFunction("foos,bars");
@@ -105,8 +104,8 @@ public class ContextFunctionPostProcessorTests {
@Test @Test
public void compose() { public void compose() {
processor.register(new FunctionRegistration<>(new Foos()).names("foos")); processor.register(new FunctionRegistration<>(new Foos(), "foos"));
processor.register(new FunctionRegistration<>(new Bars()).names("bars")); processor.register(new FunctionRegistration<>(new Bars(), "bars"));
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
Function<Flux<Integer>, Flux<String>> foos = (Function<Flux<Integer>, Flux<String>>) processor Function<Flux<Integer>, Flux<String>> foos = (Function<Flux<Integer>, Flux<String>>) processor
.lookupFunction("foos|bars"); .lookupFunction("foos|bars");
@@ -117,8 +116,8 @@ public class ContextFunctionPostProcessorTests {
@Test @Test
public void composeWrapper() { public void composeWrapper() {
processor.register(new FunctionRegistration<>(new WrappedSource()).names("ints")); processor.register(new FunctionRegistration<>(new WrappedSource(), "ints"));
processor.register(new FunctionRegistration<>(new Foos()).names("foos")); processor.register(new FunctionRegistration<>(new Foos(), "foos"));
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
Supplier<Flux<String>> foos = (Supplier<Flux<String>>) processor Supplier<Flux<String>> foos = (Supplier<Flux<String>>) processor
.lookupSupplier("ints|foos"); .lookupSupplier("ints|foos");
@@ -133,7 +132,7 @@ public class ContextFunctionPostProcessorTests {
public void isolatedFunction() { public void isolatedFunction() {
contextClassLoader = ClassUtils contextClassLoader = ClassUtils
.overrideThreadContextClassLoader(getClass().getClassLoader()); .overrideThreadContextClassLoader(getClass().getClassLoader());
processor.register(new FunctionRegistration<>(create(Foos.class)).names("foos")); processor.register(new FunctionRegistration<>(create(Foos.class), "foos"));
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
Function<Flux<Integer>, Flux<String>> foos = (Function<Flux<Integer>, Flux<String>>) processor Function<Flux<Integer>, Flux<String>> foos = (Function<Flux<Integer>, Flux<String>>) processor
.lookupFunction("foos"); .lookupFunction("foos");
@@ -145,7 +144,7 @@ public class ContextFunctionPostProcessorTests {
contextClassLoader = ClassUtils contextClassLoader = ClassUtils
.overrideThreadContextClassLoader(getClass().getClassLoader()); .overrideThreadContextClassLoader(getClass().getClassLoader());
processor.register( processor.register(
new FunctionRegistration<>(create(Source.class)).names("source")); new FunctionRegistration<>(create(Source.class), "source"));
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
Supplier<Flux<Integer>> source = (Supplier<Flux<Integer>>) processor Supplier<Flux<Integer>> source = (Supplier<Flux<Integer>>) processor
.lookupSupplier("source"); .lookupSupplier("source");
@@ -157,7 +156,7 @@ public class ContextFunctionPostProcessorTests {
contextClassLoader = ClassUtils contextClassLoader = ClassUtils
.overrideThreadContextClassLoader(getClass().getClassLoader()); .overrideThreadContextClassLoader(getClass().getClassLoader());
Object target = create(Sink.class); Object target = create(Sink.class);
processor.register(new FunctionRegistration<>(target).names("sink")); processor.register(new FunctionRegistration<>(target, "sink"));
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
Function<Flux<String>, Mono<Void>> sink = (Function<Flux<String>, Mono<Void>>) processor Function<Flux<String>, Mono<Void>> sink = (Function<Flux<String>, Mono<Void>>) processor
.lookupFunction("sink"); .lookupFunction("sink");

3
spring-cloud-function-deployer/src/main/java/org/springframework/cloud/function/deployer/FunctionCreatorConfiguration.java
View File

@@ -379,8 +379,7 @@ class FunctionCreatorConfiguration {
return; return;
} }
FunctionRegistration<Object> registration = new FunctionRegistration<Object>( FunctionRegistration<Object> registration = new FunctionRegistration<Object>(
bean).names( bean, FunctionProperties.functionName(counter.getAndIncrement()));
FunctionProperties.functionName(counter.getAndIncrement()));
if (this.runner != null) { if (this.runner != null) {
if (this.runner.containsBean(FunctionInspector.class.getName())) { if (this.runner.containsBean(FunctionInspector.class.getName())) {
Object inspector = this.runner Object inspector = this.runner

2
spring-cloud-function-deployer/src/main/java/org/springframework/cloud/function/deployer/SingleEntryFunctionRegistry.java
View File

@@ -37,7 +37,7 @@ public class SingleEntryFunctionRegistry implements FunctionRegistry {
} }
@Override @Override
public <T> T lookup(Class<T> type, String name) { public <T> T lookup(Class<?> type, String name) {
return this.name.equals(name) ? this.delegate.lookup(type, name) : null; return this.name.equals(name) ? this.delegate.lookup(type, name) : null;
} }