Spock-Genesis

repositories {
    jcenter()
}

dependencies {
    testCompile 'com.nagternal:spock-genesis:0.6.0'
}

def 'create a string by length'() {
    when: 'establishing max string length'
        def shortWord = string(5).iterator().next() (1)

    then: 'word size should be less equal than max'
        shortWord.size() <= 5

    when: 'establishing min and max word size'
        def largerWord = string(5,10).iterator().next() (2)

    then: 'word should be larger equal min'
        largerWord.size() >= 5

    and: 'word should be less equal max'
        largerWord.size() <= 10
}

def 'generate a string using a regular expression'() {
    expect:
        generatedString ==~ '(https?|ftp|file)://[-A-Z0-9+&@#/%?=~_|!:,.;]*[-A-Z0-9+&@#/%=~_|]\\d'
    where:
        generatedString << string(~'(https?|ftp|file)://[-A-Z0-9+&@#/%?=~_|!:,.;]*[-A-Z0-9+&@#/%=~_|]\\d').take(10)
}

def 'generate numbers'() {
    expect:
        getDouble().iterator().next() instanceof Double
        integer.iterator().next() instanceof Integer
        getLong().iterator().next() instanceof Long
        bytes.iterator().next() instanceof byte[]
}

def 'create an integer with min and max'() {
    when: 'establishing max possible number'
        def firstNumber = integer(5..10).iterator().next() (1)

    then: 'generated number will be less equals than max'
        firstNumber >= 5
        firstNumber <= 10

    when: 'establishing min and max valid numbers'
        def secondNumber = integer(5,10).iterator().next() (2)

    then: 'generated number must be between both numbers'
        secondNumber >= 5
        secondNumber <= 10
}

def 'create a new date value range'() {
    given: "yesterday's reference and tomorrow's"
    def yesterday = new Date() - 1
    def tomorrow  = new Date() + 1

    when: 'getting a new date'
    def newDate = date(yesterday, tomorrow).iterator().next()

    then: 'new date should be between boundaries'
    tomorrow.after(newDate)
    newDate.after(yesterday)
}

def 'create a value using the value() method'() {
    expect: 'to get several copies of a value'
    value(0).take(2).collect() == [0,0]

    and: 'to get just one'
    value(0).iterator().next() == 0
}

enum Days {
    SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY
}

def 'generate from an enum'() {
    setup:
        def gen = these Days
    expect:
        gen.collect() == Days.collect()
}

def 'generate a tuple'() {
    when: 'generating a tuple of numbers'
        def tuple = tuple(integer, integer, string).iterator().next()

    then: 'make sure we get a list of the expected size'
        tuple.size() == 3

    and: 'the type of the members are the expected'
        tuple.first() instanceof Integer
        tuple.get(1) instanceof Integer
        tuple.last() instanceof String
}

def 'generate a simple list'() {
    when: 'generating a simple list'
        def list = list(integer).iterator().next() (1)

    then: 'we only can be sure about the type of the list'
        list instanceof List

    and: 'the type of elements due to the value generator used'
        list.every { it instanceof Integer }
}

def 'generate a list with size boundaries'() {
    when: 'establishing the list definition'
        def list = list(integer, 1, 5).iterator().next() (1)

    then: 'it should obey the following assertions'
        list instanceof List                  (2)
        list.size() >= 1                      (3)
        list.size() <= 5                      (4)
        list.every { it instanceof Integer }  (5)

}

def 'generate a map'() {
    when: 'defining a map with different fields'
        def myMap = map(                            (1)
            id: getLong(),                          (2)
            name: string,                           (3)
            age: integer(0, 120)).iterator().next() (4)

    then: 'we should get instances of map'
        myMap instanceof Map

    and: 'the fields should follow the generators rules'
        myMap.id instanceof Long
        myMap.name instanceof String
        myMap.age instanceof Integer
}

static class Data {
    String s
    Integer i
    Date d
}

def 'generate type with map'() {
    setup:
        def gen = type(Data, s: string, i: integer, d: date) (1)
    when:
        Data result = gen.iterator().next() (2)
    then:
        result.d
        result.i
        result.s
}

static class TupleData {
    String s
    Integer i
    Date d

    TupleData(String s, Integer i, Date d) {
        this.s = s
        this.i = i
        this.d = d
    }
}

def 'generate type with tuple'() {
    expect:
        result instanceof TupleData
        result.d
        result.i == 42
        result.s

    where:
        result << type(TupleData, string, value(42), date).take(5)
}

def 'permute is possible with map generator'() {
    setup:
        def generator = Gen.type(MapConstructorObj, string: ['a', 'b'], integer: [1,2,3]) (1)
    when:
        List<MapConstructorObj> results = generator.permute().collect() (2)
    then: (3)
        results == [
                new MapConstructorObj(string: 'a', integer: 1),
                new MapConstructorObj(string: 'b', integer: 1),
                new MapConstructorObj(string: 'a', integer: 2),
                new MapConstructorObj(string: 'b', integer: 2),
                new MapConstructorObj(string: 'a', integer: 3),
                new MapConstructorObj(string: 'b', integer: 3),
        ]
    when: 'only to depth of 2'
        List<MapConstructorObj> results2 = generator.permute(2).collect() (4)
    then: (5)
        results2 == [
                new MapConstructorObj(string: 'a', integer: 1),
                new MapConstructorObj(string: 'b', integer: 1),
                new MapConstructorObj(string: 'a', integer: 2),
                new MapConstructorObj(string: 'b', integer: 2),
        ]
}

def 'generate from a specific set of values'() {
    expect: 'to get numbers from a varargs'
        these(1,2,3).take(3).collect() == [1,2,3]

    and: 'to get values from an iterable object such as a list'
        these([1,2,3]).take(2).collect() == [1,2]

    and: 'to get values from a given class'
        these(String).iterator().next() == String

    and: 'to stop producing numbers if the source is exhausted'
        these(1..3).take(10).collect() == [1,2,3]
}

def 'generate from multiple iterators in sequence'() {
    setup:
        def gen = these(1, 2, 3).then([4, 5])
    expect:
        gen.collect() == [1, 2, 3, 4, 5]
}

def 'create multi source generator with & operator'() {
    setup:
        def gen = string(100) & integer & date
    expect:
        gen instanceof MultiSourceGenerator
        gen.any { it instanceof Integer }
        gen.any { it instanceof String }
        gen.any { it instanceof Date }
}

def 'generate any value from a given source'() {
    given: 'a source'
        def source = [1,2,null,3]

    expect: 'only that the generated value is any of the elements'
        Gen.any(source).take(2).every { n -> n in source }
}

@Iterations(5)
class IterationsSpec extends Specification {

    static List NUMBERS = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

    static List<Integer> VALUES = []

    def 'method iterations is limited by class annotation'() {
        expect:
            value < 6
        where:
            value << NUMBERS
    }

@Iterations(2)
def 'limiting iterations to 2 makes it so the first 2 iterations are all that run'() {
    expect:
    s instanceof String
    i instanceof Integer
    i < 3
    where:
    s << string(~/[A-Z][a-z]+( [A-Z][a-z]+)?/)
    i << these(1,2,3,4,5,6)
}

def 'generate a value once'() {
    setup:
        def gen = once value
    expect:
        gen.collect() == [value]
    where:
        value << [null, 1, 'b', [1,2]]
}

def 'multiply by int limits the quantity generated'() {
    setup:
        def gen = string * 3
    when:
        def results = gen.collect()
    then:
        results.size() == 3
}

def 'generate a value repeatedly'() {
    setup:
        def gen = value(null).take(100)
    when:
        def result = gen.collect()
    then:
        result.size() == 100
        result.every { it == null }
}

def 'setting seed returns the same values with 2 generators configured the same'() {
    given:
        def generatedA = string(10).seed(879).take(10).realized
        def generatedB = string(10).seed(879).take(10).realized
    expect:
        generatedA == generatedB
}

def 'setting seed to different values produces different sequences'() {
    given:
        def generatedA = integer.seed(879).take(4).realized
        def generatedB = integer.seed(3).take(4).realized
    expect:
        generatedA == [-1295148427, 2105117961, -922763979, 1733784787]
        generatedB == [-1155099828, -1879439976, 304908421, -836442134]
}

def 'call methods on generated value using with'() {
    setup:
        def gen = date.with { setTime(1400) }

    expect:
        gen.iterator().next().getTime() == 1400
}

@Iterations(10)
def 'transform the output of a generator'() {
    expect:
        result instanceof String
        result.isInteger()
    where:
        result << integer.map { val -> val.toString() }
}