def test_nl_BE_ssn_valid(self):
from faker.providers.ssn.nl_BE import Provider
provider = Provider(None)
for i in range (1000):
ssn = provider.ssn()
self.assertEqual(len(ssn), 11)
gen_ssn_base = ssn[0:6]
gen_seq = ssn[6:9]
gen_chksum = ssn[9:11]
gen_ssn_base_as_int = int(gen_ssn_base)
gen_seq_as_int = int(gen_seq)
gen_chksum_as_int = int(gen_chksum)
# Check that the sequence nr is between 1 inclusive and 998 inclusive
self.assertGreater(gen_seq_as_int,0)
self.assertLessEqual(gen_seq_as_int, 998)
# validate checksum calculation
# Since the century is not part of ssn, try both below and above year 2000
ssn_below = int(ssn[0:9])
chksum_below = 97 - (ssn_below % 97)
ssn_above = ssn_below + 2000000000
chksum_above = 97 - (ssn_above % 97)
results = [ chksum_above, chksum_below ]
self.assertIn(gen_chksum_as_int,results)
def firefox(cls):
ver = (
'Gecko/{0} Firefox/{1}.0'.format(
DatetimeProvider.date_time_between(
datetime(2011, 1, 1)), random.randint(4, 15)),
'Gecko/{0} Firefox/3.6.{1}'.format(
DatetimeProvider.date_time_between(
datetime(2010, 1, 1)), random.randint(1, 20)),
'Gecko/{0} Firefox/3.8'.format(
DatetimeProvider.date_time_between(
datetime(2010, 1, 1)), ),
)
tmplt_win = '({0}; {1}; rv:1.9.{2}.20) {3}'
tmplt_lin = '({0}; rv:1.9.{1}.20) {2}'
tmplt_mac = '({0}; rv:1.9.{1}.20) {2}'
platforms = (
tmplt_win.format(cls.windows_platform_token(),
cls.random_element(cls.langs),
random.randint(0, 2),
random.choice(ver)),
tmplt_lin.format(cls.linux_platform_token(),
random.randint(5, 7),
random.choice(ver)),
tmplt_mac.format(cls.mac_platform_token(),
random.randint(2, 6),
random.choice(ver)),
)
return 'Mozilla/5.0 ' + cls.random_element(platforms)
def test_no_words_sentence(self):
from faker.providers.lorem import Provider
provider = Provider(None)
paragraph = provider.paragraph(0)
self.assertEqual(paragraph, '')
def test_no_words_paragraph(self):
from faker.providers.lorem import Provider
provider = Provider(None)
sentence = provider.sentence(0)
self.assertEqual(sentence, '')
def test_random_pystr_characters(self):
from faker.providers.python import Provider
provider = Provider(None)
characters = provider.pystr()
self.assertEqual(len(characters), 20)
characters = provider.pystr(max_chars=255)
self.assertEqual(len(characters), 255)
characters = provider.pystr(max_chars=0)
self.assertEqual(characters, '')
characters = provider.pystr(max_chars=-10)
self.assertEqual(characters, '')
def test_random_pyfloat(self):
from faker.providers.python import Provider
provider = Provider(None)
self.assertTrue(0 <= abs(provider.pyfloat(left_digits=1)) < 10)
self.assertTrue(0 <= abs(provider.pyfloat(left_digits=0)) < 1)
x=abs(provider.pyfloat(right_digits=0))
self.assertTrue(x-int(x) == 0)
with self.assertRaises(ValueError,
msg='A float number cannot have 0 digits '
'in total'):
provider.pyfloat(left_digits=0, right_digits=0)
def test_us_ssn_valid(self):
from faker.providers.ssn.en_US import Provider
provider = Provider(None)
for i in range(1000):
ssn = provider.ssn()
self.assertEqual(len(ssn), 11)
self.assertNotEqual(ssn[0], '9')
self.assertNotEqual(ssn[0:3], '666')
self.assertNotEqual(ssn[0:3], '000')
self.assertNotEqual(ssn[4:6], '00')
self.assertNotEqual(ssn[7:11], '0000')
def test_parse_date_time(self):
timestamp = DatetimeProvider._parse_date_time('+30d')
now = DatetimeProvider._parse_date_time('now')
assert timestamp > now
delta = timedelta(days=30)
from_delta = DatetimeProvider._parse_date_time(delta)
from_int = DatetimeProvider._parse_date_time(30)
assert datetime.fromtimestamp(from_delta).date() == (
datetime.fromtimestamp(timestamp).date())
assert datetime.fromtimestamp(from_int).date() == (
datetime.fromtimestamp(timestamp).date())
def test_parse_date_time(self):
timestamp = DatetimeProvider._parse_date_time('+30d')
now = DatetimeProvider._parse_date_time('now')
self.assertTrue(timestamp > now)
delta = timedelta(days=-30)
from_delta = DatetimeProvider._parse_date_time(delta)
from_int = DatetimeProvider._parse_date_time(30)
self.assertEqual(datetime.fromtimestamp(from_delta).date(),
datetime.fromtimestamp(timestamp).date())
self.assertEqual(datetime.fromtimestamp(from_int).date(),
datetime.fromtimestamp(timestamp).date())
def test_parse_timedelta(self):
from faker.providers.date_time import Provider
td = timedelta(days=7)
seconds = Provider._parse_timedelta(td)
self.assertEqual(seconds, 604800.0)
seconds = Provider._parse_timedelta('+1w')
self.assertEqual(seconds, 604800.0)
seconds = Provider._parse_timedelta('+1y')
self.assertEqual(seconds, 31556736.0)
with self.assertRaises(ValueError):
Provider._parse_timedelta('foobar')
def test_parse_timedelta(self):
from faker.providers.date_time import Provider
td = timedelta(days=7)
seconds = Provider._parse_timedelta(td)
assert seconds == 604800.0
seconds = Provider._parse_timedelta('+1w')
assert seconds == 604800.0
seconds = Provider._parse_timedelta('+1y')
assert seconds == 31556736.0
with pytest.raises(ValueError):
Provider._parse_timedelta('foobar')
def test_password(self):
from faker.providers.misc import Provider
def in_string(char, _str):
return char in _str
for _ in range(999):
password = Provider.password()
self.assertTrue(any([in_string(char, password) for char in "!@#$%^&*()_+"]))
self.assertTrue(any([in_string(char, password) for char in string.digits]))
self.assertTrue(any([in_string(char, password) for char in string.ascii_uppercase]))
self.assertTrue(any([in_string(char, password) for char in string.ascii_lowercase]))
with self.assertRaises(AssertionError):
Provider.password(length=2)
def test_language_code(self):
from faker.providers.misc import Provider
for _ in range(99):
language_code = Provider.language_code()
self.assertTrue(isinstance(language_code, string_types))
self.assertTrue(re.match(r'^[a-z]{2,3}$', language_code))
def ssn(cls):
"""
Returns 11 character Polish national identity code (Public Electronic Census System,
Polish: Powszechny Elektroniczny System Ewidencji Ludności - PESEL).
It has the form YYMMDDZZZXQ, where YYMMDD is the date of birth (with century
encoded in month field), ZZZ is the personal identification number, X denotes sex
(even for females, odd for males) and Q is a parity number.
https://en.wikipedia.org/wiki/National_identification_number#Poland
"""
birth_date = DateTimeProvider.date_time()
year_without_century = int(birth_date.strftime('%y'))
month = calculate_month(birth_date)
day = int(birth_date.strftime('%d'))
pesel_digits = [
int(year_without_century / 10),
year_without_century % 10,
int(month / 10),
month % 10,
int(day / 10), day % 10
]
for _ in range(4):
pesel_digits.append(cls.random_digit())
pesel_digits.append(checksum(pesel_digits))
return ''.join(str(digit) for digit in pesel_digits)
def test_date_time_between_dates(self):
from faker.providers.date_time import Provider
import random as r
random = r.Random()
provider = Provider(None)
timestamp_start = random.randint(0, 10000000000)
timestamp_end = timestamp_start + 1
datetime_start = datetime.datetime.fromtimestamp(timestamp_start)
datetime_end = datetime.datetime.fromtimestamp(timestamp_end)
random_date = provider.date_time_between_dates(datetime_start, datetime_end)
self.assertTrue(datetime_start <= random_date)
self.assertTrue(datetime_end >= random_date)
def test_language_code(self):
from faker.providers.misc import Provider
for _ in range(99):
language_code = Provider.language_code()
self.assertTrue(isinstance(language_code, string_types))
Factory.create(locale=language_code)
def test_binary(self):
from faker.providers.misc import Provider
for _ in range(999):
length = random.randint(0, 2 ** 10)
binary = Provider.binary(length)
self.assertTrue(isinstance(binary, six.binary_type))
self.assertTrue(len(binary) == length)
def test_ipv4(self):
from faker.providers.internet import Provider
provider = Provider(None)
for _ in range(999):
address = provider.ipv4()
self.assertTrue(len(address) >= 7)
self.assertTrue(len(address) <= 15)
self.assertTrue(
re.compile(r'^(\d{1,3}\.){3}\d{1,3}$').search(address))
for _ in range(999):
address = provider.ipv4(network=True)
self.assertTrue(len(address) >= 9)
self.assertTrue(len(address) <= 18)
self.assertTrue(
re.compile(r'^(\d{1,3}\.){3}\d{1,3}/\d{1,2}$').search(address))
def test_ipv6(self):
from faker.providers.internet import Provider
provider = Provider(None)
for _ in range(999):
address = provider.ipv6()
self.assertTrue(len(address) >= 3) # ::1
self.assertTrue(len(address) <= 39)
self.assertTrue(
re.compile(r'^([0-9a-f]{0,4}:){2,7}[0-9a-f]{1,4}$').search(address))
for _ in range(999):
address = provider.ipv6(network=True)
self.assertTrue(len(address) >= 4) # ::/8
self.assertTrue(len(address) <= 39 + 4)
self.assertTrue(
re.compile(r'^([0-9a-f]{0,4}:){2,7}[0-9a-f]{0,4}/\d{1,3}$').search(
address))
def test_parse_date(self):
parsed = DatetimeProvider._parse_date('+30d')
now = DatetimeProvider._parse_date('now')
today = DatetimeProvider._parse_date('today')
assert isinstance(parsed, date)
assert isinstance(now, date)
assert isinstance(today, date)
assert today == date.today()
assert now == today
assert parsed == today + timedelta(days=30)
assert DatetimeProvider._parse_date(datetime.now()) == today
assert DatetimeProvider._parse_date(parsed) == parsed
assert DatetimeProvider._parse_date(30) == parsed
assert DatetimeProvider._parse_date(timedelta(days=30)) == parsed
def test_parse_date(self):
parsed = DatetimeProvider._parse_date('+30d')
now = DatetimeProvider._parse_date('now')
today = DatetimeProvider._parse_date('today')
self.assertIsInstance(parsed, date)
self.assertIsInstance(now, date)
self.assertIsInstance(today, date)
self.assertEqual(today, date.today())
self.assertEqual(now, today)
self.assertEqual(parsed, today + timedelta(days=30))
self.assertEqual(DatetimeProvider._parse_date(datetime.now()), today)
self.assertEqual(DatetimeProvider._parse_date(parsed), parsed)
self.assertEqual(DatetimeProvider._parse_date(30), parsed)
self.assertEqual(DatetimeProvider._parse_date(timedelta(days=-30)), parsed)
def ssn(cls):
"""
Ukrainian "Реєстраційний номер облікової картки платника податків"
also known as "Ідентифікаційний номер фізичної особи".
"""
digits = []
# Number of days between 1899-12-31 and a birth date
for digit in str((DateTimeProvider.date_object() -
date(1899, 12, 31)).days):
digits.append(int(digit))
# Person's sequence number
for _ in range(4):
digits.append(cls.random_int(0, 9))
checksum = (digits[0]*-1 + digits[1]*5 + digits[2]*7 + digits[3]*9 +
digits[4]*4 + digits[5]*6 + digits[6]*10 + digits[7]*5 +
digits[8]*7)
# Remainder of a checksum divided by 11 or 1 if it equals to 10
digits.append(checksum % 11 % 10)
return ''.join(str(digit) for digit in digits)
def test_locale(self):
from faker.providers.misc import Provider
for _ in range(99):
locale = Provider.locale()
self.assertTrue(re.match(r'^[a-z]{2,3}_[A-Z]{2}$', locale))
def credit_card_expire(cls, start='now', end='+10y', date_format='%m/%y'):
expire_date = DateTimeProvider.date_time_between(start, end)
return expire_date.strftime(date_format)
def test_parse_date_time(self):
timestamp = DatetimeProvider._parse_date_time('+30d')
now = DatetimeProvider._parse_date_time('now')
self.assertTrue(timestamp > now)
def test_date_time_this_period(self):
from faker.providers.date_time import Provider
provider = Provider(None)
# test century
self.assertTrue(
self._datetime_to_time(provider.date_time_this_century(after_now=False)) <= self._datetime_to_time(
datetime.datetime.now()))
self.assertTrue(self._datetime_to_time(
provider.date_time_this_century(before_now=False, after_now=True)) >= self._datetime_to_time(
datetime.datetime.now()))
# test decade
self.assertTrue(
self._datetime_to_time(provider.date_time_this_decade(after_now=False)) <= self._datetime_to_time(
datetime.datetime.now()))
self.assertTrue(self._datetime_to_time(
provider.date_time_this_decade(before_now=False, after_now=True)) >= self._datetime_to_time(
datetime.datetime.now()))
self.assertAlmostEqual(
self._datetime_to_time(provider.date_time_this_decade(before_now=False, after_now=False)),
self._datetime_to_time(datetime.datetime.now()))
# test year
self.assertTrue(self._datetime_to_time(provider.date_time_this_year(after_now=False)) <= self._datetime_to_time(
datetime.datetime.now()))
self.assertTrue(self._datetime_to_time(
provider.date_time_this_year(before_now=False, after_now=True)) >= self._datetime_to_time(
datetime.datetime.now()))
self.assertAlmostEqual(self._datetime_to_time(provider.date_time_this_year(before_now=False, after_now=False)),
self._datetime_to_time(datetime.datetime.now()))
# test month
self.assertTrue(
self._datetime_to_time(provider.date_time_this_month(after_now=False)) <= self._datetime_to_time(
datetime.datetime.now()))
self.assertTrue(self._datetime_to_time(
provider.date_time_this_month(before_now=False, after_now=True)) >= self._datetime_to_time(
datetime.datetime.now()))
self.assertAlmostEqual(self._datetime_to_time(provider.date_time_this_month(before_now=False, after_now=False)),
self._datetime_to_time(datetime.datetime.now()))
def __init__(self, generator):
super().__init__(self.age_distribution, generator)
self.date_provider = Provider(generator)
def credit_card_expire(cls, start='now', end='+10y', date_format='%m/%y'):
expire_date = DateTimeProvider.date_time_between(start, end)
return expire_date.strftime(date_format)
def test_parse_date_time(self):
timestamp = DatetimeProvider._parse_date_time('+30d')
now = DatetimeProvider._parse_date_time('now')
self.assertTrue(timestamp > now)
def generate_pandas(conf_file):
_validate_configuration(conf_file)
with open(conf_file, 'r') as stream:
try:
conf = yaml.safe_load(stream)
except yaml.YAMLError as exc:
raise ConfigurationException(exc.message, conf_file)
length = _get_param(conf, 'length', 0)
columns = _get_param(conf, 'columns')
data = OrderedDict()
for column in columns:
_label = _get_param(column, 'name')
_type = _get_param(column, 'type')
if not _label or (not _type and not _get_dist_param(column)):
continue
if _type == 'day':
data[_label] = _generate_range(column, 1, 31, np.uint8, length,
conf_file)
elif _type == 'month':
data[_label] = _generate_range(column, 1, 12, np.uint8, length,
conf_file)
elif _type == 'weekday':
data[_label] = [date_provider.day_of_week() for i in range(length)]
elif _type == 'year':
data[_label] = _generate_range(column, datetime.min.year,
datetime.now().year, np.uint16,
length, conf_file)
elif _type == 'date':
_params = _get_param(column, 'params')
_to = parser.parse(_params['to']) if _params and _params.get(
'to') is not None else datetime.now()
_from = parser.parse(_params['from']) if _params and _params.get(
'from') is not None else _to
_pattern = _get_param(_params, 'pattern', '%Y-%m-%d')
data[_label] = [
date_provider.date_time_between_dates(_from,
_to).strftime(_pattern)
for i in range(length)
]
elif _type == 'time':
_params = column['params']
_pattern = _get_param(_params, 'pattern', '%H:%M:%S')
data[_label] = [
date_provider.time(pattern=_pattern) for i in range(length)
]
elif _type == 'currency':
_params = _get_param(column, 'params')
if _params:
_list = _get_param(_params, 'list')
if not _list:
_count = _get_param(_params, 'count')
if _count:
_list = [
currency_provider.currency_code()
for i in range(_count)
]
_items = [
_list[i] for i in np.random.randint(
low=0, high=len(_list), size=length)
]
else:
_items = [
currency_provider.currency_code() for i in range(length)
]
data[_label] = _items
elif _type == 'name':
data[_label] = _generate_text(column, length, 'name')
elif _type == 'country':
_params = _get_param(column, '_params')
if _params and _get_param(_params, 'code') is not None:
if _get_param(_params, 'code') == True:
data[_label] = _generate_text(column, length,
'country_code')
else:
data[_label] = _generate_text(column, length, 'country')
else:
data[_label] = _generate_text(column, length, 'country')
elif _type == 'city':
data[_label] = _generate_text(column, length, 'city')
elif _type == 'company':
data[_label] = _generate_text(column, length, 'company')
elif _type == 'boolean':
_items = [getrandbits(1) for i in range(length)]
_params = _get_param(column, 'params')
_as_int = _get_param(_params, 'as_int')
if _as_int is not None and _as_int:
pass
else:
_items = [bool(item) for item in _items]
data[_label] = _items
else:
if _type is not None:
try:
_type = np.dtype(_type)
except TypeError as ex:
_type = np.float16
else:
_type = np.float16
series = _generate_distribution(column, length, _type)
if series is not None:
data[_label] = series
return pd.DataFrame(data)
def test_locale(self):
from faker.providers.misc import Provider
for _ in range(99):
locale = Provider.locale()
self.assertTrue(re.match(r'^[a-z]{2,3}_[A-Z]{2}$', locale))
