def test_ipv4_caching(self):
from faker.providers.internet import Provider, _IPv4Constants
# The extra [None] here is to test code path involving whole IPv4 pool
for address_class in list(
_IPv4Constants._network_classes.keys()) + [None]:
if address_class is None:
networks_attr = '_cached_all_networks'
else:
networks_attr = '_cached_all_class_{}_networks'.format(
address_class)
weights_attr = '{}_weights'.format(networks_attr)
provider = Provider(self.generator)
# First, test cache creation
assert not hasattr(provider, networks_attr)
assert not hasattr(provider, weights_attr)
provider.ipv4(address_class=address_class)
assert hasattr(provider, networks_attr)
assert hasattr(provider, weights_attr)
# Then, test cache access on subsequent calls
with patch.object(
Provider,
networks_attr,
create=True,
new_callable=PropertyMock) as mock_networks_cache:
with patch.object(
Provider,
weights_attr,
create=True,
new_callable=PropertyMock) as mock_weights_cache:
# Keep test fast by patching the cache attributes to return something simple
mock_networks_cache.return_value = [
ip_network('10.0.0.0/24')
]
mock_weights_cache.return_value = [10]
for _ in range(100):
provider.ipv4(address_class=address_class)
# Python's hasattr() internally calls getattr()
# So each call to ipv4() accesses the cache attributes twice
assert mock_networks_cache.call_count == 200
assert mock_weights_cache.call_count == 200
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_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(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_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_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_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))