def test_ipv4_distribution_selection(self):
from faker.generator import Generator, random
from faker.utils.distribution import choices_distribution
provider = InternetProvider(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
11, # 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 test_ipv4_public_caching(self, faker):
from faker.providers.internet import _IPv4Constants
for address_class in _IPv4Constants._network_classes.keys():
networks_attr = f'_cached_public_class_{address_class}_networks'
weights_attr = f'{networks_attr}_weights'
provider = InternetProvider(faker)
# 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(InternetProvider, networks_attr, create=True,
new_callable=PropertyMock) as mock_networks_cache:
with patch.object(InternetProvider, 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_ipv6(self, faker, num_samples):
provider = InternetProvider(faker)
for _ in range(num_samples):
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(num_samples):
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_ipv4_caching(self, faker):
from faker.providers.internet import _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 = InternetProvider(faker)
# 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(
InternetProvider,
networks_attr,
create=True,
new_callable=PropertyMock) as mock_networks_cache:
with patch.object(
InternetProvider,
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
