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