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 test_no_words_sentence(self): from faker.providers.lorem import Provider provider = Provider(None) paragraph = provider.paragraph(0) self.assertEqual(paragraph, '')
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 test_locale(self): from faker.providers.misc import Provider provider = Provider(self.generator) for _ in range(99): locale = provider.locale() assert re.match(r'^[a-z]{2,3}_[A-Z]{2}$', locale)
def test_password(self): from faker.providers.misc import Provider provider = Provider(self.generator) 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_ipv4_network_class(self): from faker.providers.internet import Provider provider = Provider(self.generator) for _ in range(99): klass = provider.ipv4_network_class() assert klass in 'abc'
def test_locale(self): from faker.providers.misc import Provider provider = Provider(self.generator) for _ in range(99): locale = provider.locale() self.assertTrue(re.match(r'^[a-z]{2,3}_[A-Z]{2}$', locale))
def test_no_words_sentence(self): from faker.providers.lorem import Provider provider = Provider(self.generator) paragraph = provider.paragraph(0) assert paragraph == ''
def test_no_words_paragraph(self): from faker.providers.lorem import Provider provider = Provider(self.generator) sentence = provider.sentence(0) assert sentence == ''
def test_no_words_paragraph(self): from faker.providers.lorem import Provider provider = Provider(self.generator) sentence = provider.sentence(0) self.assertEqual(sentence, '')
def test_ipv4_public(self): from faker.providers.internet import Provider provider = Provider(self.generator) for _ in range(99): address = provider.ipv4_public() address = six.text_type(address) assert len(address) >= 7 assert len(address) <= 15 assert not ip_address(address).is_private, address assert ( re.compile(r'^(\d{1,3}\.){3}\d{1,3}$').search(address)) for _ in range(99): address = provider.ipv4_public(network=True) address = six.text_type(address) assert len(address) >= 9 assert len(address) <= 18 # Hack around ipaddress module # As 192.0.0.0 is net addr of many 192.0.0.0/* nets # ipaddress considers them as private if ip_network(address).network_address != ip_address('192.0.0.0'): assert not ip_network(address)[0].is_private, address assert ( re.compile(r'^(\d{1,3}\.){3}\d{1,3}/\d{1,2}$').search(address))
def test_ipv4_public(self): from faker.providers.internet import Provider provider = Provider(self.generator) for _ in range(999): address = provider.ipv4_public() address = text.force_text(address) self.assertTrue(len(address) >= 7) self.assertTrue(len(address) <= 15) self.assertFalse(ip_address(address).is_private, address) self.assertTrue( re.compile(r'^(\d{1,3}\.){3}\d{1,3}$').search(address)) for _ in range(999): address = provider.ipv4_public(network=True) address = text.force_text(address) self.assertTrue(len(address) >= 9) self.assertTrue(len(address) <= 18) # Hack around ipaddress module # As 192.0.0.0 is net addr of many 192.0.0.0/* nets # ipaddress considers them as private if ip_network(address).network_address != ip_address('192.0.0.0'): self.assertFalse(ip_network(address)[0].is_private, address) self.assertTrue( re.compile(r'^(\d{1,3}\.){3}\d{1,3}/\d{1,2}$').search(address))
def test_no_words_paragraph(self): from faker.providers.lorem import Provider provider = Provider(None) sentence = provider.sentence(0) self.assertEqual(sentence, '')
def test_ipv4(self): from faker.providers.internet import Provider provider = Provider(self.generator) for _ in range(99): address = provider.ipv4() assert len(address) >= 7 assert len(address) <= 15 assert ( re.compile(r'^(\d{1,3}\.){3}\d{1,3}$').search(address)) for _ in range(99): address = provider.ipv4(network=True) assert len(address) >= 9 assert len(address) <= 18 assert ( re.compile(r'^(\d{1,3}\.){3}\d{1,3}/\d{1,2}$').search(address)) address = provider.ipv4(private=True) assert len(address) >= 7 assert len(address) <= 15 assert ( re.compile(r'^(\d{1,3}\.){3}\d{1,3}$').search(address)) address = provider.ipv4(private=False) assert len(address) >= 7 assert len(address) <= 15 assert ( re.compile(r'^(\d{1,3}\.){3}\d{1,3}$').search(address))
def test_language_code(self): from faker.providers.misc import Provider provider = Provider(self.generator) 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 test_language_code(self): from faker.providers.misc import Provider provider = Provider(self.generator) for _ in range(99): language_code = provider.language_code() assert isinstance(language_code, six.string_types) assert re.match(r'^[a-z]{2,3}$', language_code)
def test_ipv4_public_class_c(self): from faker.providers.internet import Provider provider = Provider(self.generator) for _ in range(99): address = provider.ipv4_public(address_class='c') address = six.text_type(address) assert len(address) >= 7 assert len(address) <= 15 assert not ip_address(address).is_private, address
def test_random_pyfloat(self): from faker.providers.python import Provider provider = Provider(self.generator) assert 0 <= abs(provider.pyfloat(left_digits=1)) < 10 assert 0 <= abs(provider.pyfloat(left_digits=0)) < 1 x = abs(provider.pyfloat(right_digits=0)) assert x - int(x) == 0 with pytest.raises(ValueError): provider.pyfloat(left_digits=0, right_digits=0)
def test_ipv4_public_class_c(self): from faker.providers.internet import Provider provider = Provider(self.generator) for _ in range(999): address = provider.ipv4_public(address_class='c') address = text.force_text(address) self.assertTrue(len(address) >= 7) self.assertTrue(len(address) <= 15) self.assertFalse(ip_address(address).is_private, address)
def test_random_pyfloat(self): from faker.providers.python import Provider provider = Provider(self.generator) 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_ipv4_private_class_c(self): from faker.providers.internet import Provider provider = Provider(self.generator) for _ in range(999): address = provider.ipv4_private(address_class='c') address = text.force_text(address) self.assertTrue(len(address) >= 7) self.assertTrue(len(address) <= 15) self.assertTrue(ip_address(address).is_private) self.assertTrue( re.compile(r'^192\.168\.\d{1,3}\.\d{1,3}$').search(address))
def test_us_ssn_valid(self): from faker.providers.ssn.en_US import Provider provider = Provider(self.generator) 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_us_ssn_valid(self): from faker.providers.ssn.en_US import Provider provider = Provider(self.generator) for i in range(1000): ssn = provider.ssn() assert len(ssn) == 11 assert ssn[0] != '9' assert ssn[0:3] != '666' assert ssn[0:3] != '000' assert ssn[4:6] != '00' assert ssn[7:11] != '0000'
def test_ipv4_private_class_c(self): from faker.providers.internet import Provider, _IPv4Constants provider = Provider(self.generator) class_network = _IPv4Constants._network_classes['c'] class_min = class_network.network_address class_max = class_network.broadcast_address for _ in range(99): address = provider.ipv4_private(address_class='c') address = six.text_type(address) assert len(address) >= 7 assert len(address) <= 15 assert ip_address(address).is_private assert ip_address(address) >= class_min assert ip_address(address) <= class_max
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(), MiscProvider.locale().replace('_', '-'), 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_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 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(), MiscProvider.locale().replace('_', '-'), 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 safari(cls): saf = "{0}.{1}.{2}".format(random.randint(531, 535), random.randint(1, 50), random.randint(1, 7)) if not random.getrandbits(1): ver = "{0}.{1}".format(random.randint(4, 5), random.randint(0, 1)) else: ver = "{0}.0.{1}".format(random.randint(4, 5), random.randint(1, 5)) tmplt_win = '(Windows; U; {0}) AppleWebKit/{1} (KHTML, like Gecko)' \ ' Version/{2} Safari/{3}' tmplt_mac = '({0} rv:{1}.0; {2}) AppleWebKit/{3} (KHTML, like Gecko)' \ ' Version/{4} Safari/{5}' tmplt_ipod = '(iPod; U; CPU iPhone OS {0}_{1} like Mac OS X; {2})' \ ' AppleWebKit/{3} (KHTML, like Gecko) Version/{4}.0.5' \ ' Mobile/8B{5} Safari/6{6}' locale = MiscProvider.locale().replace('_', '-') platforms = ( tmplt_win.format(cls.windows_platform_token(), saf, ver, saf), tmplt_mac.format(cls.mac_platform_token(), random.randint(2, 6), locale, saf, ver, saf), tmplt_ipod.format(random.randint(3, 4), random.randint(0, 3), locale, saf, random.randint(3, 4), random.randint(111, 119), saf), ) return 'Mozilla/5.0 ' + cls.random_element(platforms)
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, (bytes, bytearray))) self.assertTrue(len(binary) == length) for _ in range(999): self.generator.seed(_) binary1 = Provider.binary(_) self.generator.seed(_) binary2 = Provider.binary(_) self.assertTrue(binary1 == binary2)
def test_password(self): from faker.providers.misc import Provider provider = Provider(self.generator) def in_string(char, _str): return char in _str for _ in range(999): password = provider.password() assert any(in_string(char, password) for char in "!@#$%^&*()_+") assert any(in_string(char, password) for char in string.digits) assert any(in_string(char, password) for char in string.ascii_uppercase) assert any(in_string(char, password) for char in string.ascii_lowercase) with pytest.raises(AssertionError): provider.password(length=2)
def test_binary(self): from faker.providers.misc import Provider provider = Provider(self.generator) for _ in range(999): length = random.randint(0, 2**10) binary = provider.binary(length) assert isinstance(binary, (bytes, bytearray)) assert len(binary) == length for _ in range(999): self.generator.seed(_) binary1 = provider.binary(_) self.generator.seed(_) binary2 = provider.binary(_) assert binary1 == binary2
def test_binary(self): from faker.providers.misc import Provider provider = Provider(self.generator) for _ in range(999): length = random.randint(0, 2 ** 10) binary = provider.binary(length) assert isinstance(binary, (bytes, bytearray)) assert len(binary) == length for _ in range(999): self.generator.seed(_) binary1 = provider.binary(_) self.generator.seed(_) binary2 = provider.binary(_) assert binary1 == binary2
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(self.generator) 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_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(self.generator) for _ in range(99): address = provider.ipv6() assert len(address) >= 3 # ::1 assert len(address) <= 39 assert (re.compile(r'^([0-9a-f]{0,4}:){2,7}[0-9a-f]{1,4}$').search( address)) for _ in range(99): address = provider.ipv6(network=True) assert len(address) >= 4 # ::/8 assert len(address) <= 39 + 4 assert (re.compile(r'^([0-9a-f]{0,4}:){2,7}[0-9a-f]{0,4}/\d{1,3}$' ).search(address))
def test_ipv6(self): from faker.providers.internet import Provider provider = Provider(self.generator) 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_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_ipv4_private(self): from faker.providers.internet import Provider provider = Provider(self.generator) for _ in range(99): address = provider.ipv4_private() address = six.text_type(address) assert len(address) >= 7 assert len(address) <= 15 assert ip_address(address).is_private assert (re.compile(r'^(\d{1,3}\.){3}\d{1,3}$').search(address)) for _ in range(99): address = provider.ipv4_private(network=True) address = six.text_type(address) assert len(address) >= 9 assert len(address) <= 18 assert ip_network(address)[0].is_private assert ( re.compile(r'^(\d{1,3}\.){3}\d{1,3}/\d{1,2}$').search(address))
def test_ipv4_private(self): from faker.providers.internet import Provider provider = Provider(self.generator) for _ in range(99): address = provider.ipv4_private() address = six.text_type(address) assert len(address) >= 7 assert len(address) <= 15 assert ip_address(address).is_private assert ( re.compile(r'^(\d{1,3}\.){3}\d{1,3}$').search(address)) for _ in range(99): address = provider.ipv4_private(network=True) address = six.text_type(address) assert len(address) >= 9 assert len(address) <= 18 assert ip_network(address)[0].is_private assert ( re.compile(r'^(\d{1,3}\.){3}\d{1,3}/\d{1,2}$').search(address))
def test_ipv4_private(self): from faker.providers.internet import Provider provider = Provider(self.generator) for _ in range(999): address = provider.ipv4_private() address = text.force_text(address) self.assertTrue(len(address) >= 7) self.assertTrue(len(address) <= 15) self.assertTrue(ip_address(address).is_private) self.assertTrue( re.compile(r'^(\d{1,3}\.){3}\d{1,3}$').search(address)) for _ in range(999): address = provider.ipv4_private(network=True) address = text.force_text(address) self.assertTrue(len(address) >= 9) self.assertTrue(len(address) <= 18) self.assertTrue(ip_network(address)[0].is_private) self.assertTrue( re.compile(r'^(\d{1,3}\.){3}\d{1,3}/\d{1,2}$').search(address))
def test_ipv4(self): from faker.providers.internet import Provider provider = Provider(self.generator) for _ in range(99): address = provider.ipv4() assert len(address) >= 7 assert len(address) <= 15 assert (re.compile(r'^(\d{1,3}\.){3}\d{1,3}$').search(address)) for _ in range(99): address = provider.ipv4(network=True) assert len(address) >= 9 assert len(address) <= 18 assert ( re.compile(r'^(\d{1,3}\.){3}\d{1,3}/\d{1,2}$').search(address)) address = provider.ipv4(private=True) assert len(address) >= 7 assert len(address) <= 15 assert (re.compile(r'^(\d{1,3}\.){3}\d{1,3}$').search(address)) address = provider.ipv4(private=False) assert len(address) >= 7 assert len(address) <= 15 assert (re.compile(r'^(\d{1,3}\.){3}\d{1,3}$').search(address))
def test_ipv4_distribution_selection(self): from faker.providers.internet import Provider from faker.utils.distribution import choices_distribution provider = Provider(self.generator) subnets = [ip_network('10.0.0.0/8'), ip_network('11.0.0.0/8')] valid_weights = [1, 1] list_of_invalid_weights = [ [1, 2, 3], # List size does not match subnet list size ['a', 'b'], # List size matches, but elements are invalid None, # Not a list or valid iterable ] with patch('faker.providers.internet.choices_distribution', wraps=choices_distribution) as mock_choices_fn: with patch('faker.generator.random.choice', wraps=random.choice) as mock_random_choice: # If weights argument is valid, only `choices_distribution` should be called provider._random_ipv4_address_from_subnets( subnets, valid_weights) assert mock_choices_fn.call_count == 1 assert mock_random_choice.call_count == 0 # If weights argument is invalid, calls to `choices_distribution` will fail # and calls to `random.choice` will be made as failover behavior for invalid_weights in list_of_invalid_weights: # Reset mock objects for each iteration mock_random_choice.reset_mock() mock_choices_fn.reset_mock() provider._random_ipv4_address_from_subnets( subnets, invalid_weights) assert mock_choices_fn.call_count == 1 assert mock_random_choice.call_count == 1
def opera(cls): platform = '({0}; {1}) Presto/2.9.{2} Version/{3}.00'.format( ( cls.linux_platform_token() if random.getrandbits(1) else cls.windows_platform_token() ), MiscProvider.locale().replace('_', '-'), random.randint(160, 190), random.randint(10, 12), ) return 'Opera/{0}.{1}.{2}'.format( random.randint(8, 9), random.randint(10, 99), platform, )
def test_random_pystr_characters(self): from faker.providers.python import Provider provider = Provider(self.generator) characters = provider.pystr() assert len(characters) == 20 characters = provider.pystr(max_chars=255) assert len(characters) == 255 characters = provider.pystr(max_chars=0) assert characters == '' characters = provider.pystr(max_chars=-10) assert characters == '' characters = provider.pystr(min_chars=10, max_chars=255) assert (len(characters) >= 10)
def test_random_pystr_characters(self): from faker.providers.python import Provider provider = Provider(self.generator) 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, '') characters = provider.pystr(min_chars=10, max_chars=255) self.assertTrue((len(characters) >= 10))