Solution #1 (take 3) - Apply Pluggable Selector Pattern by Kent Beck,...

java/src/main/java/it/tug/Main/Formatter.java

@@ -1,22 +1,39 @@
 package it.tug.Main;
 
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
 public class Formatter {
 
-    private Service service;
+    private static final MethodReflector<Formatter> methodReflector = new MethodReflector<>(Formatter.class);
+
+    private final Service service;
 
     public Formatter(Service service) {
         this.service = service;
     }
 
     public String doTheJob(String theInput) {
         String response = service.askForPermission();
-        switch (response) {
-            case "FAIL":
-                return "error";
-            case "OK":
-                return String.format("%s%s", theInput, theInput);
-            default:
-                return null;
+
+        try {
+            String methodName = response.toLowerCase();
+            Method method = methodReflector.getMethod(methodName);
+
+            return (String) method.invoke(this, theInput);
+        } catch (IllegalAccessException 
+                | IllegalArgumentException 
+                | InvocationTargetException 
+                | NoSuchMethodException ex) {
+            return null;
         }
     }
+
+    private String fail(String theInput) {
+        return "error";
+    }
+
+    private String ok(String theInput) {
+        return String.format("%s%s", theInput, theInput);
+    }
 }

java/src/main/java/it/tug/Main/MethodReflector.java

@@ -0,0 +1,30 @@
+package it.tug.Main;
+
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ *
+ * @author Gianluca Costa
+ */
+public class MethodReflector<T> { //TODO: is this class really needed? We should definitely profile the reflection call
+    private final Class<T> targetClass;
+    private final Map<String, Method> methodCache = new HashMap<>();
+
+    public MethodReflector(Class<T> targetClass) {
+        this.targetClass = targetClass;
+    }
+
+    //TODO: this method is not thread-safe, but that should NOT be an issue, generally speaking - and introducing a lock would probably be worse
+    public Method getMethod(String methodName) throws NoSuchMethodException {
+        Method method = methodCache.get(methodName);
+
+        if (method == null) {
+            method = targetClass.getDeclaredMethod(methodName, String.class);
+            methodCache.put(methodName, method);
+        }
+
+        return method;
+    }
+}

java/src/test/java/it/tug/FormatterTest.java

@@ -19,31 +19,45 @@ public void setup() {
         service = mock(Service.class);
         sut = new Formatter(service);
     }
-    
+
     @Test
-    public void shouldReturnAnErrorMessageIfServiceReturnsNull() {
+    public void shouldReturnAnErrorMessageIfServiceReturnsFail() {
         when(this.service.askForPermission()).thenReturn("FAIL");
-        
+
         String actual = sut.doTheJob("foo");
-        
+
         assertEquals("error", actual);
     }
 
     @Test
     public void shouldReturnAnTheStringDoubledIfServiceReturnsOK() {
         when(this.service.askForPermission()).thenReturn("OK");
-        
+
         String actual = sut.doTheJob("foobar");
-        
+
         assertEquals("foobarfoobar", actual);
     }
 
+    @Test
+    public void shouldReturnAnTheStringDoubledIfServiceReturnsOK_AndShouldWorkTwice() {
+        when(this.service.askForPermission()).thenReturn("OK");
+
+        String actual;
+
+        actual = sut.doTheJob("foobar");
+        actual = sut.doTheJob(actual);
+
+        assertEquals("foobarfoobarfoobarfoobar", actual);
+
+
+    }
+
     @Test
     public void shouldReturnNullIfServiceRepliesDifferentlyThanOKOrFAIL() {
         when(this.service.askForPermission()).thenReturn("luchino");
-        
+
         String actual = sut.doTheJob("foobar");
-        
+
         assertEquals(null, actual);
     }
 }