What Mr. Spock would possibly say about modern unit testing: pragmatic and emotional overview

import org.junit.Test;
import static org.junit.Assert.assertEquals;

    @Test (1)
    public void arrayList_length_ind() {
        ArrayList<String> list = new ArrayList<>();
        list.add("we");
        list.add("all");
        list.add("love");
        list.add("junit");
        assertEquals(list.size(), 4); (2)
    }

import org.testng.annotations.Test;
import static org.testng.Assert.assertEquals;

    @Test (1)
    public void arrayList_length_idm() {
        ArrayList<String> list = new ArrayList<>();
        list.add("we");
        list.add("all");
        list.add("love");
        list.add("testng");
        assertEquals(list.size(), 4); (2)
    }

'org.spockframework:spock-core:1.1-groovy-2.4-rc-2'
'cglib:cglib-nodep:3.2.2'
'org.objenesis:objenesis:2.4'

        assertEquals(list.size(), 3);
//        java.lang.AssertionError:
//        Expected :4
//        Actual   :3

        assertTrue(list.size() == 3);
//        java.lang.AssertionError
//        at org.junit.Assert.fail(Assert.java:86)
//        at org.junit.Assert.assertTrue(Assert.java:41)
//        at org.junit.Assert.assertTrue(Assert.java:52)

import static org.hamcrest.Matchers.hasSize
import static org.junit.Assert.assertThat

        assertThat(list, hasSize(3));
//        java.lang.AssertionError:
//        Expected: a collection with size <3>
//        but: collection size was <4>

import com.google.common.truth.Truth
import org.assertj.core.api.Assertions

        Assertions.assertThat(list).hasSize(3);
//        java.lang.AssertionError:
//        Expected size:<3> but was:<4> in:
//        <["we", "will", "love", "spock"]>

        Truth.assertThat(list).hasSize(3);
//      java.lang.AssertionError: Not true that <[we, will, love, spock]> has a size of <3>. It is <4>

        then:
        list.size() == 3
//        Condition not satisfied:
//
//        list.size() == 3
//        |    |      |
//        |    4      false
//        [we, will, love, spock]

import static spock.util.matcher.HamcrestSupport.expect

        then:
        expect list, hasSize(3)
//        Condition not satisfied:
//
//        expect list, hasSize(3)
//        |      |
//        false  [we, will, love, spock]
//
//        Expected: a collection with size <3>
//        but: collection size was <4>

    @Test
    void 'ArrayList.size()'() {
        // setup
        ArrayList<String> list = new ArrayList<>()

        // run
        list.add 'we'
        list.add 'will'
        list.add 'love'
        list.add 'spock'

        // verify
        assert list.findAll({ it.length() < 5 }) == list.drop(2)
//        Assertion failed:
//
//        assert list.findAll({ it.length() < 5 }) == list.drop(2)
//        |    |                            |  |    |
//        |    [we, will, love]             |  |    [love, spock]
//        [we, will, love, spock]           |  [we, will, love, spock]
//        false
    }

import org.junit.After
import org.junit.AfterClass
import org.junit.Before
import org.junit.BeforeClass
import org.junit.Test

    static Sql sql (1)

    @BeforeClass (2)
    public static void createTable() {
        sql = Sql.newInstance("jdbc:h2:mem:", "org.h2.Driver")
        sql.execute("create table testing_tool (id int primary key, name varchar(100), version varchar(100))")
    }

    @Before (3)
    public void insertBasicData() {
        sql.execute("insert into testing_tool values (1, 'junit', '4.12'), (2, 'spock', '1.0'), (3, 'testng', '6.9.10')")
    }

    @Test (4)
    public void toolCount() {
        // run
        def actual = sql.firstRow("select count(*) as toolCount from testing_tool")

        // verify
        assertThat(actual.toolCount, is(3L))
    }

    @After (5)
    public void cleanTable() {
        sql.execute("delete from testing_tool")
    }

    @AfterClass (6)
    public static void dropTable() {
        sql.execute("drop table testing_tool")
        sql.close()
    }

import org.testng.annotations.AfterClass
import org.testng.annotations.AfterMethod
import org.testng.annotations.BeforeClass
import org.testng.annotations.BeforeMethod
import org.testng.annotations.Test

    static Sql sql (1)

    @BeforeClass (2)
    public static void createTable() {
        sql = Sql.newInstance("jdbc:h2:mem:", "org.h2.Driver")
        sql.execute("create table testing_tool (id int primary key, name varchar(100), version varchar(100))")
    }

    @BeforeMethod (3)
    public void insertBasicData() {
        sql.execute("insert into testing_tool values (1, 'junit', '4.12'), (2, 'spock', '1.0'), (3, 'testng', '6.9.10')")
    }

    @Test (4)
    public void toolCount() {
        // run
        def actual = sql.firstRow("select count(*) as toolCount from testing_tool")

        // verify
        assertEquals(actual.toolCount, 3L)
    }

    @AfterMethod (5)
    public void cleanTable() {
        sql.execute("delete from testing_tool")
    }

    @AfterClass (6)
    public static void dropTable() {
        sql.execute("drop table testing_tool")
        sql.close()
    }

import org.junit.jupiter.api.AfterAll
import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.BeforeAll
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test

    static Sql sql

    @BeforeAll
    public static void createTable() {
        sql = Sql.newInstance("jdbc:h2:mem:", "org.h2.Driver")
        sql.execute("create table testing_tool (id int primary key, name varchar(100), version varchar(100))")
    }

    @BeforeEach
    public void insertBasicData() {
        sql.execute("insert into testing_tool values (1, 'junit', '4.12'), (2, 'spock', '1.0'), (3, 'testng', '6.9.10')")
    }

    @Test
    public void toolCount() {
        // run
        def actual = sql.firstRow("select count(*) as toolCount from testing_tool")

        // verify
        assertEquals(3L, actual.toolCount)
    }

    @AfterEach
    public void cleanTable() {
        sql.execute("delete from testing_tool")
    }

    @AfterAll
    public static void dropTable() {
        sql.execute("drop table testing_tool")
        sql.close()
    }

import groovy.sql.Sql

trait DatabaseSpec {

    static Sql sql (1)

    def setupSpec() { (2)
        sql = Sql.newInstance("jdbc:h2:mem:", "org.h2.Driver")
        sql.execute("create table testing_tool (id int primary key, name varchar(100), version varchar(100))")
    }

    def setup() { (3)
        sql.execute("insert into testing_tool values (1, 'junit', '4.12'), (2, 'spock', '1.0'), (3, 'testng', '6.9.10')")
    }

    def cleanup() { (4)
        sql.execute("delete from testing_tool")
    }

    def cleanupSpec() { (5)
        sql.execute("drop table testing_tool")
        sql.close()
    }
}

class N11S_SetupTeardown_AsYouLike extends Specification implements DatabaseSpec {

    def 'tool count'() {
        when: 'we count number of unit testing tools'
        def actual = sql.firstRow("select count(*) as toolCount from testing_tool")

        then: 'it should be 3'
        actual.toolCount == 3
    }

    @Shared @AutoCleanup sql  (1) (2)

    def 'JUnit5 is in game!'() {
        setup: 'add JUnit 5 to the list of unit testing tools' (3)
        sql.execute("insert into testing_tool values (4, 'junit', '5')")

        when: 'we count number of JUnits'
        def actual = sql.firstRow("select count(*) as toolCount from testing_tool where name = 'junit'")

        then: 'it should be 2'
        actual.toolCount == 2

        cleanup: 'remove JUnit 5 from the list of unit testing tools' (4)
        sql.execute("delete from testing_tool where id = 4")
    }

class N14S_SharedExplained_BasicStatic extends Specification {

    static List arrayList = new ArrayList<String>()
}

@Stepwise
class N14S_SharedExplained_Static_1 extends N14S_SharedExplained_BasicStatic {

    def 'static ArrayList and junit'() {
        when:
        N14S_SharedExplained_BasicStatic.arrayList.add('junit')

        then:
        N14S_SharedExplained_BasicStatic.arrayList.size() == 1
    }

    def 'static ArrayList and spock'() {
        when:
        N14S_SharedExplained_BasicStatic.arrayList.add('spock')

        then:
        N14S_SharedExplained_BasicStatic.arrayList.size() == 2
    }
}

class N14S_SharedExplained_Static_2 extends N14S_SharedExplained_BasicStatic {

    def 'static ArrayList and testng'() {
        when:
        N14S_SharedExplained_BasicStatic.arrayList.add('junit')

        then:
        N14S_SharedExplained_BasicStatic.arrayList.size() == 1
    }
}

class N14S_SharedExplained_BasicShared extends Specification {

    @Shared
            arrayList = new ArrayList<String>()
}

@Stepwise
class N14S_SharedExplained_Shared_1 extends N14S_SharedExplained_BasicShared {

    def 'shared ArrayList and junit'() {
        when:
        arrayList.add('junit')

        then:
        arrayList.size() == 1
    }

    def 'shared ArrayList and spock'() {
        when:
        arrayList.add('spock')

        then:
        arrayList.size() == 2
    }
}

class N14S_SharedExplained_Shared_2 extends N14S_SharedExplained_BasicShared {

    def 'shared ArrayList and testng'() {
        when:
        arrayList.add('junit')

        then:
        arrayList.size() == 1
    }
}

import spock.lang.Issue
import spock.lang.Narrative
import spock.lang.Specification
import spock.lang.Subject
import spock.lang.Title

@Title('ArrayList tests') (1)
@Narrative('''
As Java developer
(that trust nothing)
I want to be sure ArrayList works
''') (2)
@Report
class N07S_IdiomaticSpock extends Specification {

    @Subject (3)
    ArrayList<String> list

    @Issue('https://github.com/yermilov/spock-talk/issues/1') (4)
    def 'ArrayList.size()'() {
        setup: 'new ArrayList instance' (5)
        list = new ArrayList<>()

        expect: 'that newly created ArrayList instance is empty' (6)
        list.empty

        when: 'add value to list' (7)
        list.add 'we'

        and: 'add one more value to list' (8)
        list.add 'will'

        then: 'array list size should be 2' (9)
        list.size() == 2

        when: 'add two more values into list'
        list.add 'love'
        list.add 'spock'

        then: 'array list size should be 4'
        list.size() == 4

        and: 'list contains all needed values'
        list == [ 'we', 'will', 'love', 'spock' ]
    }
}

testCompile('com.athaydes:spock-reports:1.2.10') {
    transitive = false // this avoids affecting your version of Groovy/Spock
}

    def 'is coin flip good enough for determine if integer is prime'() {
        when: 'we flip a coin'
        boolean coinFlip = new Random().nextBoolean()

        then: 'it will be great if coin flip predict if number is prime'
        (number % 2 == 0 ? false : coinFlip) == expectedAnswer (4)

        where: 'data is random' (1)
        number << (1..5).collect({ new Random().nextInt(1000) }).findAll({ it >= 2 }).sort() (2)
        expectedAnswer = Primes.isPrime(number) (3)
    }

    @Unroll (1)
    def 'calculate runner speed and location after some time for #description'() { (2)
        expect: 'that runner speed is equal to expected'
        speed0 + accl * time == speed1

        and: 'runner location is equal to expected'
        coord0 + time * (speed0 + accl / 2 * time) == coord1

        where: 'there are set of precalculated data for different situations' (3)
        coord0 | speed0 | accl | time || coord1 | speed1 || description
        0      | 6      | 0    | 10   || 60     | 6      || 'steady run from starting point'
        5      | 0      | 3    | 3    || 17     | 9      || 'start from still with acceleration'
        -50    | 10     | -1   | 10   || 0      | 0      || 'constant deceleration'
    }

@RunWith(Parameterized.class)
public class N16J_DataProviders {

    @Parameterized.Parameters(name = "calc runner speed and location after some time for {6}")
    public static Collection<Object[]> data() {
        return Arrays.asList(new Object[][] {
            { 0.0,   6.0,  0.0,  10.0, 60.0, 6.0, "steady run from starting point" },
            { 5.0,   0.0,  3.0,  3.0,  17.0, 9.0, "starting from standing with acceleration" },
            { -50.0, 10.0, -1.0, 10.0, 0.0,  0.0, "constant deceleration"}
        });
    }

    @Parameterized.Parameter(value = 0)
    public double initialLocation;

    @Parameterized.Parameter(value = 1)
    public double initialSpeed;

    @Parameterized.Parameter(value = 2)
    public double acceleration;

    @Parameterized.Parameter(value = 3)
    public double time;

    @Parameterized.Parameter(value = 4)
    public double expectedLocation;

    @Parameterized.Parameter(value = 5)
    public double expectedSpeed;

    @Parameterized.Parameter(value = 6)
    public String description;

    @Test
    public void speed() {
        double speed = initialSpeed + acceleration * time;
        assertThat(speed, is(equalTo(expectedSpeed)));
    }

    @DataProvider(name = "data")
    public static Object[][] data() {
        return new Object[][] {
            { 0.0,   6.0,  0.0,  10.0, 60.0, 6.0 },
            { 5.0,   0.0,  3.0,  3.0,  17.0, 9.0 },
            { -50.0, 10.0, -1.0, 10.0, 0.0,  0.0 }
        };
    }

    @Test(dataProvider = "data")
    public void speed(double initialLocation, double initialSpeed, double acceleration, double time, double expectedLocation, double expectedSpeed) {
        double speed = initialSpeed + acceleration * time;
        assertEquals(speed, expectedSpeed);
    }

    private static final Object[][] DATA = new Object[][] {
            { 0.0,   6.0,  0.0,  10.0, 60.0, 6.0, "steady run from starting point" },
            { 5.0,   0.0,  3.0,  3.0,  17.0, 9.0, "starting from standing with acceleration" },
            { -50.0, 10.0, -1.0, 10.0, 0.0,  0.0, "constant deceleration"}
    };

    @TestFactory
    public Stream<DynamicTest> speedTests() {
        return Arrays.stream(DATA).map(data -> dynamicTest(data[6].toString(), () -> {
            double initialSpeed = (double) data[1];
            double acceleration = (double) data[2];
            double time = (double) data[3];
            double expectedSpeed = (double) data[5];

            double speed = initialSpeed + acceleration * time;
            assertEquals(expectedSpeed, speed);
        }));
    }

    @Test(expected = IndexOutOfBoundsException.class)
    public void exception_oldWay() {
        // setup
        ArrayList<Integer> arrayList = new ArrayList<>();

        // run
        arrayList.get(17);
    }

    @Test
    public void exceptionAndMessage_oldWay() {
        // setup
        ArrayList<Integer> arrayList = new ArrayList<>();

        // run
        try {
            arrayList.get(17);
            fail("Expected an IndexOutOfBoundsException to be thrown");
        } catch (IndexOutOfBoundsException exception) {
            // verify
            assertThat(exception.getMessage(), is("Index: 17, Size: 0"));
        }
    }

    def 'empty ArrayList has no 17th element'() {
        given: 'empty array list'
        def arrayList = new ArrayList<Integer>()

        when: 'we try to retrieve element with index #17'
        arrayList.get(17)

        then: 'exception is thrown with expected message'
        IndexOutOfBoundsException exception = thrown()
        exception.message == 'Index: 17, Size: 0'
    }

    @Test
    public void noException_oldWay() {
        // setup
        ArrayList<Integer> arrayList = new ArrayList<>();

        // run
        arrayList.size();

        // verify no exception is thrown
    }

    @Test
    public void noException_uglyWay() {
        // setup
        ArrayList<Integer> arrayList = new ArrayList<>();

        // run
        try {
            arrayList.size();
        } catch (Exception exception) {
            // verify no exception is thrown
            fail("Expected no exception to be thrown");
        }
    }

    def 'large ArrayList has 17th element'() {
        given: 'list of 28 prime numbers'
        def arrayList = new ArrayList<Integer>()
        28.times { arrayList << Primes.nextPrime(arrayList.empty ? 1 : arrayList[-1]) }

        when: 'we try to retrieve element with index #17'
        arrayList.get(17)

        then: 'no exception is thrown'
        notThrown(IndexOutOfBoundsException)
    }

    @Rule
    public ExpectedException thrown = ExpectedException.none();


    @Test
    public void exception_modernWay() {
        // setup
        ArrayList<Integer> arrayList = new ArrayList<>();

        // expect
        thrown.expect(IndexOutOfBoundsException.class);
        thrown.expectMessage(is("Index: 17, Size: 0"));

        // run
        arrayList.get(17);
    }

    @Test
    public void exception() {
        // setup
        ArrayList<Integer> arrayList = new ArrayList<>();

        // run & verify
        Throwable thrown = expectThrows(IndexOutOfBoundsException.class, () -> { arrayList.get(17); });
        assertEquals("Index: 17, Size: 0", thrown.getMessage());
    }

    @Test(expectedExceptions = IndexOutOfBoundsException.class, expectedExceptionsMessageRegExp = "Index: 17, Size: 0")
    public void exception_oldWay() {
        // setup
        ArrayList<Integer> arrayList = new ArrayList<>();

        // run
        arrayList.get(17);
    }

import org.spockframework.runtime.AbstractRunListener
import org.spockframework.runtime.extension.AbstractAnnotationDrivenExtension
import org.spockframework.runtime.model.FeatureInfo
import org.spockframework.runtime.model.SpecInfo

class ReportExtension extends AbstractAnnotationDrivenExtension<Report> { (1)

    @Override
    void visitSpecAnnotation(Report annotation, SpecInfo spec) {
        spec.addListener(new AbstractRunListener() { (2)

            @Override
            void afterFeature(FeatureInfo feature) {
                for (block in feature.blocks) { (3)
                    for (text in block.texts) { (4)
                        println "${block.kind.name().toLowerCase()} $text" (5)
                    }
                }
            }
        })
    }
}

@Stepwise
class N48S_SystemProperties extends Specification {

    @RestoreSystemProperties
    def 'set spock version'() {
        expect: 'that spock.version is not set'
        System.getProperty('spock.version') == null

        when: 'spock version is set'
        System.setProperty('spock.version', '1.1')

        then: 'we can retrieve its value back'
        System.getProperty('spock.version') == '1.1'
    }

    def 'check spock version is not set'() {
        expect: 'that spock.version is not set'
        System.getProperty('spock.version') == null
    }
}

        then: 'list is not empty, is of size 4, and contains all added values'
        with(list) {
            empty == false
            size() == 4
            get(0) == 'we'
            get(1) == 'will'
            get(2) == 'love'
            get(3) == 'spock'
        }

        then: 'list is not empty, is of size 3, and contains all added values'
        verifyAll {
            list.empty == false
            list.size() == 3
            list.get(0) == 'we'
            list.get(1) == 'love'
            list.get(2) == 'spock'
        }

class N51S_JUnitRules extends Specification {

    @org.junit.Rule OutputCapture capture = new OutputCapture()

    def "capture output print method"() {
        when: 'text is printed to console'
        print "2 + 2 = ${2+2}"

        then: 'it is printed as expected'
        capture.toString() == '2 + 2 = 4'
    }
}

    @ConfineMetaClassChanges([Integer])
    def 'sometimes 2 + 2 = 5'() {
        setup: 'very special Integer + Integer operation'
        Integer.metaClass.plus = { Integer other ->
            return 5
        }

        expect: '2 + 2 == 5'
        2 + 2 == 5
    }

    def 'usually 2 + 2 == 4'() {
        expect: '2 + 2 == 4'
        2 + 2 == 4
    }

@ContextConfiguration(classes = Config)
class N22S_Stubs extends Specification {

    @Autowired
    PasswordGenerator passwordGenerator

import geb.spock.GebSpec
import spock.lang.Title

@Title('Geb example')
class N49S_Geb extends GebSpec {

    static {
        System.setProperty('webdriver.gecko.driver', 'D:\\Tools\\Selenium\\geckodriver.exe')
    }

    def 'search for wikipedia in google'() {
        when: 'go to google.com'
        go 'http://www.google.com'

        then: 'page title is Google'
        title == 'Google'

        when: 'enter wikipedia and click on search'
        $('input', name: 'q').value('wikipedia')
        $('input', name: 'btnG').click()

        then: 'title is wikipedia'
        waitFor { title.startsWith 'wikipedia - ' }

        expect: 'that search result contains link to ru.wikipedia.org'
        $('*', 0).text().contains('ru.wikipedia.org')
    }
}