def test_init(self): requests = Mock() requests.request = Mock(return_value=self.response_login) with patch("cloudify_vsphere.contentlibrary.requests", requests): # correct session id cl = contentlibrary.ContentLibrary({'host': 'host', 'username': '******', 'password': '******', 'allow_insecure': True}) cl.__del__() # wrong session id response = Mock() response.json = Mock(return_value={"value": 'other_id'}) response.cookies = {'vmware-api-session-id': 'session_id'} requests.request = Mock(return_value=response) with self.assertRaises(NonRecoverableError): contentlibrary.ContentLibrary({'host': 'host', 'username': '******', 'password': '******', 'allow_insecure': True}) # no response response = Mock() response.json = Mock(return_value={}) response.cookies = {} requests.request = Mock(return_value=response) with self.assertRaises(NonRecoverableError): contentlibrary.ContentLibrary({'host': 'host', 'username': '******', 'password': '******', 'allow_insecure': True})
def test_photo_queryset(self): viewset_mock = Mock(spec=PhotoViewSet) viewset_mock.request = Mock(user=self.user2) self.assertEqual(len(PhotoViewSet.get_queryset(viewset_mock)), 2) self.contest.publish_date = date.today() - timedelta(days=1) self.contest.save() viewset_mock.request = Mock(user=self.user2) self.assertEqual(len(PhotoViewSet.get_queryset(viewset_mock)), 3)
def test_return_correct_body_for_multiple_response(self): item1 = Mock(file_name="file1") item1.request = "request1" item2 = Mock(file_name="file2") item2.request = "request2" # item2.title = Mock(return_value="title2") mapper = CherryPyMapper() mapper.cherrypy = Mock() mapper.cherrypy.url = Mock(return_value="some url") body = log.log_multiple_matches([item1, item2]) self.assertEqual(body, "Matched 2 items, choosing the first one\n- file1\nrequest1\n\n- file2\nrequest2\n")
def test_concurrency_no_auth(self): lock = Lock() calls = set() items = [] def add_item(method, url, **kwargs): thread = kwargs['thread'] with lock: if items: other = items.pop() ok_(other != thread) else: items.append(thread) sleep(0.25) with lock: ok_(not items) calls.add(thread) return Mock() session = Mock() session.request = add_item client = KerberosClient('http://nn', max_concurrency=1, session=session) args = ('POST', 'http://foo') t1 = Thread( target=client._request, args=args, kwargs={'thread': 1, 'auth': True} ) t1.start() t2 = Thread(target=client._request, args=args, kwargs={'thread': 2}) t2.start() t1.join() t2.join() eq_(calls, set([1, 2]))
def test_onionoo_too_many_answers(self): agent = Mock() resp = Mock() resp.code = 200 def feed_response(protocol): config = { "relays": [ { "fingerprint": "00786E43CCC5409753F25E36031C5CEA6EA43702", }, { "fingerprint": "boom", } ] } protocol.dataReceived(json.dumps(config).encode()) protocol.connectionLost(Failure(ResponseDone())) resp.deliverBody = Mock(side_effect=feed_response) agent.request = Mock(return_value=defer.succeed(resp)) with self.assertRaises(Exception) as ctx: yield self.router.get_onionoo_details(agent) self.assertTrue( "multiple relays for" in str(ctx.exception) )
def test_content_item_deploy_fail(self): # failed deployment response_deployment_state = Mock() response_deployment_state.cookies = {} response_deployment_state.json = Mock(return_value={"value": { 'name': 'def', 'id': 'id'}}) response_failed_deployment = Mock() response_failed_deployment.cookies = {} response_failed_deployment.json = Mock(return_value={"value": { 'name': 'def', 'succeeded': False, 'id': 'id'}}) _responses = [self.response_logout, response_failed_deployment, response_deployment_state, self.response_login] def _fake_response(*argc, **kwargs): return _responses.pop() requests = Mock() requests.request = _fake_response # check correct deployment with patch("cloudify_vsphere.contentlibrary.requests", requests): with self.assertRaises(NonRecoverableError): cl = contentlibrary.ContentLibrary({'host': 'host', 'username': '******', 'password': '******', 'allow_insecure': True}) cl.content_item_deploy( "abc", {'target': '_target'}, {'param': '_param'}) cl.__del__()
def unauthorized_response(): res = Mock(DefaultNetworkResponse, headers={}) _set_content_and_json_from_content(res, content=b'') res.status_code = 401 res.ok = False res.request = Mock() return res
def test_content_library_get(self): response_list = Mock() response_list.cookies = {} response_list.json = Mock(return_value={"value": ['abc']}) response_library = Mock() response_library.cookies = {} response_library.json = Mock(return_value={"value": {'name': 'abc', 'id': 'id'}}) _responses = [self.response_logout, response_library, response_list, self.response_login] def _fake_response(*argc, **kwargs): return _responses.pop() requests = Mock() requests.request = _fake_response # check content libraries list with patch("cloudify_vsphere.contentlibrary.requests", requests): cl = contentlibrary.ContentLibrary({'host': 'host', 'username': '******', 'password': '******', 'allow_insecure': True}) self.assertEqual(cl.content_library_get("abc"), {'name': 'abc', 'id': 'id'}) cl.__del__()
def test_execute_script_both(mock_requests): r = Mock() r.status_code = 200 r.content = resource_string( __name__, 'assets/test_execute_script_both.xml' ) r.request = Mock() mock_requests.post.return_value = r name = 'test_execute_script' engine = 'groovy' script = 'htmlOut.print("a")\nrawOut.print("b")' raw, html = h.execute_script(name, engine, script) mock_requests.post.assert_called_with( url='https://localhost:8443/engine/job/%s/script' % name, data=dict( engine=engine, script=script ), auth=None, verify=False, headers={'accept': 'application/xml'}, allow_redirects=False, timeout=None ) assert_equals("raw", raw) assert_equals("html", html)
def test_target_source_changed(self): validator = DjangoUserPermissionValidator('value') ctx = Mock(spec=['user']) ctx.request = Mock() ctx.request.user.has_perm.return_value = False self.assertFalse(validator.is_write_authorized(ctx, None, 'a', 'b')) ctx.request.user.has_perm.assert_called_with('value')
def test_target_source_not_changed(self): validator = DjangoUserPermissionValidator('value') ctx = Mock(spec=['user']) ctx.request = Mock() # Should not call has_perm ctx.request.user.has_perm.side_effect = Exception self.assertTrue(validator.is_write_authorized(ctx, None, 'a', 'a'))
def test_socks_agent_tcp_host_port(self): reactor = Mock() config = Mock() config.SocksPort = [] proto = Mock() gold = object() proto.request = Mock(return_value=defer.succeed(gold)) def getConnection(key, endpoint): self.assertTrue(isinstance(endpoint, TorSocksEndpoint)) self.assertTrue(endpoint._tls) self.assertEqual(endpoint._host, u'meejah.ca') self.assertEqual(endpoint._port, 443) return defer.succeed(proto) pool = Mock() pool.getConnection = getConnection # do the test agent = yield agent_for_socks_port(reactor, config, '127.0.0.50:1234', pool=pool) # apart from the getConnection asserts... res = yield agent.request(b'GET', b'https://meejah.ca') self.assertIs(res, gold)
def test_cleanup_parmeters(self): _responses = [self.response_logout, self.response_login] def _fake_response(*argc, **kwargs): return _responses.pop() requests = Mock() requests.request = _fake_response # check correct deployment with patch("cloudify_vsphere.contentlibrary.requests", requests): cl = contentlibrary.ContentLibrary({'host': 'host', 'username': '******', 'password': '******', 'allow_insecure': True}) self.assertEqual( cl._cleanup_specs({"additional_parameters": [{ "type": "DeploymentOptionParams", "@class": "com.vmware.vcenter.ovf.deployment_option_params" }]}), {'additional_parameters': [collections.OrderedDict([( # class should be always first in list '@class', 'com.vmware.vcenter.ovf.deployment_option_params' ), ( 'type', 'DeploymentOptionParams' )])]} ) cl.__del__()
def DatetimeDataConverter(mockTimeZone): """Set up a `DatetimeDataConverter` object for tests.""" widget = Mock() widget.request = zope.publisher.browser.TestRequest() field = Mock() field.missing_value = None return icemac.addressbook.browser.form.DatetimeDataConverter(field, widget)
def test_method_as_str(self): # noinspection PyShadowingNames def foo(_): pass # noinspection PyUnresolvedReferences with patch.object(MyClass, 'foo', foo): profile_function_or_method('silk.tests.test_dynamic_profiling', 'MyClass.foo', 'test') mock_data_collector = Mock() mock_data_collector.queries = [] mock_data_collector.request = Request() with patch('silk.profiling.profiler.DataCollector', return_value=mock_data_collector) as mock_DataCollector: MyClass().foo() self.assertEqual( mock_DataCollector.return_value.register_profile. call_count, 1) call_args = mock_DataCollector.return_value.register_profile.call_args[ 0][0] self.assertDictContainsSubset( { 'func_name': foo.__name__, 'dynamic': True, 'file_path': source_file_name(), 'name': 'test', 'line_num': six.get_function_code(foo).co_firstlineno }, call_args)
def test_widget_addform_url_on_addform(self): from plone.app.widgets.dx import AjaxSelectWidget widget = AjaxSelectWidget(self.request) form = Mock() from zope.interface import directlyProvides from z3c.form.interfaces import IAddForm directlyProvides(form, IAddForm) form.request = {'URL': 'http://addform_url'} widget.form = form self.assertEqual( { 'name': None, 'value': u'', 'pattern': 'select2', 'pattern_options': {'separator': ';'}, }, widget._base_args(), ) widget.vocabulary = 'vocabulary1' self.assertEqual( { 'name': None, 'value': u'', 'pattern': 'select2', 'pattern_options': { 'separator': ';', 'vocabularyUrl': 'http://addform_url/@@getVocabulary?name=vocabulary1'} }, widget._base_args(), )
def test_should_not_update_state_if_unaavailable(self): # Set app = NewrelicApp('1111','777') headers = {"X-Api-Key":'1111'} url ='/v2/applications/777.json' # Mocks connection_obj = Mock() response_obj = Mock() httplib.HTTPConnection = Mock(return_value=connection_obj) response_obj.status = 500 # Error response_obj.read = Mock(return_value='') connection_obj.connect = Mock() connection_obj.request = Mock() connection_obj.getresponse = Mock(return_value=response_obj) # Assertion app.update_state() connection_obj.connect.assert_called_once() connection_obj.request.assert_called_once_with('GET', url, '', headers) connection_obj.getresponse.assert_called_once() self.assertFalse(app.reachable)
def test_handle_produce_response_on_nonretriable(self, fake_decode, fake_retry): m1 = Message('test_driver', {'val': 1}, None, None, 0, 1) m2 = Message('test_driver', {'val': 2}, None, None, 0, 1) response = Mock() response.code = 500 response.error = False response.request = Mock() response.request._batch = [m1, m2] response.request._id = 1 body = { 'offsets': [{}, {}], 'value_schema_id': 1, 'key_schema_id': 2, 'error_code': 50101, 'message': 'Nonretriable' } fake_decode.return_value = body self.producer._handle_produce_response('test_driver', response) calls = [ call('test_driver', m1, 'nonretriable'), call('test_driver', m2, 'nonretriable') ] self.client.mock_for('drop_message').assert_has_calls(calls)
def setUp(self): proto = Mock() self.pool = Mock() self.expected_response = object() proto.request = Mock( return_value=defer.succeed(self.expected_response)) self.pool.getConnection = Mock(return_value=defer.succeed(proto))
def test_onionoo_success(self): agent = Mock() resp = Mock() resp.code = 200 def feed_response(protocol): config = { "relays": [ { "fingerprint": "00786E43CCC5409753F25E36031C5CEA6EA43702", }, ] } protocol.dataReceived(json.dumps(config).encode()) protocol.connectionLost(Failure(ResponseDone())) resp.deliverBody = Mock(side_effect=feed_response) agent.request = Mock(return_value=defer.succeed(resp)) data = yield self.router.get_onionoo_details(agent) self.assertTrue('fingerprint' in data) self.assertTrue( data['fingerprint'] == "00786E43CCC5409753F25E36031C5CEA6EA43702")
def test_handle_produce_success_mixed_success(self, fake_retry): m1 = Message('test_driver', {'val': 1}, None, None, 0, 1) m2 = Message('test_driver', {'val': 2}, None, None, 0, 1) m3 = Message('test_driver', {'val': 3}, None, None, 0, 1) offsets = [{}, {'error_code': 1, 'message': 'Nonretriable'}, {'error_code': 2, 'message': 'Retriable'}] response = Mock() response.request = Mock() response.request._batch = [m1, m2, m3] response.request._id = 1 body = {'offsets': offsets, 'value_schema_id': 1, 'key_schema_id': 2} self.producer._handle_produce_success('test_driver', response, body) self.client.mock_for('produce_success').assert_called_once_with('test_driver', [(m1, {})], [(m2, offsets[1]), (m3, offsets[2])]) self.client.mock_for('drop_message').assert_called_once_with('test_driver', m2, 'nonretriable') fake_retry.assert_called_once_with('test_driver', m3)
def test_return_correct_body_for_multiple_response(self): item1 = Mock(file_name="file1") item1.request = "request1" item2 = Mock(file_name="file2") item2.request = "request2" # item2.title = Mock(return_value="title2") mapper = CherryPyMapper() mapper.cherrypy = Mock() mapper.cherrypy.url = Mock(return_value="some url") body = log.log_multiple_matches([item1, item2]) self.assertEqual( body, "Matched 2 items, choosing the first one\n- file1\nrequest1\n\n- file2\nrequest2\n" )
def mock_data_collector(): mock = Mock() mock.queries = [] mock.local = Mock() r = RequestSkill() mock.local.request = r mock.request = r return mock
def _dummy_send(*args, **kwargs): dummy_response = Mock() dummy_response.headers = {} dummy_response.status_code = status_code dummy_response.text = response_body dummy_response.request = args[0] _dummy_send.call_args = (args, kwargs) return dummy_response
def pytest_funcarg__response(request): req = request.getfuncargvalue("request") response = Mock() response.request = req response.request.cookie['session_key'] = "a" * 64 response.request.session = {'session_key': "a" * 64} response.cookie = SimpleCookie() return response
def mock_data_collector(): mock = Mock() mock.queries = [] mock.local = Mock() r = Request() mock.local.request = r mock.request = r return mock
def test_no_credentials_no_401(self): http = Mock() http.request = Mock(return_value='response') client = Client(http, None) response = client.request('/uri') self.assertEquals('response', response) http.request.assert_called_once_with(DEFAULT_INSTANCE_URL + '/uri', 'GET', None, None, 5, None)
def _dummy_send(*args, **kwargs): dummy_response = Mock() dummy_response.headers = {} dummy_response.status_code = status_code dummy_response.text = response_body dummy_response.request = args[0] dummy_response.cookies = {} _dummy_send.call_args = (args, kwargs) return dummy_response
def test_onionoo_get_fails(self): agent = Mock() resp = Mock() resp.code = 500 agent.request = Mock(return_value=defer.succeed(resp)) with self.assertRaises(Exception) as ctx: yield self.router.get_onionoo_details(agent) self.assertTrue("Failed to lookup" in str(ctx.exception))
def test_different_instance_url(self): credentials = Mock() credentials.token_response = {'instance_url': 'abcd'} http = Mock() http.request = Mock(return_value='response') client = Client(http, credentials) response = client.request('/uri') self.assertEquals('response', response) http.request.assert_called_once_with('abcd/uri', ANY, ANY, ANY, ANY, ANY)
def test_return_correct_body_for_multiple_response(self): item1 = Mock(file_name="file1") item1.request = "request1" item2 = Mock(file_name="file2") item2.request = "request2" # Config = Mock(verbose=True) mapper = CherryPyMapper() mapper.cherrypy = Mock() mapper.cherrypy.url = Mock(return_value="some url") body = Log.multiple_matches([item1, item2]) self.assertEqual( body, "- file1\nrequest1\n- file2\nrequest2\n", )
def _dummy_send(*args, **kwargs): dummy_response = Mock() dummy_response.headers = {} dummy_response.getheaders = Mock(return_value={}) dummy_response.status = status_code dummy_response.read = Mock(return_value=response_body) dummy_response.request = args[0] dummy_response.cookies = {} _dummy_send.call_args = (args, kwargs) return dummy_response
def test_default_http_client_called(self): hc = Mock(stripe.http_client.HTTPClient) hc._verify_ssl_certs = True hc.name = 'mockclient' hc.request = Mock(return_value=("{}", 200, {})) stripe.default_http_client = hc stripe.Charge.list(limit=3) hc.request.assert_called_with( 'get', 'https://api.stripe.com/v1/charges?limit=3', ANY, None)
def _backend(self, session_kwargs=None): strategy = Mock() strategy.request = None strategy.session_get.return_value = object() strategy.partial_from_session.return_value = \ (0, 'mock-backend', [], session_kwargs or {}) backend = Mock() backend.name = 'mock-backend' backend.strategy = strategy return backend
def test_handle_produce_success_simple_success(self): m1 = Message('test_driver', {'val': 1}, None, None, 0, 1) response = Mock() response.request = Mock() response.request._batch = [m1] body = {'offsets': [{}], 'value_schema_id': 1, 'key_schema_id': 2} self.producer._handle_produce_success('test_driver', response, body) self.client.mock_for('produce_success').assert_called_once_with( 'test_driver', [(m1, {})], [])
def _strategy(self, session_kwargs=None): backend = Mock() backend.name = 'mock-backend' strategy = Mock() strategy.request = None strategy.backend = backend strategy.session_get.return_value = object() strategy.partial_from_session.return_value = \ (0, backend.name, [], session_kwargs or {}) return strategy
def test_onionoo_get_fails(self): agent = Mock() resp = Mock() resp.code = 500 agent.request = Mock(return_value=defer.succeed(resp)) with self.assertRaises(Exception) as ctx: yield self.router.get_onionoo_details(agent) self.assertTrue( "Failed to lookup" in str(ctx.exception) )
def test_get_event_kwargs(self, mock_fd): view = Mock(index=Mock(_silent=False), _silent=False) view.request = Mock(action='index') kwargs = events._get_event_kwargs(view) mock_fd.from_dict.assert_called_once_with( view._json_params, view.Model) assert kwargs == { 'fields': mock_fd.from_dict(), 'instance': view.context, 'model': view.Model, 'view': view }
def test_add(self): with patch('httplib.HTTPConnection') as mock_http: mock_conn = Mock() mock_conn.request = Mock() mock_http.return_value = mock_conn taskqueue.add(url='http://example.com/foo', params={'key': 'thekey'}, queue_name='test') mock_http.assert_called_with('example.com') mock_conn.request.assert_called_with( 'POST', 'http://example.com/foo', 'key=thekey', {'Content-Type': 'text/plain'})
def test_handle_produce_success_simple_success(self): m1 = Message('test_driver', {'val': 1}, None, None, 0, 1) response = Mock() response.request = Mock() response.request._batch = [m1] body = {'offsets': [{}], 'value_schema_id': 1, 'key_schema_id': 2} self.producer._handle_produce_success('test_driver', response, body) self.client.mock_for('produce_success').assert_called_once_with('test_driver', [(m1, {})], [])
def test_get_event_kwargs(self, mock_fd): view = Mock(index=Mock(_silent=False), _silent=False) view.request = Mock(action='index') kwargs = events._get_event_kwargs(view) mock_fd.from_dict.assert_called_once_with(view._json_params, view.Model) assert kwargs == { 'fields': mock_fd.from_dict(), 'instance': view.context, 'model': view.Model, 'view': view }
def test_unknown_http_return_code(self): client = HttpClient() client.verboseLevel = 0 client.session = Mock() client.session.cookies = [] resp = Mock(spec_set=requests.Response()) resp.request = Mock() resp.request.headers = {} resp.status_code = 999 client.session.request = Mock(return_value=resp) self.assertRaises(NetworkError, client.get, 'http://foo.bar', retry=False)
def generic_successful_request_response(): mock_request_response = Mock(requests.Response(), headers=dict([('header{0}'.format(i), 'value{0}'.format(i)) for i in range(4)])) _set_content_and_json_from_json(mock_request_response, json_value=dict([('key{0}'.format(i), 'value{0}'.format(i)) for i in range(8)])) mock_request_response.status_code = 200 mock_request_response.ok = True mock_request_response.request = Mock() return mock_request_response
def test_request_passes_the_url_without_path_and_without_query_string(self): http = Mock() http.request = Mock() authParamProvider = Mock() authParamProvider.get = Mock() requester = Requester(http, authParamProvider) requester.request(hostname="some.hostname.com", method="GET", apiId="API_ID", apiKey="API_KEY") url = http.request.call_args[0][1] self.assertEquals("https://some.hostname.com/api/v3/", url)
def testGetSetsCookie(self): httpRequestMock = Mock(return_value=(httplib2.Response({'set-cookie': 'acookie'}), '')) httpObjectMock = Mock() httpObjectMock.request = httpRequestMock mock = Mock(return_value=httpObjectMock) HttpClient._getHttpObject = mock client = HttpClient('username', 'password') client.get('http://localhost:9999/url') self.assertEqual('acookie', client.cookie)
def testUnknownHttpReturnCode(self): httpRequestMock = Mock(return_value=(httplib2.Response({'status': '999'}), '')) httpObjectMock = Mock() httpObjectMock.request = httpRequestMock mock = Mock(return_value=httpObjectMock) HttpClient._getHttpObject = mock client = HttpClient('username', 'password') client.cookie = 'acookie' self.assertRaises(NetworkError, client.get, 'url')
def test_init(self): requests = Mock() requests.request = Mock(return_value=self.response_login) with patch("cloudify_vsphere.contentlibrary.requests", requests): # correct session id cl = contentlibrary.ContentLibrary({ 'host': 'host', 'username': '******', 'password': '******', 'allow_insecure': True }) cl.__del__() # wrong session id response = Mock() response.json = Mock(return_value={"value": 'other_id'}) response.cookies = {'vmware-api-session-id': 'session_id'} requests.request = Mock(return_value=response) with self.assertRaises(NonRecoverableError): contentlibrary.ContentLibrary({ 'host': 'host', 'username': '******', 'password': '******', 'allow_insecure': True }) # no response response = Mock() response.json = Mock(return_value={}) response.cookies = {} requests.request = Mock(return_value=response) with self.assertRaises(NonRecoverableError): contentlibrary.ContentLibrary({ 'host': 'host', 'username': '******', 'password': '******', 'allow_insecure': True })
def test_submit_configuration(mock_requests): r = Mock() r.status_code = 200 r.request = Mock() r.content = resource_string( __name__, 'assets/test_get_job_info.xml' ) mock_requests.get.return_value = r r = Mock() r.status_code = 200 r.request = Mock() mock_requests.put.return_value = r name = 'test_submit_configuration' h.submit_configuration(name, 'cxml') mock_requests.put.assert_called_with( url=('https://localhost:8443/engine/job/' 'test/jobdir/crawler-beans.cxml'), data='cxml', auth=None, verify=False, headers={'accept': 'application/xml'}, timeout=None )
def test_request_passes_the_url_without_path_and_without_query_string( self): http = Mock() http.request = Mock() authParamProvider = Mock() authParamProvider.get = Mock() requester = Requester(http, authParamProvider) requester.request(hostname="some.hostname.com", method="GET", apiId="API_ID", apiKey="API_KEY") url = http.request.call_args[0][1] self.assertEqual("https://some.hostname.com/api/v3/", url)
def test_default_network_response_properties_pass_through_to_session_response_properties(access_token): mock_session_response = Mock(Response) mock_session_response.status_code = 200 mock_session_response.headers = {} mock_session_response.raw = Mock() mock_session_response.content = json.dumps('content') mock_session_response.request = Mock() network_reponse = DefaultNetworkResponse(mock_session_response, access_token) assert network_reponse.json() == mock_session_response.json() assert network_reponse.content == mock_session_response.content assert network_reponse.ok == mock_session_response.ok assert network_reponse.status_code == mock_session_response.status_code assert network_reponse.headers == mock_session_response.headers assert network_reponse.response_as_stream == mock_session_response.raw assert network_reponse.access_token_used == access_token