void 'test name cannot be null'() {
    when:
    domain.name = null

    then:
    !domain.validate(['name'])
    domain.errors['name'].code == 'nullable'
}

void 'test name cannot be blank'() {
    when:
    domain.name = ''

    then:
    !domain.validate(['name'])
}

void 'test name can have a maximum of 255 characters'() {
    when: 'for a string of 256 characters'
    String str = 'a' * 256
    domain.name = str

    then: 'name validation fails'
    !domain.validate(['name'])
    domain.errors['name'].code == 'maxSize.exceeded'

    when: 'for a string of 256 characters'
    str = 'a' * 255
    domain.name = str

    then: 'name validation passes'
    domain.validate(['name'])
}

@Ignore
void 'test url can have a maximum of 255 characters'() {
    when: 'for a string of 256 characters'
    String urlprefifx = 'http://'
    String urlsufifx = '.com'
    String str = 'a' * (256 - (urlprefifx.size() + urlsufifx.size()))
    str = urlprefifx + str + urlsufifx
    domain.url = str

    then: 'url validation fails'
    !domain.validate(['url'])
    domain.errors['url'].code == 'maxSize.exceeded'

    when: 'for a string of 256 characters'
    str = "${urlprefifx}${'a' * (255 - (urlprefifx.size() + urlsufifx.size()))}${urlsufifx}"
    domain.url = str
    then: 'url validation passes'
    domain.validate(['url'])
}

@Unroll('Hotel.validate() with url: #value should have returned #expected with errorCode: #expectedErrorCode')
void "test url validation"() {
    when:
    domain.url = value

    then:
    expected == domain.validate(['url'])
    domain.errors['url']?.code == expectedErrorCode

    where:
    value                  | expected | expectedErrorCode
    null                   | true     | null
    ''                     | true     | null
    'http://hilton.com'    | true     | null
    'hilton'               | false    | 'url.invalid'
}

@Unroll('Hotel.validate() with email: #value should have returned #expected with errorCode: #expectedErrorCode')
void "test email validation"() {
    when:
    domain.email = value

    then:
    expected == domain.validate(['email'])
    domain.errors['email']?.code == expectedErrorCode

    where:
    value                  | expected | expectedErrorCode
    null                   |  true    | null
    ''                     |  true    | null
    '[email protected]'   |  true    | null
    'hilton'               |  false   | 'email.invalid'
}

package demo

import grails.test.hibernate.HibernateSpec

@SuppressWarnings('MethodName')
class HotelEmailUniqueConstraintSpec extends HibernateSpec {

    List<Class> getDomainClasses() { [Hotel] }

    def "hotel's email unique constraint"() {

        when: 'You instantiate a hotel with name and an email address which has been never used before'
        def hotel = new Hotel(name: 'Hotel Transilvania', email: '[email protected]')

        then: 'hotel is valid instance'
        hotel.validate()

        and: 'we can save it, and we get back a not null GORM Entity'
        hotel.save()

        and: 'there is one additional Hotel'
        Hotel.count() == old(Hotel.count()) + 1

        when: 'instanting a different hotel with the same email address'
        def hilton = new Hotel(name: 'Hilton Hotel', email: '[email protected]')

        then: 'the hotel instance is not valid'
        !hilton.validate(['email'])

        and: 'unique error code is populated'
        hilton.errors['email']?.code == 'unique'

        and: 'trying to save fails too'
        !hilton.save()

        and: 'no hotel has been added'
        Hotel.count() == old(Hotel.count())
    }
}

static mapping = {
    about type: 'text'
}

void 'test about can be null'() {
    when:
    domain.about = null

    then:
    domain.validate(['about'])
}

void 'test about can be blank'() {
    when:
    domain.about = ''

    then:
    domain.validate(['about'])
}

void 'test about can have a more than 255 characters'() {
    when: 'for a string of 256 characters'
    String str = 'a' * 256
    domain.about = str

    then: 'about validation passes'
    domain.validate(['about'])
}

latitude nullable: true, range: -90..90
longitude nullable: true, range: -180..180

latitude nullable: true, validator: { val, obj, errors ->
    if ( val == null ) {
        return true
    }
    if (val < -90.0) {
        errors.rejectValue('latitude', 'range.toosmall')
        return false
    }
    if (val > 90.0) {
        errors.rejectValue('latitude', 'range.toobig')
        return false
    }
    true
}

@Unroll('Hotel.validate() with latitude: #value should have returned #expected with errorCode: #expectedErrorCode')
void 'test latitude validation'() {
    when:
    domain.latitude = value

    then:
    expected == domain.validate(['latitude'])
    domain.errors['latitude']?.code == expectedErrorCode

    where:
    value                  | expected | expectedErrorCode
    null                   | true     | null
    0                      | true     | null
    0.5                    | true     | null
    90                     | true     | null
    90.5                   | false    | 'range.toobig'
    -90                    | true     | null
    -180                   | false    | 'range.toosmall'
    180                    | false    | 'range.toobig'
}

@Unroll('Hotel.longitude() with latitude: #value should have returned #expected with error code: #expectedErrorCode')
void 'test longitude validation'() {
    when:
    domain.longitude = value

    then:
    expected == domain.validate(['longitude'])
    domain.errors['longitude']?.code == expectedErrorCode

    where:
    value                  | expected | expectedErrorCode
    null                   | true     | null
    0                      | true     | null
    90                     | true     | null
    90.1                   | true     | null
    -90                    | true     | null
    -180                   | true     | null
    180                    | true     | null
    180.1                  | false    | 'range.toobig'
    -180.1                 | false    | 'range.toosmall'
}