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_no_words_sentence(self):
from faker.providers.lorem import Provider
provider = Provider(None)
paragraph = provider.paragraph(0)
self.assertEqual(paragraph, '')
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_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_no_words_sentence(self):
from faker.providers.lorem import Provider
provider = Provider(self.generator)
paragraph = provider.paragraph(0)
assert paragraph == ''
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_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)
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()
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_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_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 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
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_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))
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)
