Add the create method for the TestCommandFactory.

src/main/java/space/kklochko/simple_jbdd/annotations/Title.java

@@ -0,0 +1,13 @@
+package space.kklochko.simple_jbdd.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface Title {
+    String value() default "Title";
+}
+

src/main/java/space/kklochko/simple_jbdd/test_examples/Sum.java

@@ -1,8 +0,0 @@
-package space.kklochko.simple_jbdd.test_examples;
-
-public class Sum {
-    static int sum(int a, int b) {
-        return a + b;
-    }
-}
-

src/main/java/space/kklochko/simple_jbdd/test_examples/samples/Sum.java

@@ -0,0 +1,8 @@
+package space.kklochko.simple_jbdd.test_examples.samples;
+
+public class Sum {
+    public static int sum(int a, int b) {
+        return a + b;
+    }
+}
+

src/main/java/space/kklochko/simple_jbdd/test_examples/tests/SimpleFailedThenTest.java

@@ -0,0 +1,15 @@
+package space.kklochko.simple_jbdd.test_examples.tests;
+
+import space.kklochko.simple_jbdd.annotations.Then;
+import space.kklochko.simple_jbdd.annotations.Title;
+import space.kklochko.simple_jbdd.tests.Test;
+
+
+@Title("A Simple Failed GivenWhenTest for Sum")
+public class SimpleFailedThenTest extends Test {
+    @Then
+    public void check() {
+        assert 30 == 10 + 20 + 1;
+    }
+}
+

src/main/java/space/kklochko/simple_jbdd/test_examples/tests/SimpleGivenWhenThenTest.java

@@ -0,0 +1,32 @@
+package space.kklochko.simple_jbdd.test_examples.tests;
+
+import space.kklochko.simple_jbdd.annotations.Given;
+import space.kklochko.simple_jbdd.annotations.Then;
+import space.kklochko.simple_jbdd.annotations.Title;
+import space.kklochko.simple_jbdd.annotations.When;
+import space.kklochko.simple_jbdd.test_examples.samples.Sum;
+import space.kklochko.simple_jbdd.tests.Test;
+
+@Title("A Simple GivenWhenTest for Sum")
+public class SimpleGivenWhenThenTest extends Test {
+    private Sum sum;
+    private int a;
+    private int b;
+
+    @Given
+    void setup() {
+        sum = new Sum();
+    }
+
+    @When
+    void trigger() {
+        a = 10;
+        b = 20;
+    }
+
+    @Then
+    void check() {
+        assert 30 == sum.sum(a, b);
+    }
+}
+

src/main/java/space/kklochko/simple_jbdd/test_examples/tests/SimpleThenTest.java

@@ -0,0 +1,14 @@
+package space.kklochko.simple_jbdd.test_examples.tests;
+
+import space.kklochko.simple_jbdd.annotations.Then;
+import space.kklochko.simple_jbdd.annotations.Title;
+import space.kklochko.simple_jbdd.tests.Test;
+
+@Title("Simple test")
+public class SimpleThenTest extends Test {
+    @Then("The sum of 10 and 20 is 30.")
+    public void check() {
+        assert 30 == 10 + 20;
+    }
+}
+

src/main/java/space/kklochko/simple_jbdd/test_examples/tests/SimpleThenTestWithoutTitle.java

@@ -0,0 +1,13 @@
+package space.kklochko.simple_jbdd.test_examples.tests;
+
+import space.kklochko.simple_jbdd.annotations.Then;
+import space.kklochko.simple_jbdd.annotations.Title;
+import space.kklochko.simple_jbdd.tests.Test;
+
+public class SimpleThenTestWithoutTitle extends Test {
+    @Then("The sum of 10 and 20 is 30.")
+    public void check() {
+        assert 30 == 10 + 20;
+    }
+}
+

src/main/java/space/kklochko/simple_jbdd/tests/Test.java

@@ -0,0 +1,6 @@
+package space.kklochko.simple_jbdd.tests;
+
+public abstract class Test {
+
+}
+

src/main/java/space/kklochko/simple_jbdd/tests/commands/AbstractTestCommand.java

@@ -0,0 +1,43 @@
+package space.kklochko.simple_jbdd.tests.commands;
+
+import space.kklochko.simple_jbdd.tests.Test;
+import java.util.Map;
+import java.util.TreeMap;
+
+public abstract class AbstractTestCommand<T extends Test> {
+    protected String type;
+    protected String label;
+
+    public AbstractTestCommand(String label) {
+        setLabel(label);
+    }
+
+    public abstract boolean test();
+
+    public Map<String, String> getLabels() {
+        Map<String, String> labels = new TreeMap<String, String>();
+        labels.put(getType(), this.getLabel());
+        return labels;
+    }
+
+    public String getType() {
+        return type;
+    }
+
+    public void setType(String type) {
+        this.type = type;
+    }
+
+    public void setLabel(String label) {
+        this.label = label;
+    }
+
+    public String getLabel() {
+        return label;
+    }
+
+    public abstract void setObject(T object);
+
+    public abstract T getObject();
+}
+

src/main/java/space/kklochko/simple_jbdd/tests/commands/SimpleTestCommand.java

@@ -0,0 +1,27 @@
+package space.kklochko.simple_jbdd.tests.commands;
+
+import space.kklochko.simple_jbdd.tests.Test;
+
+public class SimpleTestCommand<T extends Test> extends AbstractTestCommand<T> {
+    protected T object;
+
+    public SimpleTestCommand(String label, T object) {
+        super(label);
+        setObject(object);
+        setType("Title");
+    }
+
+    @Override
+    public boolean test() {
+        return true;
+    }
+
+    public void setObject(T object) {
+        this.object = object;
+    }
+
+    public T getObject() {
+        return object;
+    }
+}
+

src/main/java/space/kklochko/simple_jbdd/tests/commands/decorators/AbstractDecorator.java

@@ -0,0 +1,55 @@
+package space.kklochko.simple_jbdd.tests.commands.decorators;
+
+import space.kklochko.simple_jbdd.tests.Test;
+import space.kklochko.simple_jbdd.tests.commands.AbstractTestCommand;
+
+import java.lang.reflect.Method;
+import java.util.Map;
+
+public abstract class AbstractDecorator<T extends Test> extends AbstractTestCommand<T> {
+    protected AbstractTestCommand<T> command;
+
+    protected Method method;
+
+    public AbstractDecorator(String label, AbstractTestCommand<T> command) {
+        super(label);
+        setCommand(command);
+    }
+
+    public abstract boolean test();
+
+    public Map<String, String> getLabels() {
+        Map<String, String> labels = getCommand().getLabels();
+        labels.put(getType(), this.getLabel());
+        return labels;
+    }
+
+    public abstract boolean runMethod();
+
+    public void setMethod(Method method) {
+        this.method = method;
+    }
+
+    public Method getMethod() {
+        return method;
+    }
+
+    @Override
+    public void setObject(T object) {
+        command.setObject(object);
+    }
+
+    @Override
+    public T getObject() {
+        return command.getObject();
+    }
+
+    public AbstractTestCommand<T> getCommand() {
+        return command;
+    }
+
+    public void setCommand(AbstractTestCommand<T> command) {
+        this.command = command;
+    }
+}
+

src/main/java/space/kklochko/simple_jbdd/tests/commands/decorators/BlockDecorator.java

@@ -0,0 +1,39 @@
+package space.kklochko.simple_jbdd.tests.commands.decorators;
+
+import space.kklochko.simple_jbdd.tests.Test;
+import space.kklochko.simple_jbdd.tests.commands.AbstractTestCommand;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class BlockDecorator<T extends Test> extends AbstractDecorator<T> {
+    public BlockDecorator(String label, AbstractTestCommand<T> command, Method method, String type) {
+        super(label, command);
+        setType(type);
+        setMethod(method);
+    }
+
+    public boolean test() {
+        boolean result = runMethod();
+
+        if(!result)
+            return false;
+
+        return getCommand().test();
+    }
+
+    public boolean runMethod() {
+        try {
+            method.setAccessible(true);
+            method.invoke(getCommand().getObject());
+            return true;
+        } catch (InvocationTargetException e) {
+            System.err.println(e.getMessage());
+            throw new RuntimeException(e);
+        } catch (IllegalAccessException e) {
+            System.err.println("Check access modifiers.");
+            throw new RuntimeException(e);
+        }
+    };
+}
+

src/main/java/space/kklochko/simple_jbdd/tests/factories/TestCommandFactory.java

@@ -0,0 +1,76 @@
+package space.kklochko.simple_jbdd.tests.factories;
+
+import space.kklochko.simple_jbdd.annotations.Given;
+import space.kklochko.simple_jbdd.annotations.Then;
+import space.kklochko.simple_jbdd.annotations.Title;
+import space.kklochko.simple_jbdd.annotations.When;
+import space.kklochko.simple_jbdd.tests.Test;
+import space.kklochko.simple_jbdd.tests.commands.AbstractTestCommand;
+import space.kklochko.simple_jbdd.tests.commands.SimpleTestCommand;
+import space.kklochko.simple_jbdd.tests.commands.decorators.BlockDecorator;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.util.Map;
+import java.util.TreeMap;
+
+public class TestCommandFactory {
+    public AbstractTestCommand create(Test input) {
+	    Class<?> aClass = input.getClass();
+	    Map<String, Method> test_methods = this.getTestMethods(aClass);
+
+        AbstractTestCommand<Test> aTestCommand = createTest(aClass, input);
+
+        if(test_methods.containsKey("Then")) {
+            Method then = test_methods.get("Then");
+            String label = then.getAnnotation(Then.class).value();
+            aTestCommand = new BlockDecorator<Test>(label, aTestCommand, then, "Then");
+        }
+
+        if(test_methods.containsKey("When")) {
+            Method when = test_methods.get("When");
+            String label = when.getAnnotation(When.class).value();
+            aTestCommand = new BlockDecorator<Test>(label, aTestCommand, when, "When");
+        }
+
+        if(test_methods.containsKey("Given")) {
+            Method when = test_methods.get("Given");
+            String label = when.getAnnotation(Given.class).value();
+            aTestCommand = new BlockDecorator<Test>(label, aTestCommand, when, "Given");
+        }
+
+        return aTestCommand;
+    }
+
+    protected AbstractTestCommand<Test> createTest(Class<?> aClass, Test input) {
+        Title aTitle = aClass.getAnnotation(Title.class);
+        String title = aClass.getName();
+
+        if(aTitle != null)
+            title = aTitle.value();
+
+        return new SimpleTestCommand<Test>(title, input);
+    }
+
+    protected <T extends Test> Map<String, Method> getTestMethods(Class<?> aClass) {
+        Map<String, Method> test_methods = new TreeMap<String, Method>();
+
+        for(Method method : aClass.getDeclaredMethods()) {
+            Annotation[] annotations = method.getAnnotations();
+
+            if (annotations.length == 0)
+                continue;
+
+            if(method.isAnnotationPresent(Given.class))
+                test_methods.put("Given", method);
+
+            if(method.isAnnotationPresent(When.class))
+                test_methods.put("When", method);
+
+            if(method.isAnnotationPresent(Then.class))
+                test_methods.put("Then", method);
+        }
+
+        return test_methods;
+    }
+}

src/test/groovy/space/kklochko/simple_jbdd/test_examples/samples/SumSpec.groovy

@@ -1,5 +1,6 @@
-package space.kklochko.simple_jbdd.test_examples
+package space.kklochko.simple_jbdd.test_examples.samples
 
+import space.kklochko.simple_jbdd.test_examples.samples.Sum
 import spock.lang.Specification
 
 class SumSpec extends Specification {

src/test/groovy/space/kklochko/simple_jbdd/tests/factories/TestCommandFactorySpec.groovy

@@ -0,0 +1,96 @@
+package space.kklochko.simple_jbdd.tests.factories
+
+import space.kklochko.simple_jbdd.test_examples.tests.SimpleGivenWhenThenTest
+import space.kklochko.simple_jbdd.test_examples.tests.SimpleThenTest
+import space.kklochko.simple_jbdd.test_examples.tests.SimpleThenTestWithoutTitle
+import space.kklochko.simple_jbdd.tests.factories.TestCommandFactory
+import spock.lang.Narrative;
+import spock.lang.Specification
+import spock.lang.Subject
+import spock.lang.Title
+
+@Narrative("""The factory must generate a test command, so
+those tests check if factory generate them right.
+""")
+@Title("Unit test for TestCommandFactory")
+class TestCommandFactorySpec extends Specification {
+    def "If the map of methods have one test block."() {
+        given: "I have a TestCommandFactory object"
+        @Subject
+        def factory = new TestCommandFactory();
+
+        and: "I also have a SimpleThenTest object"
+        def simpleThenTest = new SimpleThenTest()
+
+        when: "If a test have only one block"
+        def map = factory.getTestMethods(simpleThenTest.getClass())
+
+        then: "the map size is 1 method"
+        1 == map.size()
+    }
+
+    def "createTest() sets the title to a class name if no Title annotation."() {
+        given: "I have a test factory"
+        @Subject
+        def factory = new TestCommandFactory()
+
+        and: "I have a test class without Title"
+        def testClass = new SimpleThenTestWithoutTitle()
+
+        when: "I build a test"
+        def test = factory.create(testClass)
+
+        then: "The test have title as the test class"
+        testClass.class.getName() == test.getLabels()['Title']
+    }
+
+    def "createTest() sets the title to a value of the Title annotation."() {
+        given: "I have a test factory"
+        @Subject
+        def factory = new TestCommandFactory()
+
+        and: "I have a test class with Title"
+        def testClass = new SimpleThenTest()
+
+        and: "and the title of the annotation"
+        def titleClass = space.kklochko.simple_jbdd.annotations.Title.class
+        def title = testClass.getClass().getAnnotation(titleClass).value()
+
+        when: "I build a test"
+        def test = factory.create(testClass)
+
+        then: "The test have title as the test class"
+        title == test.getLabels()['Title']
+    }
+
+    def "createTest() build a Test with only Then."() {
+        given: "I have a test factory"
+        @Subject
+        def factory = new TestCommandFactory()
+
+        and: "I have a test class with Title"
+        def testClass = new SimpleThenTest()
+
+        when: "I build a test"
+        def test = factory.create(testClass)
+
+        then: "The test have title and then method"
+        ['Title', 'Then'].toSet() == test.getLabels().keySet()
+    }
+
+    def "createTest() build a Test with Given-When-Then."() {
+        given: "I have a test factory"
+        @Subject
+        def factory = new TestCommandFactory()
+
+        and: "I have a test class with Title and Given-When-Then"
+        def testClass = new SimpleGivenWhenThenTest()
+
+        when: "I build a test"
+        def test = factory.create(testClass)
+
+        then: "The test have title and then method"
+        ['Title', 'Given', 'When', 'Then'].toSet() == test.getLabels().keySet()
+    }
+}
+