GH-199 Added support for typeless lookup in FunctionCatalog

Updated both the interface as well as InMemoryFunctionCatalog BeanFactoryFunctionCatalog and SingleEntryFunctionRegistry implementations
Added tests

Resolves #199

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2017 the original author or authors.
+ * Copyright 2016-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20,10 +20,30 @@ import java.util.Set;
 
 /**
  * @author Dave Syer
+ * @author Oleg Zhurakousky
  */
 public interface FunctionCatalog {
 
-	<T> T lookup(Class<?> type, String name);
+	/**
+	 * Will look up the instance of the functional interface by name only
+	 *
+	 * @param name the name of the functional interface. Must not be null;
+	 * @return instance of the functional interface registered with this catalog
+	 */
+	default public <T> T lookup(String name) {
+		return this.lookup(null, name);
+	}
+
+	/**
+	 * Will look up the instance of the functional interface by name and type
+	 * which can only be Supplier, Consumer or Function. If type is not provided, the lookup
+	 * will be made based on name only
+	 *
+	 * @param type the type of functional interface. Can be null
+	 * @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);
 
 	Set<String> getNames(Class<?> type);
 

spring-cloud-function-context/src/main/java/org/springframework/cloud/function/context/FunctionRegistration.java

@@ -31,6 +31,7 @@ import org.springframework.cloud.function.core.FluxConsumer;
 import org.springframework.cloud.function.core.FluxFunction;
 import org.springframework.cloud.function.core.FluxSupplier;
 import org.springframework.util.Assert;
+import org.springframework.util.ObjectUtils;
 
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
@@ -58,6 +59,7 @@ public class FunctionRegistration<T> {
 		this.target = target;
 	}
 
+
 	/**
 	 * Creates instance of FunctionRegistration.
 	 *
@@ -66,11 +68,11 @@ public class FunctionRegistration<T> {
 	 * @param names additional set of names for this registration. Additional names
 	 * can be provided {@link #name(String)} or {@link #names(String...)} operations.
 	 */
-	public FunctionRegistration(T target, String name, String... additionalNames) {
+	public FunctionRegistration(T target, String... names) {
 		Assert.notNull(target, "'target' must not be null");
+		Assert.notEmpty(names, "'names' must not be null or empty");
 		this.target = target;
-		this.names(name);
+		this.names(names);
-		this.names(additionalNames);
 	}
 
 	public Map<String, String> getProperties() {

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

@@ -19,6 +19,7 @@ package org.springframework.cloud.function.context.catalog;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 import java.util.function.Consumer;
 import java.util.function.Function;
@@ -117,9 +118,15 @@ public class InMemoryFunctionCatalog
 
 	@Override
 	@SuppressWarnings("unchecked")
-	public <T> T lookup(Class<?> type, String name) {
+	public <T> T lookup(Class<T> type, String name) {
-		Map<String, Object> map = this.extractTypeMap(type);
+		T function = null;
-		return (T) map.get(name);
+		if (type == null) {
+			function = (T) functions.values().stream().filter(map -> map.get(name) != null).map(map -> map.get(name)).findFirst().orElse(null);
+		}
+		else {
+			function = (T) this.extractTypeMap(type).get(name);
+		}
+		return function;
 	}
 
 	@Override

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

@@ -135,17 +135,27 @@ public class ContextFunctionCatalogAutoConfiguration {
 
 		@Override
 		@SuppressWarnings("unchecked")
-		public <T> T lookup(Class<?> type, String name) {
+		public <T> T lookup(Class<T> type, String name) {
-			if (Supplier.class.isAssignableFrom(type)) {
+			T function = null;
-				return (T) processor.lookupSupplier(name);
+			if (type == null) {
+				function = (T) processor.lookupFunction(name);
+				if (function == null) {
+					function = (T) processor.lookupConsumer(name);
+				}
+				if (function == null) {
+					function = (T) processor.lookupSupplier(name);
+				}
 			}
-			if (Consumer.class.isAssignableFrom(type)) {
+			else if (Supplier.class.isAssignableFrom(type)) {
-				return (T) processor.lookupConsumer(name);
+				function = (T) processor.lookupSupplier(name);
 			}
-			if (Function.class.isAssignableFrom(type)) {
+			else if (Consumer.class.isAssignableFrom(type)) {
-				return (T) processor.lookupFunction(name);
+				function = (T) processor.lookupConsumer(name);
 			}
-			return null;
+			else if (Function.class.isAssignableFrom(type)) {
+				function = (T) processor.lookupFunction(name);
+			}
+			return function;
 		}
 
 		@Override
@@ -233,7 +243,7 @@ public class ContextFunctionCatalogAutoConfiguration {
 			if (function == null || !names.containsKey(function)) {
 				return null;
 			}
-			return new FunctionRegistration<>(function).name(names.get(function))
+			return new FunctionRegistration<>(function, names.get(function))
 					.type(findType(function).getType());
 		}
 
@@ -390,7 +400,7 @@ public class ContextFunctionCatalogAutoConfiguration {
 				.forEach(entry -> {
 					if (!targets.containsKey(entry.getValue())) {
 						FunctionRegistration<Object> target = new FunctionRegistration<Object>(
-								entry.getValue()).names(getAliases(entry.getKey()));
+								entry.getValue(), getAliases(entry.getKey()).toArray(new String[] {}));
 						targets.put(target.getTarget(), entry.getKey());
 						registrations.add(target);
 					}

spring-cloud-function-context/src/test/java/org/springframework/cloud/function/context/catalog/InMemoryFunctionCatalogTests.java

@@ -16,13 +16,17 @@
 
 package org.springframework.cloud.function.context.catalog;
 
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
 
 import java.util.function.Function;
 
 import org.junit.Test;
 import org.springframework.cloud.function.context.FunctionRegistration;
 import org.springframework.cloud.function.context.FunctionType;
+import org.springframework.cloud.function.core.FluxFunction;
 
 /**
  *
@@ -42,6 +46,22 @@ public class InMemoryFunctionCatalogTests {
 		assertSame(registration, registration2);
 	}
 
+	@Test
+	public void testFunctionLookup() {
+		TestFunction function = new TestFunction();
+		FunctionRegistration<TestFunction> registration = new FunctionRegistration<>(function, "foo")
+				.type(FunctionType.of(TestFunction.class).getType());
+		InMemoryFunctionCatalog catalog = new InMemoryFunctionCatalog();
+		catalog.register(registration);
+
+		Object lookedUpFunction = catalog.lookup("hello");
+		assertNull(lookedUpFunction);
+
+		lookedUpFunction = catalog.lookup("foo");
+		assertNotNull(lookedUpFunction);
+		assertTrue(lookedUpFunction instanceof FluxFunction);
+	}
+
 	private static class TestFunction implements Function<Integer, String> {
 		@Override
 		public String apply(Integer t) {

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

@@ -60,6 +60,13 @@ public class BeanFactoryFunctionCatalogTests {
 		assertThat(foos.apply(Flux.just(2)).blockFirst()).isEqualTo("4");
 	}
 
+	@Test
+	public void lookupFunctionWithNoType() {
+		processor.register(new FunctionRegistration<>(new Foos(), "foos"));
+		Function<Flux<Integer>, Flux<String>> foos = processor.lookup("foos");
+		assertThat(foos.apply(Flux.just(2)).blockFirst()).isEqualTo("4");
+	}
+
 	@Test
 	public void registerFunctionWithType() {
 		processor.register(new FunctionRegistration<Function<Integer, String>>(

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

@@ -89,14 +89,15 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 		ContextFunctionCatalogAutoConfigurationTests.value = null;
 	}
 
+	@SuppressWarnings("unchecked")
 	@Test
 	public void lookUps() {
 		create(SimpleConfiguration.class);
 		assertThat(context.getBean("function")).isInstanceOf(Function.class);
-		assertThat(catalog.<Function<?, ?>>lookup(Function.class, "function"))
+		assertThat(catalog.lookup(Function.class, "function"))
 				.isInstanceOf(Function.class);
 		assertThat(context.getBean("function2")).isInstanceOf(Function.class);
-		assertThat(catalog.<Function<?, ?>>lookup(Function.class, "function,function2"))
+		assertThat(catalog.lookup(Function.class, "function,function2"))
 				.isInstanceOf(Function.class);
 		Function<Flux<String>, Flux<String>> f = catalog.lookup(Function.class,
 				"function,function2,function3");
@@ -104,10 +105,10 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 		assertThat(f.apply(Flux.just("hello")).blockFirst())
 				.isEqualTo("HELLOfunction2function3");
 		assertThat(context.getBean("supplierFoo")).isInstanceOf(Supplier.class);
-		assertThat(catalog.<Supplier<?>>lookup(Supplier.class, "supplierFoo"))
+		assertThat(catalog.lookup(Supplier.class, "supplierFoo"))
 				.isInstanceOf(Supplier.class);
 		assertThat(context.getBean("supplier_Foo")).isInstanceOf(Supplier.class);
-		assertThat(catalog.<Supplier<?>>lookup(Supplier.class, "supplier_Foo"))
+		assertThat(catalog.lookup(Supplier.class, "supplier_Foo"))
 				.isInstanceOf(Supplier.class);
 	}
 
@@ -115,9 +116,9 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 	public void ambiguousFunction() {
 		create(AmbiguousConfiguration.class);
 		assertThat(context.getBean("foos")).isInstanceOf(Function.class);
-		assertThat(catalog.<Function<?, ?>>lookup(Function.class, "foos"))
+		assertThat(catalog.lookup(Function.class, "foos"))
 				.isInstanceOf(Function.class);
-		assertThat(catalog.<Supplier<?>>lookup(Supplier.class, "foos"))
+		assertThat(catalog.lookup(Supplier.class, "foos"))
 				.isInstanceOf(Supplier.class);
 		assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos")))
 				.isEqualTo(String.class);
@@ -129,7 +130,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 	public void configurationFunction() {
 		create(FunctionConfiguration.class);
 		assertThat(context.getBean("foos")).isInstanceOf(Function.class);
-		assertThat(catalog.<Function<?, ?>>lookup(Function.class, "foos"))
+		assertThat(catalog.lookup(Function.class, "foos"))
 				.isInstanceOf(Function.class);
 		assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos")))
 				.isEqualTo(String.class);
@@ -143,7 +144,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 	public void dependencyInjection() {
 		create(DependencyInjectionConfiguration.class);
 		assertThat(context.getBean("foos")).isInstanceOf(Function.class);
-		assertThat(catalog.<Function<?, ?>>lookup(Function.class, "foos"))
+		assertThat(catalog.lookup(Function.class, "foos"))
 				.isInstanceOf(Function.class);
 		assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos")))
 				.isEqualTo(String.class);
@@ -153,7 +154,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 	public void externalDependencyInjection() {
 		create(ExternalDependencyConfiguration.class);
 		assertThat(context.getBean("foos")).isInstanceOf(Function.class);
-		assertThat(catalog.<Function<?, ?>>lookup(Function.class, "foos"))
+		assertThat(catalog.lookup(Function.class, "foos"))
 				.isInstanceOf(Function.class);
 		assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos")))
 				.isEqualTo(String.class);
@@ -162,9 +163,9 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 	@Test
 	public void composedFunction() {
 		create(MultipleConfiguration.class);
-		assertThat(catalog.<Function<?, ?>>lookup(Function.class, "foos,bars"))
+		assertThat(catalog.lookup(Function.class, "foos,bars"))
 				.isInstanceOf(Function.class);
-		assertThat(catalog.<Function<?, ?>>lookup(Function.class, "names,foos")).isNull();
+		assertThat(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")))
@@ -174,9 +175,9 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 	@Test
 	public void composedSupplier() {
 		create(MultipleConfiguration.class);
-		assertThat(catalog.<Supplier<?>>lookup(Supplier.class, "names,foos"))
+		assertThat(catalog.lookup(Supplier.class, "names,foos"))
 				.isInstanceOf(Supplier.class);
-		assertThat(catalog.<Function<?, ?>>lookup(Function.class, "names,foos")).isNull();
+		assertThat(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
@@ -187,8 +188,8 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 	@Test
 	public void composedConsumer() {
 		create(MultipleConfiguration.class);
-		assertThat(catalog.<Consumer<?>>lookup(Consumer.class, "foos,print")).isNull();
+		assertThat(catalog.lookup(Consumer.class, "foos,print")).isNull();
-		assertThat(catalog.<Function<?, ?>>lookup(Function.class, "foos,print"))
+		assertThat(catalog.lookup(Function.class, "foos,print"))
 				.isInstanceOf(Function.class);
 		assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos,print")))
 				.isAssignableFrom(String.class);
@@ -201,7 +202,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 	public void genericFunction() {
 		create(GenericConfiguration.class);
 		assertThat(context.getBean("function")).isInstanceOf(Function.class);
-		assertThat(catalog.<Function<?, ?>>lookup(Function.class, "function"))
+		assertThat(catalog.lookup(Function.class, "function"))
 				.isInstanceOf(Function.class);
 		assertThat(inspector.getInputType(catalog.lookup(Function.class, "function")))
 				.isAssignableFrom(Map.class);
@@ -213,7 +214,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 	public void fluxMessageFunction() {
 		create(FluxMessageConfiguration.class);
 		assertThat(context.getBean("function")).isInstanceOf(Function.class);
-		assertThat(catalog.<Function<?, ?>>lookup(Function.class, "function"))
+		assertThat(catalog.lookup(Function.class, "function"))
 				.isInstanceOf(Function.class);
 		assertThat(inspector.isMessage(catalog.lookup(Function.class, "function")))
 				.isTrue();
@@ -227,7 +228,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 	public void publisherMessageFunction() {
 		create(PublisherMessageConfiguration.class);
 		assertThat(context.getBean("function")).isInstanceOf(Function.class);
-		assertThat(catalog.<Function<?, ?>>lookup(Function.class, "function"))
+		assertThat(catalog.lookup(Function.class, "function"))
 				.isInstanceOf(Function.class);
 		assertThat(inspector.isMessage(catalog.lookup(Function.class, "function")))
 				.isTrue();
@@ -241,7 +242,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 	public void monoFunction() {
 		create(MonoConfiguration.class);
 		assertThat(context.getBean("function")).isInstanceOf(Function.class);
-		assertThat(catalog.<Function<?, ?>>lookup(Function.class, "function"))
+		assertThat(catalog.lookup(Function.class, "function"))
 				.isInstanceOf(Function.class);
 		assertThat(inspector.isMessage(catalog.lookup(Function.class, "function")))
 				.isFalse();
@@ -257,7 +258,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 	public void messageFunction() {
 		create(MessageConfiguration.class);
 		assertThat(context.getBean("function")).isInstanceOf(Function.class);
-		assertThat(catalog.<Function<?, ?>>lookup(Function.class, "function"))
+		assertThat(catalog.lookup(Function.class, "function"))
 				.isInstanceOf(Function.class);
 		assertThat(inspector.isMessage(catalog.lookup(Function.class, "function")))
 				.isTrue();
@@ -271,7 +272,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 	public void genericFluxFunction() {
 		create(GenericFluxConfiguration.class);
 		assertThat(context.getBean("function")).isInstanceOf(Function.class);
-		assertThat(catalog.<Function<?, ?>>lookup(Function.class, "function"))
+		assertThat(catalog.lookup(Function.class, "function"))
 				.isInstanceOf(Function.class);
 		assertThat(inspector.getInputType(catalog.lookup(Function.class, "function")))
 				.isAssignableFrom(Map.class);
@@ -283,7 +284,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 	public void externalFunction() {
 		create(ExternalConfiguration.class);
 		assertThat(context.getBean("function")).isInstanceOf(Function.class);
-		assertThat(catalog.<Function<?, ?>>lookup(Function.class, "function"))
+		assertThat(catalog.lookup(Function.class, "function"))
 				.isInstanceOf(Function.class);
 		assertThat(inspector.getInputType(catalog.lookup(Function.class, "function")))
 				.isAssignableFrom(Map.class);
@@ -295,7 +296,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 	public void singletonFunction() {
 		create(SingletonConfiguration.class);
 		assertThat(context.getBean("function")).isInstanceOf(Function.class);
-		assertThat(catalog.<Function<?, ?>>lookup(Function.class, "function"))
+		assertThat(catalog.lookup(Function.class, "function"))
 				.isInstanceOf(Function.class);
 		assertThat(inspector.getInputType(catalog.lookup(Function.class, "function")))
 				.isAssignableFrom(Integer.class);
@@ -307,7 +308,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 	public void singletonMessageFunction() {
 		create(SingletonMessageConfiguration.class);
 		assertThat(context.getBean("function")).isInstanceOf(Function.class);
-		assertThat(catalog.<Function<?, ?>>lookup(Function.class, "function"))
+		assertThat(catalog.lookup(Function.class, "function"))
 				.isInstanceOf(Function.class);
 		assertThat(inspector.getInputType(catalog.lookup(Function.class, "function")))
 				.isAssignableFrom(Integer.class);
@@ -321,7 +322,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 	public void nonParametericTypeFunction() {
 		create(NonParametricTypeSingletonConfiguration.class);
 		assertThat(context.getBean("function")).isInstanceOf(Function.class);
-		assertThat(catalog.<Function<?, ?>>lookup(Function.class, "function"))
+		assertThat(catalog.lookup(Function.class, "function"))
 				.isInstanceOf(Function.class);
 		assertThat(inspector.getInputType(catalog.lookup(Function.class, "function")))
 				.isAssignableFrom(Integer.class);
@@ -333,7 +334,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 	public void componentScanBeanFunction() {
 		create(ComponentScanBeanConfiguration.class);
 		assertThat(context.getBean("function")).isInstanceOf(Function.class);
-		assertThat(catalog.<Function<?, ?>>lookup(Function.class, "function"))
+		assertThat(catalog.lookup(Function.class, "function"))
 				.isInstanceOf(Function.class);
 		assertThat(inspector.getInputType(catalog.lookup(Function.class, "function")))
 				.isAssignableFrom(Map.class);
@@ -345,7 +346,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 	public void componentScanFunction() {
 		create(ComponentScanConfiguration.class);
 		assertThat(context.getBean("function")).isInstanceOf(Function.class);
-		assertThat(catalog.<Function<?, ?>>lookup(Function.class, "function"))
+		assertThat(catalog.lookup(Function.class, "function"))
 				.isInstanceOf(Function.class);
 		assertThat(inspector.getInputType(catalog.lookup(Function.class, "function")))
 				.isAssignableFrom(Map.class);
@@ -358,7 +359,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 		try {
 			create("greeter.jar", ComponentScanJarConfiguration.class);
 			assertThat(context.getBean("greeter")).isInstanceOf(Function.class);
-			assertThat(catalog.<Function<?, ?>>lookup(Function.class, "greeter"))
+			assertThat(catalog.lookup(Function.class, "greeter"))
 					.isInstanceOf(Function.class);
 			assertThat(inspector.getInputType(catalog.lookup(Function.class, "greeter")))
 					.isAssignableFrom(String.class);
@@ -383,6 +384,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 		}
 	}
 
+	@SuppressWarnings("unchecked")
 	@Test
 	public void simpleFunction() {
 		create(SimpleConfiguration.class);
@@ -397,6 +399,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 				.isEqualTo(inspector.getRegistration(function).getType());
 	}
 
+	@SuppressWarnings("unchecked")
 	@Test
 	public void simpleSupplier() {
 		create(SimpleConfiguration.class);
@@ -405,6 +408,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 		assertThat(supplier.get().blockFirst()).isEqualTo("hello");
 	}
 
+	@SuppressWarnings("unchecked")
 	@Test
 	public void simpleConsumer() {
 		create(SimpleConfiguration.class);
@@ -419,8 +423,8 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 	public void qualifiedBean() {
 		create(QualifiedConfiguration.class);
 		assertThat(context.getBean("function")).isInstanceOf(Function.class);
-		assertThat(catalog.<Function<?, ?>>lookup(Function.class, "function")).isNull();
+		assertThat(catalog.lookup(Function.class, "function")).isNull();
-		assertThat(catalog.<Function<?, ?>>lookup(Function.class, "other"))
+		assertThat(catalog.lookup(Function.class, "other"))
 				.isInstanceOf(Function.class);
 		assertThat(inspector.getInputType(catalog.lookup(Function.class, "other")))
 				.isEqualTo(String.class);
@@ -430,9 +434,9 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 	public void aliasBean() {
 		create(AliasConfiguration.class);
 		assertThat(context.getBean("function")).isInstanceOf(Function.class);
-		assertThat(catalog.<Function<?, ?>>lookup(Function.class, "function"))
+		assertThat(catalog.lookup(Function.class, "function"))
 				.isNotNull();
-		assertThat(catalog.<Function<?, ?>>lookup(Function.class, "other"))
+		assertThat(catalog.lookup(Function.class, "other"))
 				.isInstanceOf(Function.class);
 	}
 
@@ -440,10 +444,10 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 	public void registrationBean() {
 		create(RegistrationConfiguration.class);
 		assertThat(context.getBean("function")).isInstanceOf(Function.class);
-		assertThat(catalog.<Function<?, ?>>lookup(Function.class, "function")).isNull();
+		assertThat(catalog.lookup(Function.class, "function")).isNull();
-		assertThat(catalog.<Function<?, ?>>lookup(Function.class, "registration"))
+		assertThat(catalog.lookup(Function.class, "registration"))
 				.isNull();
-		assertThat(catalog.<Function<?, ?>>lookup(Function.class, "other"))
+		assertThat(catalog.lookup(Function.class, "other"))
 				.isInstanceOf(Function.class);
 	}
 
@@ -454,7 +458,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.<Function<?, ?>>lookup(Function.class, "foos"))
+		assertThat(catalog.lookup(Function.class, "foos"))
 				.isInstanceOf(Function.class);
 		assertThat(inspector.getInputWrapper(catalog.lookup(Function.class, "foos")))
 				.isEqualTo(String.class);
@@ -470,7 +474,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.<Function<?, ?>>lookup(Function.class, "foos"))
+		assertThat(catalog.lookup(Function.class, "foos"))
 				.isInstanceOf(Function.class);
 		assertThat(inspector.getInputWrapper(catalog.lookup(Function.class, "foos")))
 				.isEqualTo(String.class);
@@ -483,7 +487,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 						+ "::set",
 				"spring.cloud.function.compile.foos.type=consumer",
 				"spring.cloud.function.compile.foos.inputType=String");
-		assertThat(catalog.<Function<?, ?>>lookup(Function.class, "foos"))
+		assertThat(catalog.lookup(Function.class, "foos"))
 				.isInstanceOf(Function.class);
 		assertThat(inspector.getInputWrapper(catalog.lookup(Function.class, "foos")))
 				.isEqualTo(String.class);
@@ -499,7 +503,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.<Consumer<?>>lookup(Consumer.class, "foos"))
+		assertThat(catalog.lookup(Consumer.class, "foos"))
 				.isInstanceOf(Consumer.class);
 		assertThat(inspector.getInputWrapper(catalog.lookup(Consumer.class, "foos")))
 				.isEqualTo(Flux.class);
@@ -510,11 +514,12 @@ 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.<Function<?, ?>>lookup(Function.class, "function"))
+		assertThat(this.catalog.lookup(Function.class, "function"))
 				.isInstanceOf(Function.class);
 		Function<Flux<String>, Flux<String>> f = this.catalog.lookup(Function.class,
 				"function");
@@ -816,8 +821,7 @@ public class ContextFunctionCatalogAutoConfigurationTests {
 	protected static class RegistrationConfiguration {
 		@Bean
 		public FunctionRegistration<Function<String, String>> registration() {
-			return new FunctionRegistration<Function<String, String>>(function())
+			return new FunctionRegistration<Function<String, String>>(function(), "other");
-					.name("other");
 		}
 
 		@Bean

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 the original author or authors.
+ * Copyright 2017-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -44,7 +44,7 @@ import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
 /**
- * @author Dave Syert
+ * @author Dave Syer
  *
  */
 public class ContextFunctionCatalogInitializerTests {
@@ -64,7 +64,7 @@ public class ContextFunctionCatalogInitializerTests {
 	public void lookUps() {
 		create(SimpleConfiguration.class);
 		assertThat(context.getBean("function")).isInstanceOf(FunctionRegistration.class);
-		assertThat(catalog.<Function<?, ?>>lookup(Function.class, "function"))
+		assertThat(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.<Function<?, ?>>lookup(Function.class, "function"))
+		assertThat(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.<Function<?, ?>>lookup(Function.class, "foos"))
+		assertThat(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.<Function<?, ?>>lookup(Function.class, "foos"))
+		assertThat(catalog.lookup(Function.class, "foos"))
 				.isInstanceOf(Function.class);
 		assertThat(inspector.getInputType(catalog.lookup(Function.class, "foos")))
 				.isEqualTo(String.class);

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2017 the original author or authors.
+ * Copyright 2016-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -37,7 +37,7 @@ public class SingleEntryFunctionRegistry implements FunctionRegistry {
 	}
 
 	@Override
-	public <T> T lookup(Class<?> type, String name) {
+	public <T> T lookup(Class<T> type, String name) {
 		return this.name.equals(name) ? this.delegate.lookup(type, name) : null;
 	}