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 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)