def setUp(self): self.validity_tester_patcher = patch(self.validity_tester) self.validity_tester_mock = self.validity_tester_patcher.start() function = Mock() function.__name__ = str('function') self.obj = Mock() self.function = function self.decorated_function = self.decorator(self.function)
def setUp(self): self.whitelist_mock = Mock() self.whitelist_mock.filter_matching.return_value = MagicMock() self.resolver_mock = Mock() self.resolver_mock.get_urls_and_locations.return_value = MagicMock() self.url_tester_mock = Mock() self.tested_instance = GeneralizedURLTester(self.url_tester_mock, self.whitelist_mock, self.resolver_mock)
def get_response_mock(url): """Get a mock representing a response to a request. :param url: response URL :returns: an instance of mock representing a response """ response = Mock() response.url = url return response
def get_url_tester_mock(identifier): """Get a mock of a URL tester object. :param identifier: an identifier for a URL tester object to be returned :returns: an instance of Mock representing a URL tester object """ source = Mock() source.identifier = identifier return source
def setUp(self): self.value_constructor_patcher = patch.object(self.class_to_test, 'factory', Mock()) self.value_constructor_mock = self.value_constructor_patcher.start() self.name_from_ip_patcher = patch('spam_lists.structures.name_from_ip') self.name_from_ip_mock = self.name_from_ip_patcher.start() self.tested_instance = self.class_to_test(Mock()) super(IPAddressTestMixin, self).setUp()
def setUp(self): self.host_factory_mock = Mock() self.host_factory_mock.side_effect = host_collection_host_factory self.tested_instance = self.constructor( 'test_host_collection', self.classification, host_factory=self.host_factory_mock)
def hp_hosts_get(url): """Get mock representing a response for a GET request. :param url: a request address :returns: a Mock instance representing response object expected by HpHosts """ query_string = urlparse(url).query query_data = parse_qs(query_string) content = 'Not Listed' host = query_data['s'][0] if host in listed_hosts: content = 'Listed,{}'.format(class_str) response = Mock() response.text = content return response
def test_lt_for_not_comparable_values(self, _, result): self.tested_instance.value.__lt__.side_effect = TypeError str_value = self.tested_instance.to_unicode() str_value.__lt__.return_value = result other = Mock() assertion = self.assertTrue if result else self.assertFalse assertion(self.tested_instance < other)
def setUp(self): url_testers = [] for _ in range(3): tester = Mock() tester.any_match.return_value = False tester.lookup_matching.return_value = [] tester.filter_matching.return_value = [] url_testers.append(tester) self.tested_instance = URLTesterChain(*url_testers)
def setUp(self): session_mock = Mock() self.head_mock = session_mock.head self.head_mock.side_effect = HeadSideEffects() self.resolve_redirects_mock = session_mock.resolve_redirects self.redirect_results = ResolveRedirectsSideEffects() self.resolve_redirects_mock.side_effect = self.redirect_results self.resolver = RedirectURLResolver(session_mock) self.patcher = patch('spam_lists.composites.is_valid_url') self.is_valid_url_mock = self.patcher.start()
def setUp(self): self.listed_hosts = [] self.get_patcher = patch('spam_lists.clients.get') self.get_mock = self.get_patcher.start() self.get_mock.side_effect = create_hp_hosts_get( self.classification, []) self.host_factory_mock = Mock() self.tested_instance = HpHosts('spam_lists_test_suite') self.tested_instance._host_factory = self.host_factory_mock self.host_factory_mock.side_effect = host_list_host_factory
def test_get_urls_and_locations(self, cached_iterable_mock): """Test if an instance of CachedIterable is returned. :param cached_iterable_mock: a mock of CachedIterable class object """ expected = Mock() cached_iterable_mock.return_value = expected actual = self.resolver.get_urls_and_locations(['http://test.com']) self.assertEqual(expected, actual)
def post(_, body): """Get mock of a response to a POST query to GSB Lookup API. :param body: a request body :returns: a Mock instance representing the response. Properties of the object depend on external values provided by the creator of the method: expected_401, spam_urls and classification """ response = Mock() if expected_401: response.status_code = 401 response.raise_for_status.side_effect = HTTPError else: urls = body.splitlines()[1:] classes = ['ok' if u not in spam_urls else ','.join(classification) for u in urls] response.text = '\n'.join(classes) code = 200 if spam_urls else 204 response.status_code = code return response
def test_lt_for_missing_to_unicode_method_to_handle(self, _, side_effect): """Test for TypeError when the other misses to_unicode method. :param side_effect: a side effect for __lt__ method of value attribute of the tested instance. """ other = Mock(spec=['value']) value = MagicMock() value.__lt__.side_effect = side_effect self.tested_instance.value = value self.assertRaises(TypeError, self.tested_instance.__lt__, other)
def setUp(self): self.host_factory_mock = Mock() self.host_factory_mock.side_effect = host_list_host_factory classification_map = {} for i, k in enumerate(self.classification, 1): classification_map[2**i] = k self.tested_instance = self.dnsbl_factory('test_service', self.query_domain_str, classification_map, self.host_factory_mock) self.dns_query_patcher = patch('spam_lists.clients.query') self.dns_query_mock = self.dns_query_patcher.start() self.dns_query_mock.side_effect = DNSQuerySideEffects([])
def post(_, body): """Get mock of a response to a POST query to GSB Lookup API. :param body: a request body :returns: a Mock instance representing the response. Properties of the object depend on external values provided by the creator of the method: expected_401, spam_urls and classification """ response = Mock() if expected_401: response.status_code = 401 response.raise_for_status.side_effect = HTTPError else: urls = body.splitlines()[1:] classes = [ 'ok' if u not in spam_urls else ','.join(classification) for u in urls ] response.text = '\n'.join(classes) code = 200 if spam_urls else 204 response.status_code = code return response
def __call__(self, query_name): """Query for a DNS name. :param query_name: a domain for which the mock is being queried :returns: a list containing a DNS answer mock :raises NXDOMAIN: if query_name is not included in the preconfigured list """ if query_name in self.expected_query_names: dns_answer_mock = Mock() return_value = '121.0.0.{}'.format(self.last_octet) dns_answer_mock.to_text.return_value = return_value return [dns_answer_mock] raise NXDOMAIN
def test_lt_for_not_comparable_values(self): """Test a result of comparing non-comparable values. The result is expected to be equal to that of comparison of string values of both objects. """ self.tested_instance.value.__lt__.side_effect = TypeError str_value = self.tested_instance.to_unicode() other = Mock() other_str_value = 'other_str' other.to_unicode.return_value = other_str_value self.assertEqual(str_value < other_str_value, self.tested_instance < other)
def setUp(self): self.listed_hosts = [] self.host_factory_mock = Mock() self.host_factory_mock.side_effect = host_list_host_factory self.tested_instance = HostList(self.host_factory_mock) self._contains_patcher = patch( 'spam_lists.host_list.HostList._contains') self._contains_mock = self._contains_patcher.start() self._contains_mock.side_effect = lambda h: h in self.listed_hosts host_data_getter_name = ( 'spam_lists.host_list.HostList._get_match_and_classification') self.host_data_getter_patcher = patch(host_data_getter_name) self.host_data_getter_mock = self.host_data_getter_patcher.start() def _get_match_and_classification(host): if host in self.listed_hosts: return host, self.classification return None, None self.host_data_getter_mock.side_effect = _get_match_and_classification
def test_lt_for_larger_value(self): """Test if True is returned for a larger value.""" self.tested_instance.value.__lt__.return_value = True self.assertTrue(self.tested_instance < Mock())
def test_constructor_for_invalid_argument(self): """Test if an error is raised for an invalid argument.""" self.value_constructor_mock.side_effect = ValueError self.assertRaises(self.class_to_test.invalid_ip_error_type, self.class_to_test, Mock())
def test_lt_for_smaller_value(self): """Test if False is returned for a smaller value.""" self.tested_instance.value.__lt__.return_value = False self.assertFalse(self.tested_instance < Mock())
def test_lt_for_missing_value_attribute(self): """Test for TypeError when value misses a 'value' attribute.""" other = Mock(spec=[]) self.assertRaises(TypeError, self.tested_instance.__lt__, other)
class GeneralizedURLTesterTest(unittest.TestCase): """Tests for GeneralizedURLTester class. :cvar test_urls: a list of URLs passed as argument to tested methods :cvar no_resolution_setup: a parameter setup for test methods requiring no explicit parameter to use (or not use) redirect resolution in tested calls. Contains names of methods of tested instance to be called :cvar common_setup: a parameter setup for test methods testing calls with and without redirect resolution, depending on value of a parameter, with False assumed as default. Contains names of methods of tested instance to be called. :ivar tested_instance: instance of GeneralizedURLTester to be tested :ivar whitelist_mock: an object representing an instance of a whitelist used by tested_instance :ivar url_tester_mock: an object representing a URL tester instance to be used by tested instance :ivar resolver_mock: an object representing an instance of redirect resolver to be used by tested instance """ # pylint: disable=too-many-public-methods test_urls = ['http:abc.com', 'http://def.com', 'http://xyz.com'] no_resolution_setup = [ ['any_match'], ['filter_matching'], ['lookup_matching'], ] common_setup = [['any_match', True], ['filter_matching', True], ['lookup_matching', True]] + no_resolution_setup def setUp(self): self.whitelist_mock = Mock() self.whitelist_mock.filter_matching.return_value = MagicMock() self.resolver_mock = Mock() self.resolver_mock.get_urls_and_locations.return_value = MagicMock() self.url_tester_mock = Mock() self.tested_instance = GeneralizedURLTester(self.url_tester_mock, self.whitelist_mock, self.resolver_mock) def _call_for(self, function_name, resolve_redirects): function = getattr(self.tested_instance, function_name) return function(self.test_urls, resolve_redirects) @parameterized.expand(common_setup) def test_whitelist_used_with(self, function_name, resolve_redirects=False): """Test if the whitelist is used during a method call. :param function_name: a name of a method to be tested :param resolve_redirects: a value of resolve_redirects argument of the tested method """ self._call_for(function_name, resolve_redirects) urls_and_locations = self.test_urls if resolve_redirects: urls_and_locations = self.resolver_mock.get_urls_and_locations() whitelist_method = self.whitelist_mock.filter_matching whitelist_method.assert_called_once_with(urls_and_locations) @parameterized.expand(no_resolution_setup) def test_resolution_with(self, function_name): """Test if redirect resolution is performed. Redirect resolution must be performed during all method calls that receive resolve_redirects=True as argument. :param function_name: a name of a method to be tested """ self._call_for(function_name, True) resolver_function = self.resolver_mock.get_urls_and_locations resolver_function.assert_called_once_with(self.test_urls) @parameterized.expand(no_resolution_setup) def test_no_resolution_with(self, function_name): """Test if redirect resolution is not performed. Redirect resolution must not be performed during all calls that receive resolve_redirects=False as argument. :param function_name: a name of a method to be tested """ self._call_for(function_name, False) self.resolver_mock.assert_not_called() @parameterized.expand(common_setup) def test_url_tester_results_for(self, function_name, resolve_redirects=False): """Test if expected results are returned. Each method must return result of a method of url_tester called during its execution. :param function_name: a name of a method to be tested :param resolve_redirects: a value of resolve_redirects argument of the tested method """ url_tester_function = getattr(self.url_tester_mock, function_name) expected = url_tester_function() actual = self._call_for(function_name, resolve_redirects) self.assertEqual(expected, actual)
def setUp(self): self.factories = tuple(Mock() for _ in range(5))