def test_ipv4_private_caching(self):
from faker.providers.internet import Provider, _IPv4Constants
for address_class in _IPv4Constants._network_classes.keys():
networks_attr = '_cached_private_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_private(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_private(address_class=address_class)
# Python's hasattr() internally calls getattr()
# So each call to ipv4_private() accesses the cache attributes twice
assert mock_networks_cache.call_count == 200
assert mock_weights_cache.call_count == 200
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_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_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_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_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_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
