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)