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;
* @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);

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
@SuppressWarnings("unchecked")
public <T> T lookup(Class<T> type, String name) {
public <T> 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);

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
@SuppressWarnings("unchecked")
public <T> T lookup(Class<T> type, String name) {
public <T> T lookup(Class<?> type, String name) {
T function = null;
if (type == null) {
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
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<Foos> registration = new FunctionRegistration<>(new Foos())
.names("foos").type(FunctionType.of(Foos.class).getType());
FunctionRegistration<Foos> 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();

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>>> {
@Override
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
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,
"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<Integer>, Flux<String>> 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<Function<Integer, String>>(
(Integer i) -> "i=" + i).names("foos").type(
(Integer i) -> "i=" + i, "foos").type(
FunctionType.from(Integer.class).to(String.class).getType()));
Function<Flux<Integer>, Flux<String>> 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<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)
.wrap(Flux.class).getType()));
Function<Flux<Integer>, Flux<String>> foos = processor.lookup(Function.class, "");
@@ -92,8 +92,7 @@ public class BeanFactoryFunctionCatalogTests {
processor.register(
new FunctionRegistration<Function<Flux<String>, Mono<Map<String, Integer>>>>(
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<Flux<String>> 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<Integer>, Flux<String>> 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<Flux<String>> 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<Flux<Integer>> 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<Flux<Integer>, Mono<Void>> 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<Flux<String>, Mono<Void>> foos = processor.lookup(Function.class, "");
foos.apply(Flux.just("2")).subscribe();
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.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<String>, Flux<String>> 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<Flux<String>> 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<String>, Flux<String>> f = this.catalog.lookup(Function.class,
"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() {
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);

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
public void basicRegistrationFeatures() {
processor.register(new FunctionRegistration<>(new Foos()).names("foos"));
processor.register(new FunctionRegistration<>(new Foos(), "foos"));
@SuppressWarnings("unchecked")
Function<Flux<Integer>, Flux<String>> foos = (Function<Flux<Integer>, Flux<String>>) processor
.lookupFunction("foos");
@@ -71,8 +71,7 @@ public class ContextFunctionPostProcessorTests {
@Test
public void registrationThroughMerge() {
FunctionRegistration<Foos> registration = new FunctionRegistration<>(new Foos())
.names("foos");
FunctionRegistration<Foos> 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<Integer>, Flux<String>> foos = (Function<Flux<Integer>, Flux<String>>) 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<Integer>, Flux<String>> foos = (Function<Flux<Integer>, Flux<String>>) 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<Flux<String>> foos = (Supplier<Flux<String>>) 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<Integer>, Flux<String>> foos = (Function<Flux<Integer>, Flux<String>>) 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<Flux<Integer>> source = (Supplier<Flux<Integer>>) 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<Flux<String>, Mono<Void>> sink = (Function<Flux<String>, Mono<Void>>) processor
.lookupFunction("sink");