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