Fix the encoding issue.

build.gradle

@@ -12,6 +12,10 @@ java {
     }
 }
 
+compileJava {
+    options.encoding = 'UTF-8'
+}
+
 repositories {
   // Spock releases are available from Maven Central
   mavenCentral()

src/main/java/space/kklochko/simple_jbdd/tests/factories/meta/AbstractTestCommandMetaDataFactory.java

@@ -0,0 +1,9 @@
+package space.kklochko.simple_jbdd.tests.factories.meta;
+
+import java.util.AbstractMap;
+import java.util.ArrayList;
+
+public abstract class AbstractTestCommandMetaDataFactory {
+    abstract public ArrayList<AbstractMap.SimpleEntry<String, String>> create();
+}
+

src/main/java/space/kklochko/simple_jbdd/tests/factories/meta/TestCommandMetaDataFactory.java

@@ -0,0 +1,34 @@
+package space.kklochko.simple_jbdd.tests.factories.meta;
+
+import space.kklochko.simple_jbdd.tests.commands.AbstractTestCommand;
+import space.kklochko.simple_jbdd.tests.commands.decorators.AbstractDecorator;
+
+import java.util.AbstractMap;
+import java.util.ArrayList;
+
+public class TestCommandMetaDataFactory extends AbstractTestCommandMetaDataFactory {
+    private AbstractTestCommand command;
+
+    public TestCommandMetaDataFactory(AbstractTestCommand command) {
+        this.command = command;
+    }
+
+    public ArrayList<AbstractMap.SimpleEntry<String, String>> create() {
+        ArrayList<AbstractMap.SimpleEntry<String, String>> blocks = new ArrayList<>();
+        AbstractTestCommand currentCommand = command;
+        Class<?> aClass = command.getClass();
+
+        while(AbstractDecorator.class.isAssignableFrom(aClass)) {
+            AbstractDecorator block = (AbstractDecorator) currentCommand;
+            blocks.add(new AbstractMap.SimpleEntry<>(block.getType(), block.getLabel()));
+
+            currentCommand = block.getCommand();
+            aClass = currentCommand.getClass();
+        }
+
+        blocks.add(0, (new AbstractMap.SimpleEntry<>(currentCommand.getType(), currentCommand.getLabel())));
+
+        return blocks;
+    }
+}
+

src/main/java/space/kklochko/simple_jbdd/tests/loaders/ClassLoader.java

@@ -0,0 +1,26 @@
+package space.kklochko.simple_jbdd.tests.loaders;
+
+import java.util.ArrayList;
+import java.util.Set;
+
+public class ClassLoader<T> {
+
+    AbstractNameClassLoader nameLoader;
+
+    public ClassLoader(AbstractNameClassLoader nameLoader) {
+        this.nameLoader = nameLoader;
+    }
+
+    public ArrayList<T> load() {
+        Set<Class<?>> names = nameLoader.load();
+        ArrayList<T> classes = new ArrayList<>();
+
+        for(Class<?> name : names) {
+            SingleClassLoader loader = new SingleClassLoader(name.getName());
+            classes.add((T) loader.load());
+        }
+
+        return classes;
+    }
+}
+

src/main/java/space/kklochko/simple_jbdd/tests/reports/fmt/SimpleTestReportFormatter.java

@@ -0,0 +1,57 @@
+package space.kklochko.simple_jbdd.tests.reports.fmt;
+
+import space.kklochko.simple_jbdd.tests.Test;
+
+import java.util.AbstractMap;
+import java.util.ArrayList;
+
+public class SimpleTestReportFormatter {
+    private ArrayList<AbstractMap.SimpleEntry<String, String>> testMetaData;
+    private boolean isPassed;
+    final private String passedIcon = "✓";
+    final private String failedIcon = "⨯";
+
+    public SimpleTestReportFormatter(ArrayList<AbstractMap.SimpleEntry<String, String>> testMetaData, boolean isPassed) {
+        setTestMetaData(testMetaData);
+        setPassed(isPassed);
+    }
+
+    public String format() {
+        String status = (isPassed) ? getPassedIcon() : getFailedIcon();
+        String title = getTestMetaData().get(0).getValue();
+
+        String result = String.format("%s %s\n", status, title);
+
+        for(int i=1; i<getTestMetaData().size(); ++i) {
+            AbstractMap.SimpleEntry<String, String> pair = getTestMetaData().get(i);
+            result += String.format("\t%s %s\n", pair.getKey(), pair.getValue());
+        }
+
+        return result;
+    }
+
+    public ArrayList<AbstractMap.SimpleEntry<String, String>> getTestMetaData() {
+        return testMetaData;
+    }
+
+    public void setTestMetaData(ArrayList<AbstractMap.SimpleEntry<String, String>> testMetaData) {
+        this.testMetaData = testMetaData;
+    }
+
+    public boolean isPassed() {
+        return isPassed;
+    }
+
+    public void setPassed(boolean passed) {
+        isPassed = passed;
+    }
+
+    public String getPassedIcon() {
+        return passedIcon;
+    }
+
+    public String getFailedIcon() {
+        return failedIcon;
+    }
+}
+

src/test/groovy/space/kklochko/simple_jbdd/tests/factories/meta/IntegratedTestCommandMetaDataFactorySpec.groovy

@@ -0,0 +1,46 @@
+package space.kklochko.simple_jbdd.tests.factories.meta
+
+import space.kklochko.simple_jbdd.test_examples.tests.SimpleFailedThenTest
+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.commands.AbstractTestCommand
+import space.kklochko.simple_jbdd.tests.commands.decorators.BlockDecorator
+import space.kklochko.simple_jbdd.tests.factories.TestCommandFactory
+import space.kklochko.simple_jbdd.tests.runners.SimpleTestRunner
+import spock.lang.Narrative
+import spock.lang.Specification
+import spock.lang.Subject
+import spock.lang.Title
+
+@Narrative("""The factory must generate a test command metadata, so
+those tests check if the factory generate it right.
+""")
+@Title("Integrated tests for TestCommandMetaDataFactory")
+class IntegratedTestCommandMetaDataFactorySpec extends Specification {
+    def "Metadata have  the map of methods have one test block."() {
+        given: "I have a command factory"
+        def commandFactory = new TestCommandFactory();
+
+        and: "I have a command of a test"
+        def command = commandFactory.create(testObject)
+
+        and: "I have a TestCommandMetaDataFactory object"
+        @Subject
+        def factory = new TestCommandMetaDataFactory(command)
+
+        when: "Parse the command to get metadata"
+        def metadata = factory.create()
+
+        then: "the metadata have only two labels for Title and Then"
+        expectedCount == metadata.size()
+
+        where: "Possible variants of tests"
+        testObject                       || expectedCount
+        new SimpleThenTest()             || 2
+        new SimpleGivenWhenThenTest()    || 4
+        new SimpleThenTestWithoutTitle() || 2
+        new SimpleFailedThenTest()       || 2
+    }
+}
+

src/test/groovy/space/kklochko/simple_jbdd/tests/factories/meta/TestCommandMetaDataFactorySpec.groovy

@@ -0,0 +1,93 @@
+package space.kklochko.simple_jbdd.tests.factories.meta
+
+import space.kklochko.simple_jbdd.test_examples.tests.SimpleGivenWhenThenTest
+import space.kklochko.simple_jbdd.test_examples.tests.SimpleThenTest
+import space.kklochko.simple_jbdd.tests.commands.AbstractTestCommand
+import space.kklochko.simple_jbdd.tests.commands.decorators.BlockDecorator
+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 metadata, so
+those tests check if the factory generate it right.
+""")
+@Title("Unit tests for TestCommandMetaDataFactory")
+class TestCommandMetaDataFactorySpec extends Specification {
+    def "If the map of methods have one test block."() {
+        given: "I have a simple test with only Then block and its command."
+        def test = Mock(AbstractTestCommand) {
+            getType() >> "Title"
+            getLabel() >> "A simple test"
+        }
+
+        def command = GroovyMock(BlockDecorator) {
+            getType() >> "Then"
+            getLabel() >> "Then block"
+            getCommand() >> test
+        }
+
+        and: "I have a TestCommandMetaDataFactory object"
+        @Subject
+        def factory = new TestCommandMetaDataFactory(command)
+
+        when: "Parse the command to get metadata"
+        def metadata = factory.create()
+
+        then: "The metadata have only two labels for Title and Then"
+        2 == metadata.size()
+
+        and: "The format and the order must be the same"
+        metadata == [
+                new AbstractMap.SimpleEntry<>("Title", "A simple test"),
+                new AbstractMap.SimpleEntry<>("Then", "Then block")
+        ]
+    }
+
+    def "If the map of methods have GivenWhenThen blocks."() {
+        given: "I have a simple test with only Then block and its command."
+        def test = Mock(AbstractTestCommand) {
+            getType() >> "Title"
+            getLabel() >> "A simple test"
+        }
+
+        and: "Bootstrapping the test command"
+        def then = GroovyMock(BlockDecorator) {
+            getType() >> "Then"
+            getLabel() >> "Then block"
+            getCommand() >> test
+        }
+
+        def when = GroovyMock(BlockDecorator) {
+            getType() >> "When"
+            getLabel() >> "When block"
+            getCommand() >> then
+        }
+
+        def command = GroovyMock(BlockDecorator) {
+            getType() >> "Given"
+            getLabel() >> "Given block"
+            getCommand() >> when
+        }
+
+        and: "I have a TestCommandMetaDataFactory object"
+        @Subject
+        def factory = new TestCommandMetaDataFactory(command)
+
+        when: "Parse the command to get metadata"
+        def metadata = factory.create()
+
+        then: "The metadata have only two labels for Title and Then"
+        4 == metadata.size()
+
+        and: "The format and the order must be the same"
+        metadata == [
+                new AbstractMap.SimpleEntry<>("Title", "A simple test"),
+                new AbstractMap.SimpleEntry<>("Given", "Given block"),
+                new AbstractMap.SimpleEntry<>("When", "When block"),
+                new AbstractMap.SimpleEntry<>("Then", "Then block")
+        ]
+    }
+}
+

src/test/groovy/space/kklochko/simple_jbdd/tests/loaders/IntegratedClassLoader.groovy

@@ -0,0 +1,43 @@
+package space.kklochko.simple_jbdd.tests.loaders
+
+import spock.lang.Narrative
+import spock.lang.Specification
+import spock.lang.Subject
+import spock.lang.Title
+
+@Narrative("""The loader must return a test classes or null, so
+those tests check if responses are right.
+""")
+@Title("Integrated tests for ClassLoader.")
+class IntegratedClassLoader extends Specification {
+    def "The classes have been loaded."() {
+        given: "I have a name class loader"
+        def nameLoader = new NameClassLoader()
+
+        and: "I have a loader for classes"
+        @Subject
+        def loader = new ClassLoader(nameLoader)
+
+        when: "The classes were loaded"
+        def classes = loader.load()
+
+        then: "Checking that the test result is expected"
+        3 == classes.size()
+    }
+
+    def "The classes must be represent the Test interface."() {
+        given: "I have a name class loader"
+        def nameLoader = new NameClassLoader()
+
+        and: "I have a loader for classes"
+        @Subject
+        def loader = new ClassLoader(nameLoader)
+
+        when: "The classes were loaded"
+        def classes = loader.load()
+
+        then: "Checking that the test result is expected"
+        classes.every({ space.kklochko.simple_jbdd.tests.Test.class.isAssignableFrom(it) })
+    }
+}
+

src/test/groovy/space/kklochko/simple_jbdd/tests/reports/fmt/SimpleTestReportFormatterSpec.groovy

@@ -0,0 +1,68 @@
+package space.kklochko.simple_jbdd.tests.reports.fmt
+
+import space.kklochko.simple_jbdd.test_examples.tests.SimpleFailedThenTest
+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.commands.AbstractTestCommand
+import space.kklochko.simple_jbdd.tests.commands.decorators.BlockDecorator
+import space.kklochko.simple_jbdd.tests.factories.meta.TestCommandMetaDataFactory
+import spock.lang.Narrative
+import spock.lang.Specification
+import spock.lang.Subject
+import spock.lang.Title
+
+@Narrative("""The formatter must generate a format for the test command metadata, so
+those tests check if the formatter generate it right.
+""")
+@Title("Unit tests for SimpleTestReportFormatter")
+class SimpleTestReportFormatterSpec extends Specification {
+    def "If the map of methods have one test block."() {
+        given: "I have a metaData"
+        def metaData = [
+            new AbstractMap.SimpleEntry<>("Title", "A simple test"),
+            new AbstractMap.SimpleEntry<>("Then", "Then block")
+        ]
+
+        and: "I have the formatter object"
+        @Subject
+        def formatter = new SimpleTestReportFormatter(metaData, isPassed)
+
+        when: "Generate the format"
+        def format = formatter.format()
+
+        then: "The format must be the same"
+        expectedFormat == format
+
+        where: "Possible variants of tests"
+        isPassed || expectedFormat
+        true     || "✓ A simple test\n\tThen Then block\n"
+        false    || "⨯ A simple test\n\tThen Then block\n"
+    }
+
+    def "If the map of methods have GivenWhenThen blocks."() {
+        given: "I have a metaData"
+        def metaData = [
+            new AbstractMap.SimpleEntry<>("Title", "A simple test"),
+            new AbstractMap.SimpleEntry<>("Given", "Given block"),
+            new AbstractMap.SimpleEntry<>("When", "When block"),
+            new AbstractMap.SimpleEntry<>("Then", "Then block")
+        ]
+
+        and: "I have the formatter object"
+        @Subject
+        def formatter = new SimpleTestReportFormatter(metaData, isPassed)
+
+        when: "Generate the format"
+        def format = formatter.format()
+
+        then: "The format must be the same"
+        expectedFormat == format
+
+        where: "Possible variants of tests"
+        isPassed || expectedFormat
+        true     || "✓ A simple test\n\tGiven Given block\n\tWhen When block\n\tThen Then block\n"
+        false    || "⨯ A simple test\n\tGiven Given block\n\tWhen When block\n\tThen Then block\n"
+    }
+}
+