741 lines
20 KiB
JavaScript
741 lines
20 KiB
JavaScript
import test from 'ava'
|
||
import Chance from '../chance.js'
|
||
import _ from 'lodash'
|
||
import phoneNumber from './helpers/phoneNumber.min.js'
|
||
|
||
const chance = new Chance()
|
||
|
||
// chance.address()
|
||
test('address() returns a string', t => {
|
||
t.true(_.isString(chance.address()))
|
||
})
|
||
|
||
test('address() starts with a number', t => {
|
||
_.times(1000, () => t.true(/[0-9]+.+/.test(chance.address())))
|
||
})
|
||
|
||
test('address() can take a short_suffix arg and obey it', t => {
|
||
_.times(1000, () => {
|
||
let address = chance.address({ short_suffix: true })
|
||
t.true(address.split(' ')[2].length < 5)
|
||
})
|
||
})
|
||
|
||
// chance.altitude()
|
||
test('altitude() looks right', t => {
|
||
t.is(typeof chance.altitude(), 'number')
|
||
})
|
||
|
||
test('altitude() is in the right range', t => {
|
||
_.times(1000, () => {
|
||
let altitude = chance.altitude()
|
||
t.true(altitude > 0)
|
||
t.true(altitude < 8848)
|
||
})
|
||
})
|
||
|
||
test('altitude() will accept a min and obey it', t => {
|
||
_.times(1000, () => {
|
||
let min = chance.floating({ min: 0, max: 8848 })
|
||
let altitude = chance.altitude({ min: min })
|
||
t.true(altitude > min)
|
||
t.true(altitude < 8848)
|
||
})
|
||
})
|
||
|
||
test('altitude() will accept a max and obey it', t => {
|
||
_.times(1000, () => {
|
||
let max = chance.floating({ min: 0, max: 8848 })
|
||
let altitude = chance.altitude({ max: max })
|
||
t.true(altitude > 0)
|
||
t.true(altitude < max)
|
||
})
|
||
})
|
||
|
||
// chance.areacode()
|
||
test('areacode() looks right', t => {
|
||
_.times(1000, () => {
|
||
let areacode = chance.areacode()
|
||
t.true(_.isString(areacode))
|
||
t.true(/^\(([2-9][0-8][0-9])\)$/.test(areacode))
|
||
})
|
||
})
|
||
|
||
test('areacode() can take parens', t => {
|
||
_.times(1000, () => {
|
||
let areacode = chance.areacode({ parens: false })
|
||
t.true(_.isString(areacode))
|
||
t.true(/^([2-9][0-8][0-9])$/.test(areacode))
|
||
})
|
||
})
|
||
|
||
// chance.city()
|
||
test('city() looks right', t => {
|
||
_.times(1000, () => {
|
||
let city = chance.city()
|
||
t.true(_.isString(city))
|
||
t.true(/[a-zA-Z]+/.test(city))
|
||
})
|
||
})
|
||
|
||
// chance.coordinates()
|
||
test('coordinates() looks right', t => {
|
||
_.times(1000, () => {
|
||
let coordinates = chance.coordinates()
|
||
t.true(_.isString(coordinates))
|
||
t.is(coordinates.split(',').length, 2)
|
||
})
|
||
})
|
||
|
||
test('coordinates() returns coordinates in DD format as default', t => {
|
||
_.times(1000, () => {
|
||
const CHARS_NOT_TO_CONTAIN = ['°', '’', '”']
|
||
|
||
let coordinates = chance.coordinates()
|
||
let [ latitude, longitude ] = coordinates.split(',')
|
||
|
||
t.true(_.isString(coordinates))
|
||
t.is(coordinates.split(',').length, 2)
|
||
t.true(CHARS_NOT_TO_CONTAIN.every(char => !latitude.includes(char)))
|
||
t.true(CHARS_NOT_TO_CONTAIN.every(char => !longitude.includes(char)))
|
||
})
|
||
})
|
||
|
||
test('coordinates() will obey DD format', t => {
|
||
_.times(1000, () => {
|
||
const CHARS_NOT_TO_CONTAIN = ['°', '’', '”']
|
||
|
||
let coordinates = chance.coordinates({format: 'dd'})
|
||
let [ latitude, longitude ] = coordinates.split(',')
|
||
|
||
t.true(_.isString(coordinates))
|
||
t.is(coordinates.split(',').length, 2)
|
||
t.true(CHARS_NOT_TO_CONTAIN.every(char => !latitude.includes(char)))
|
||
t.true(CHARS_NOT_TO_CONTAIN.every(char => !longitude.includes(char)))
|
||
})
|
||
})
|
||
|
||
test('coordinates() will obey DDM format', t => {
|
||
_.times(1000, () => {
|
||
const CHARS_TO_CONTAIN = ['°']
|
||
const CHARS_NOT_TO_CONTAIN = ['’', '”']
|
||
|
||
let coordinates = chance.coordinates({format: 'ddm'})
|
||
let [ latitude, longitude ] = coordinates.split(',')
|
||
|
||
t.true(_.isString(coordinates))
|
||
t.is(coordinates.split(',').length, 2)
|
||
t.true(CHARS_TO_CONTAIN.every(char => latitude.includes(char)))
|
||
t.true(CHARS_TO_CONTAIN.every(char => longitude.includes(char)))
|
||
t.true(CHARS_NOT_TO_CONTAIN.every(char => !latitude.includes(char)))
|
||
t.true(CHARS_NOT_TO_CONTAIN.every(char => !longitude.includes(char)))
|
||
})
|
||
})
|
||
|
||
test('coordinates() will obey DMS format', t => {
|
||
_.times(1000, () => {
|
||
const CHARS_TO_CONTAIN = ['°', '’', '”']
|
||
|
||
let coordinates = chance.coordinates({format: 'dms'})
|
||
let [ latitude, longitude ] = coordinates.split(',')
|
||
|
||
t.true(_.isString(coordinates))
|
||
t.is(coordinates.split(',').length, 2)
|
||
t.true(CHARS_TO_CONTAIN.every(char => latitude.includes(char)))
|
||
t.true(CHARS_TO_CONTAIN.every(char => longitude.includes(char)))
|
||
})
|
||
})
|
||
|
||
// chance.counties()
|
||
test('counties() returns an array of counties', t => {
|
||
t.true(_.isArray(chance.counties()))
|
||
})
|
||
|
||
test('counties() returns a (long) county name', t => {
|
||
_.times(1000, () => t.true(chance.counties({ full: true }).length > 2))
|
||
})
|
||
|
||
test('counties() can return a random (long) county name', t => {
|
||
_.times(1000, () => {
|
||
t.true(chance.counties({ full: true, country: 'uk' }).length > 2)
|
||
})
|
||
})
|
||
|
||
// chance.countries()
|
||
test('countries() returns an array of countries', t => {
|
||
t.true(_.isArray(chance.countries()))
|
||
})
|
||
|
||
// chance.country()
|
||
test('country() returns a random (short) country name', t => {
|
||
_.times(1000, () => {
|
||
t.is(chance.country().length, 2)
|
||
})
|
||
})
|
||
|
||
test('country() returns a random (long) country name', t => {
|
||
_.times(1000, () => {
|
||
t.true(chance.country({ full: true }).length > 2)
|
||
})
|
||
})
|
||
|
||
// chance.county()
|
||
test('county() returns a random county name', t => {
|
||
_.times(1000, () => {
|
||
t.true(_.isString(chance.county()))
|
||
})
|
||
})
|
||
|
||
test('country() returns a random (long) country name', t => {
|
||
_.times(1000, () => {
|
||
t.true(chance.country({ full: true }).length > 2)
|
||
})
|
||
})
|
||
|
||
// chance.depth()
|
||
test('depth() looks right', t => {
|
||
t.is(typeof chance.depth(), 'number')
|
||
})
|
||
|
||
test('depth() is in the right range', t => {
|
||
_.times(1000, () => {
|
||
let depth = chance.depth()
|
||
t.true(depth > -10994)
|
||
t.true(depth < 0)
|
||
})
|
||
})
|
||
|
||
test('depth() will accept a min and obey it', t => {
|
||
_.times(1000, () => {
|
||
let min = chance.floating({ min: -10994, max: 0 })
|
||
let depth = chance.depth({ min: min })
|
||
t.true(depth > min)
|
||
t.true(depth < 0)
|
||
})
|
||
})
|
||
|
||
test('depth() will accept a max and obey it', t => {
|
||
_.times(1000, () => {
|
||
let max = chance.floating({ min: -10994, max: 0 })
|
||
let depth = chance.depth({ max: max })
|
||
t.true(depth > -10994)
|
||
t.true(depth < max)
|
||
})
|
||
})
|
||
|
||
// chance.geohash
|
||
test('geohash() looks right', t => {
|
||
let geohash = chance.geohash()
|
||
t.true(_.isString(geohash))
|
||
t.is(geohash.length, 7)
|
||
})
|
||
|
||
test('geohash() will accept a length and obey it', t => {
|
||
_.times(1000, () => {
|
||
let length = chance.d10()
|
||
let geohash = chance.geohash({ length: length })
|
||
t.is(geohash.length, length)
|
||
})
|
||
})
|
||
|
||
// chance.latitude()
|
||
test('latitude() looks right', t => {
|
||
t.is(typeof chance.latitude(), 'number')
|
||
})
|
||
|
||
test('latitude() is in the right range', t => {
|
||
_.times(1000, () => {
|
||
let latitude = chance.latitude()
|
||
t.true(latitude >= -90)
|
||
t.true(latitude <= 90)
|
||
})
|
||
})
|
||
|
||
test('latitude() will accept a min and obey it', t => {
|
||
_.times(1000, () => {
|
||
let min = chance.floating({ min: -90, max: 90 })
|
||
let latitude = chance.latitude({ min: min })
|
||
t.true(latitude >= min)
|
||
t.true(latitude <= 90)
|
||
})
|
||
})
|
||
|
||
test('latitude() will accept a max and obey it', t => {
|
||
_.times(1000, () => {
|
||
let max = chance.floating({ min: -90, max: 90 })
|
||
let latitude = chance.latitude({ max: max })
|
||
t.true(latitude >= -90)
|
||
t.true(latitude <= max)
|
||
})
|
||
})
|
||
|
||
test('latitude() returns latitude in DD format as default', t => {
|
||
_.times(1000, () => {
|
||
const CHARS_NOT_TO_CONTAIN = ['°', '’', '”']
|
||
|
||
let latitude = chance.latitude()
|
||
|
||
t.is(typeof latitude, 'number')
|
||
t.true(CHARS_NOT_TO_CONTAIN.every(char => !latitude.toString().includes(char)))
|
||
})
|
||
})
|
||
|
||
test('latitude() will obey DD format', t => {
|
||
_.times(1000, () => {
|
||
const CHARS_NOT_TO_CONTAIN = ['°', '’', '”']
|
||
|
||
let latitude = chance.latitude({format: 'dd'})
|
||
|
||
t.is(typeof latitude, 'number')
|
||
t.true(CHARS_NOT_TO_CONTAIN.every(char => !latitude.toString().includes(char)))
|
||
})
|
||
})
|
||
|
||
test('latitude() will obey DDM format', t => {
|
||
_.times(1000, () => {
|
||
const CHARS_TO_CONTAIN = ['°']
|
||
const CHARS_NOT_TO_CONTAIN = ['’', '”']
|
||
|
||
let latitude = chance.latitude({format: 'ddm'})
|
||
|
||
t.true(_.isString(latitude))
|
||
t.true(CHARS_TO_CONTAIN.every(char => latitude.includes(char)))
|
||
t.true(CHARS_NOT_TO_CONTAIN.every(char => !latitude.includes(char)))
|
||
})
|
||
})
|
||
|
||
test('latitude() will obey DMS format', t => {
|
||
_.times(1000, () => {
|
||
const CHARS_TO_CONTAIN = ['°', '’', '”']
|
||
|
||
let latitude = chance.latitude({format: 'dms'})
|
||
|
||
t.true(_.isString(latitude))
|
||
t.true(CHARS_TO_CONTAIN.every(char => latitude.includes(char)))
|
||
})
|
||
})
|
||
|
||
// chance.longitude()
|
||
test('longitude() looks right', t => {
|
||
t.is(typeof chance.longitude(), 'number')
|
||
})
|
||
|
||
test('longitude() is in the right range', t => {
|
||
_.times(1000, () => {
|
||
let longitude = chance.longitude()
|
||
t.true(longitude >= -180)
|
||
t.true(longitude <= 180)
|
||
})
|
||
})
|
||
|
||
test('longitude() will accept a min and obey it', t => {
|
||
_.times(1000, () => {
|
||
let min = chance.floating({ min: -180, max: 180 })
|
||
let longitude = chance.longitude({ min: min })
|
||
t.true(longitude >= min)
|
||
t.true(longitude <= 180)
|
||
})
|
||
})
|
||
|
||
test('longitude() will accept a max and obey it', t => {
|
||
_.times(1000, () => {
|
||
let max = chance.floating({ min: -180, max: 180 })
|
||
let longitude = chance.longitude({ max: max })
|
||
t.true(longitude >= -180)
|
||
t.true(longitude <= max)
|
||
})
|
||
})
|
||
|
||
test('longitude() returns longitude in DD format as default', t => {
|
||
_.times(1000, () => {
|
||
const CHARS_NOT_TO_CONTAIN = ['°', '’', '”']
|
||
|
||
let longitude = chance.longitude()
|
||
|
||
t.is(typeof longitude, 'number')
|
||
t.true(CHARS_NOT_TO_CONTAIN.every(char => !longitude.toString().includes(char)))
|
||
})
|
||
})
|
||
|
||
test('longitude() will obey DD format', t => {
|
||
_.times(1000, () => {
|
||
const CHARS_NOT_TO_CONTAIN = ['°', '’', '”']
|
||
|
||
let longitude = chance.longitude({format: 'dd'})
|
||
|
||
t.is(typeof longitude, 'number')
|
||
t.true(CHARS_NOT_TO_CONTAIN.every(char => !longitude.toString().includes(char)))
|
||
})
|
||
})
|
||
|
||
test('longitude() will obey DDM format', t => {
|
||
_.times(1000, () => {
|
||
const CHARS_TO_CONTAIN = ['°']
|
||
const CHARS_NOT_TO_CONTAIN = ['’', '”']
|
||
|
||
let longitude = chance.longitude({format: 'ddm'})
|
||
|
||
t.true(_.isString(longitude))
|
||
t.true(CHARS_TO_CONTAIN.every(char => longitude.includes(char)))
|
||
t.true(CHARS_NOT_TO_CONTAIN.every(char => !longitude.includes(char)))
|
||
})
|
||
})
|
||
|
||
test('longitude() will obey DMS format', t => {
|
||
_.times(1000, () => {
|
||
const CHARS_TO_CONTAIN = ['°', '’', '”']
|
||
|
||
let longitude = chance.longitude({format: 'dms'})
|
||
|
||
t.true(_.isString(longitude))
|
||
t.true(CHARS_TO_CONTAIN.every(char => longitude.includes(char)))
|
||
})
|
||
})
|
||
|
||
// chance.phone()
|
||
test('phone() returns a string', t => {
|
||
t.true(_.isString(chance.phone()))
|
||
})
|
||
|
||
test('phone() looks like an actual phone number', t => {
|
||
t.true(/^\(([2-9][0-8][0-9])\)?[\-. ]?([2-9][0-9]{2,2})[\-. ]?([0-9]{4,4})$/.test(chance.phone()))
|
||
})
|
||
|
||
test('phone() obeys formatted option', t => {
|
||
_.times(1000, () => {
|
||
let phone = chance.phone({ formatted: false })
|
||
t.true(_.isString(phone))
|
||
t.true(/^[2-9][0-8]\d[2-9]\d{6,6}$/.test(phone))
|
||
})
|
||
})
|
||
|
||
test('phone() obeys formatted option and parens option', t => {
|
||
_.times(1000, () => {
|
||
let phone = chance.phone({ formatted: false, parens: true })
|
||
t.true(_.isString(phone))
|
||
t.true(/^[2-9][0-8]\d[2-9]\d{6,6}$/.test(phone))
|
||
})
|
||
})
|
||
|
||
test('phone() with uk option works', t => {
|
||
t.true(_.isString(chance.phone({ country: 'uk' })))
|
||
})
|
||
|
||
test('phone() with uk option works and mobile option', t => {
|
||
t.true(_.isString(chance.phone({ country: 'uk', mobile: true })))
|
||
})
|
||
|
||
test('phone() with uk country looks right', t => {
|
||
t.true(phoneNumber.isValid(chance.phone({ country: 'uk' })))
|
||
})
|
||
|
||
test('phone() with uk country unformatted looks right', t => {
|
||
t.true(phoneNumber.isValid(phoneNumber.format(chance.phone({
|
||
country: 'uk',
|
||
formatted: false
|
||
}))))
|
||
})
|
||
|
||
test('phone() with uk country and mobile option looks right', t => {
|
||
_.times(1000, () => {
|
||
t.true(phoneNumber.isValid(chance.phone({
|
||
country: 'uk',
|
||
mobile: true
|
||
})))
|
||
})
|
||
})
|
||
|
||
test('phone() with uk country and mobile option unformatted looks right', t => {
|
||
_.times(1000, () => {
|
||
t.true(phoneNumber.isValid(phoneNumber.format(chance.phone({
|
||
country: 'uk',
|
||
mobile: true,
|
||
formatted: false
|
||
}))))
|
||
})
|
||
})
|
||
|
||
test('phone() with fr country works', t => {
|
||
t.true(_.isString(chance.phone({ country: 'fr' })))
|
||
})
|
||
|
||
test('phone() with fr country works with mobile option', t => {
|
||
t.true(_.isString(chance.phone({ country: 'fr', mobile: true })))
|
||
})
|
||
|
||
test('phone() with fr country looks right', t => {
|
||
_.times(1000, () => {
|
||
t.true(/0[123459] .. .. .. ../.test(chance.phone({ country: 'fr' })))
|
||
})
|
||
})
|
||
|
||
test('phone() with fr country looks right unformatted', t => {
|
||
_.times(1000, () => {
|
||
t.true(/0........./.test(chance.phone({
|
||
country: 'fr',
|
||
formatted: false
|
||
})))
|
||
})
|
||
})
|
||
|
||
test('phone() with fr country on mobile looks right', t => {
|
||
_.times(1000, () => {
|
||
t.true(/0[67] .. .. .. ../.test(chance.phone({
|
||
country: 'fr',
|
||
mobile: true
|
||
})))
|
||
})
|
||
})
|
||
|
||
test('phone() with fr country on mobile, unformatted looks right', t => {
|
||
_.times(1000, () => {
|
||
t.true(/0[67]......../.test(chance.phone({
|
||
country: 'fr',
|
||
mobile: true,
|
||
formatted: false
|
||
})))
|
||
})
|
||
})
|
||
|
||
test('phone() with br country option works', t => {
|
||
t.true(_.isString(chance.phone({ country: 'br' })))
|
||
})
|
||
|
||
test('phone() with br country and mobile option works', t => {
|
||
t.true(_.isString(chance.phone({ country: 'br', mobile: true })))
|
||
})
|
||
|
||
test('phone() with br country and formatted false option return a correct format', t => {
|
||
t.true(/([0-9]{2})([2-5]{1})([0-9]{3})([0-9]{4})/.test(chance.phone({
|
||
country: 'br',
|
||
mobile: false,
|
||
formatted: false
|
||
})))
|
||
})
|
||
|
||
test('phone() with br country, formatted false and mobile option return a correct format', t => {
|
||
t.true(/([0-9]{2})\9([0-9]{4})([0-9]{4})/.test(chance.phone({
|
||
country: 'br',
|
||
mobile: true,
|
||
formatted: false
|
||
})))
|
||
})
|
||
|
||
test('phone() with br country and formatted option apply the correct mask', t => {
|
||
t.true(/\(([0-9]{2})\) ([2-5]{1})([0-9]{3})\-([0-9]{4})/.test(chance.phone({
|
||
country: 'br',
|
||
mobile: false,
|
||
formatted: true
|
||
})))
|
||
})
|
||
|
||
test('phone() with br country, formatted and mobile option apply the correct mask', t => {
|
||
t.true(/\(([0-9]{2})\) 9([0-9]{4})\-([0-9]{4})/.test(chance.phone({
|
||
country: 'br',
|
||
mobile: true,
|
||
formatted: true
|
||
})))
|
||
})
|
||
|
||
// chance.postal()
|
||
test('postal() returns a valid basic postal code', t => {
|
||
_.times(1000, () => {
|
||
let postal = chance.postal()
|
||
t.is(postal.length, 7)
|
||
postal.split('').map((char) => {
|
||
t.is(char.toUpperCase(), char)
|
||
})
|
||
})
|
||
})
|
||
|
||
test('postcode() returns a valid basic postcode', t => {
|
||
_.times(10, () => {
|
||
let postcode = chance.postcode();
|
||
t.regex(postcode, /^[A-Z]{1,2}\d[A-Z\d]? \d[A-Z]{2}$/);
|
||
})
|
||
})
|
||
|
||
// chance.province()
|
||
test('province() returns a random (short) province name', t => {
|
||
_.times(1000, () => t.true(chance.province().length < 3))
|
||
})
|
||
|
||
test('province() can return a long random province name', t => {
|
||
_.times(1000, () => t.true(chance.province({ full: true }).length > 2))
|
||
})
|
||
|
||
test('province() can return a random long "it" province', t => {
|
||
_.times(1000, () => {
|
||
t.true(chance.province({country: 'it', full: true }).length > 2)
|
||
})
|
||
})
|
||
|
||
// chance.provinces()
|
||
test('provinces() returns an array of provinces', t => {
|
||
t.true(_.isArray(chance.provinces()))
|
||
})
|
||
|
||
test('provinces() supports internationalization', t => {
|
||
t.not(chance.provinces(), chance.provinces({ country: 'it' }))
|
||
})
|
||
|
||
// chance.state()
|
||
test('state() returns a random (short) state name', t => {
|
||
_.times(1000, () => t.true(chance.state().length < 3))
|
||
})
|
||
|
||
test('state() can take a country and return a state', t => {
|
||
_.times(1000, () => t.true(chance.state({ country: 'it' }).length === 3))
|
||
})
|
||
|
||
test('state() can return full state name', t => {
|
||
_.times(1000, () => {
|
||
t.true(chance.state({
|
||
full: true
|
||
}).length > 2)
|
||
})
|
||
})
|
||
|
||
test('state() with country returns a long state name', t => {
|
||
_.times(1000, () => {
|
||
t.true(chance.state({
|
||
country: 'it',
|
||
full: true
|
||
}).length > 2)
|
||
})
|
||
_.times(1000, () => {
|
||
t.true(chance.state({
|
||
country: 'uk',
|
||
full: true
|
||
}).length > 2)
|
||
})
|
||
})
|
||
|
||
// chance.states()
|
||
test('states() returns an array of states', t => {
|
||
t.true(_.isArray(chance.states()))
|
||
})
|
||
|
||
test('states() returns all 50 states and DC', t => {
|
||
t.is(chance.states().length, 51)
|
||
})
|
||
|
||
test('states() with territories returns 50 US states, DC, and 7 US territories', t => {
|
||
t.is(chance.states({
|
||
territories: true
|
||
}).length, 58)
|
||
})
|
||
|
||
test('states() without us states and dc returns 7 US territories', t => {
|
||
t.is(chance.states({
|
||
territories: true,
|
||
us_states_and_dc: false
|
||
}).length, 7)
|
||
})
|
||
|
||
test('states() with armed forces returns 50 states, DC, and 3 armed forces military states', t => {
|
||
t.is(chance.states({
|
||
armed_forces: true
|
||
}).length, 54)
|
||
})
|
||
|
||
test('states() with armed forces without states returns 3 armed forces states', t => {
|
||
t.is(chance.states({
|
||
armed_forces: true,
|
||
us_states_and_dc: false
|
||
}).length, 3)
|
||
})
|
||
|
||
test('states() with all options returns 61 items', t => {
|
||
t.is(chance.states({
|
||
territories: true,
|
||
armed_forces: true
|
||
}).length, 61)
|
||
})
|
||
|
||
test('states() without states returns 7 territories and 3 armed forces states', t => {
|
||
t.is(chance.states({
|
||
territories: true,
|
||
armed_forces: true,
|
||
us_states_and_dc: false
|
||
}).length, 10)
|
||
})
|
||
|
||
test('states() with country of "it" returns 20 regions', t => {
|
||
t.is(chance.states({
|
||
country: 'it'
|
||
}).length, 20)
|
||
})
|
||
|
||
test('states() with country of "uk" returns 129 UK counties', t => {
|
||
t.is(chance.states({
|
||
country: 'uk'
|
||
}).length, 129)
|
||
})
|
||
|
||
test('states() with country of "mx" returns 32 MX states', t => {
|
||
t.is(chance.states({
|
||
country: 'mx'
|
||
}).length, 32)
|
||
})
|
||
|
||
// chance.street()
|
||
test('street() works', t => {
|
||
_.times(100, () => t.is(typeof chance.street(), 'string'))
|
||
})
|
||
|
||
test('street() works with it country', t => {
|
||
_.times(100, () => t.is(typeof chance.street({ country: 'it' }), 'string'))
|
||
})
|
||
|
||
// chance.street_suffix()
|
||
test('street_suffix() returns a single suffix', t => {
|
||
_.times(1000, () => {
|
||
let suffix = chance.street_suffix()
|
||
t.is(typeof suffix, 'object')
|
||
t.is(typeof suffix.name, 'string')
|
||
t.is(typeof suffix.abbreviation, 'string')
|
||
})
|
||
})
|
||
|
||
// chance.street_suffixes()
|
||
test('street_suffixes() returns the suffix array', t => {
|
||
let suffixes = chance.street_suffixes()
|
||
t.true(_.isArray(suffixes))
|
||
suffixes.map((suffix) => {
|
||
t.truthy(suffix.name)
|
||
t.truthy(suffix.abbreviation)
|
||
})
|
||
})
|
||
|
||
test('street_suffixes() are short', t => {
|
||
let suffixes = chance.street_suffixes()
|
||
suffixes.map((suffix) => {
|
||
t.true(suffix.abbreviation.length < 5)
|
||
})
|
||
})
|
||
|
||
test('street_suffixes() are longish', t => {
|
||
let suffixes = chance.street_suffixes()
|
||
suffixes.map((suffix) => {
|
||
t.true(suffix.name.length > 2)
|
||
})
|
||
})
|
||
|
||
// chance.zip()
|
||
test('zip() returns a valid basic zip code', t => {
|
||
_.times(1000, () => {
|
||
let zip = chance.zip()
|
||
t.is(zip.length, 5)
|
||
t.true(/(^\d{5}$)|(^\d{5}-\d{4}$)/.test(zip))
|
||
})
|
||
})
|
||
|
||
test('zip() returns a valid zip+4 code', t => {
|
||
_.times(1000, () => {
|
||
let zip = chance.zip({ plusfour: true })
|
||
t.is(zip.length, 10)
|
||
t.true(/(^\d{5}$)|(^\d{5}-\d{4}$)/.test(zip))
|
||
})
|
||
})
|