def test_unexpected_status_code(self): """ Test the `UnexpectedStatusCodeException` exception. """ # with .json() exception raised response = Mock() response.json = Mock() response.json.side_effect = Exception("Test") response.status_code = 1234 exception = UnexpectedStatusCodeException(message="Test message", response=response) self.assertEqual(exception.status_code, 1234) self.assertIsNone(exception.json) self.assertEqual( str(exception), "Test message! Unexpected status code: 1234, with response body: None" ) # with .json() value response = Mock() response.json = Mock() response.json.return_value = {"test": "OK!"} response.status_code = 4321 exception = UnexpectedStatusCodeException( message="Second test message", response=response) self.assertEqual(exception.status_code, 4321) self.assertEqual(exception.json, {"test": "OK!"}) self.assertEqual( str(exception), "Second test message! Unexpected status code: 4321, with response body: {'test': 'OK!'}" )
def test_call_headers_dict(self): app = Goblet(function_name="goblet_example") mock = Mock() @app.http(headers={"test": 1, "test2": 2}) def mock_function(request): mock() return True mock_request = Mock() mock_request.path = "/" mock_request.headers = {"test": 1, "test2": 2} mock_request.json = {} mock_request2 = Mock() mock_request2.path = "/" mock_request2.headers = {"test": 1} mock_request2.json = {} mock_request3 = Mock() mock_request3.path = "/" mock_request3.headers = {"test": 3} mock_request3.json = {} app(mock_request, None) app(mock_request2, None) app(mock_request3, None) assert mock.call_count == 1
def test_071__pem_cert_chain_generate(self, mock_get): """ _pem_cert_chain_generate - request returns certificate three certs """ cert_dic = { 'issuer': 'issuer', 'certificateBase64': 'certificateBase641' } mockresponse1 = Mock() mockresponse1.json = lambda: {'certificates': {'active': 'active'}} mockresponse2 = Mock() mockresponse2.json = lambda: { 'certificateBase64': 'certificateBase642', 'issuer': 'issuer' } mockresponse3 = Mock() mockresponse3.json = lambda: {'certificates': {'active': 'active'}} mockresponse4 = Mock() mockresponse4.json = lambda: { 'certificateBase64': 'certificateBase643', 'issuer': 'issuer' } mockresponse5 = Mock() mockresponse5.json = lambda: {'foo': 'bar'} mock_get.side_effect = [ mockresponse1, mockresponse2, mockresponse3, mockresponse4, mockresponse5 ] self.assertEqual( '-----BEGIN CERTIFICATE-----\ncertificateBase641\n-----END CERTIFICATE-----\n-----BEGIN CERTIFICATE-----\ncertificateBase642\n-----END CERTIFICATE-----\n-----BEGIN CERTIFICATE-----\ncertificateBase643\n-----END CERTIFICATE-----\n', self.cahandler._pem_cert_chain_generate(cert_dic))
def test_unsubscribe_lookup_error(self, mock_requests_post, mock_requests_get): """Newsletter unsubscribe should report lookup failure""" # http://basket.readthedocs.io/newsletter_api.html#news-lookup-user expected_get_params = { 'api_key': EXPECTED_BASKET_API_KEY, 'email': self.user.email } mock_get_response = Mock() mock_get_json = Mock(return_value={ 'status': 'error', 'desc': 'user not found' }) mock_get_response.json = mock_get_json mock_requests_get.return_value = mock_get_response # http://basket.readthedocs.io/newsletter_api.html#news-unsubscribe mock_post_response = Mock() mock_post_json = Mock() mock_post_response.json = mock_post_json mock_requests_post.return_value = mock_post_response profile = UserProfile.objects.get_profile(self.user) result = profile.unsubscribe() self.assertEqual('email not found in basket', result) mock_requests_get.assert_called_with(EXPECTED_BASKET_LOOKUP_USER_URL, params=expected_get_params) mock_get_json.assert_called_with() self.assertFalse(mock_requests_post.called) self.assertFalse(mock_post_json.called)
def test_unsubscribe_request_exception(self, mock_requests_post, mock_requests_get): """Newsletter unsubscribe should gracefully handle request exceptions""" expected_get_params = { 'api_key': EXPECTED_BASKET_API_KEY, 'email': self.user.email } mock_get_response = Mock() mock_get_json = Mock(return_value={}) mock_get_response.json = mock_get_json expected_result = Timeout() def raise_request_exception(*args, **kwargs): raise expected_result mock_requests_get.side_effect = raise_request_exception mock_requests_get.return_value = mock_get_response mock_post_response = Mock() mock_post_json = Mock() mock_post_response.json = mock_post_json mock_requests_post.return_value = mock_post_response profile = UserProfile.objects.get_profile(self.user) result = profile.unsubscribe() self.assertEqual(expected_result, result) mock_requests_get.assert_called_with(EXPECTED_BASKET_LOOKUP_USER_URL, params=expected_get_params) self.assertFalse(mock_get_json.called) self.assertFalse(mock_requests_post.called) self.assertFalse(mock_post_json.called)
def test_call_route(self): app = Goblet(function_name="goblet_example") mock = Mock() mock_param = Mock() app.route("/test")(mock_dummy_function(mock)) @app.route("/test/{param}", methods=["POST"]) def mock_function2(param): mock_param(param) return True mock_event1 = Mock() mock_event1.path = "/test" mock_event1.method = "GET" mock_event1.headers = {} mock_event1.json = {} app(mock_event1, None) mock_event2 = Mock() mock_event2.path = "/test/param" mock_event2.method = "POST" mock_event2.headers = {} mock_event2.json = {} app(mock_event2, None) assert mock.call_count == 1 mock_param.assert_called_once_with("param")
def get(self, url: str, params=None): mock = Mock() if 'abci_query' in url: def mock_json(): return { 'result': { 'response': { 'code': 0, 'value': { 'custody': '391b31c15035cfd18782149267d39361c61a7672f90f6fcedac27500fba25d00' } } } } mock.json = mock_json elif 'broadcast_tx_sync' in url: def mock_json(): return { 'result': { 'code': 0, } } mock.json = mock_json return mock
def login_with_mlc( app, name="user", scope="profile%20team", email="*****@*****.**", oauth_id=1337, team_name="TestTeam", team_oauth_id=1234, raise_for_error=True, ): with app.test_client() as client, patch.object( requests, "get") as fake_get_request, patch.object( requests, "post") as fake_post_request: client.get("/login") with client.session_transaction() as sess: nonce = sess["nonce"] redirect_url = "{endpoint}?response_type=code&client_id={client_id}&scope={scope}&state={state}".format( endpoint=app.config["OAUTH_AUTHORIZATION_ENDPOINT"], client_id=app.config["OAUTH_CLIENT_ID"], scope=scope, state=nonce, ) r = client.get("/oauth", follow_redirects=False) assert r.location == redirect_url fake_post_response = Mock() fake_post_request.return_value = fake_post_response fake_post_response.status_code = 200 fake_post_response.json = lambda: { "access_token": "fake_mlc_access_token" } fake_get_response = Mock() fake_get_request.return_value = fake_get_response fake_get_response.status_code = 200 fake_get_response.json = lambda: { "id": oauth_id, "name": name, "email": email, "team": { "id": team_oauth_id, "name": team_name }, } client.get( "/redirect?code={code}&state={state}".format(code="mlc_test_code", state=nonce), follow_redirects=False, ) if raise_for_error: with client.session_transaction() as sess: assert sess["id"] assert sess["nonce"] assert sess["hash"] return client
def test_get_and_update_iou(): request_args = dict( url='url', token_network_address=factories.UNIT_TOKEN_NETWORK_ADDRESS, sender=factories.make_checksum_address(), receiver=factories.make_checksum_address(), ) # RequestExceptions should be reraised as ServiceRequestFailed with pytest.raises(ServiceRequestFailed): with patch.object(requests, 'get', side_effect=requests.RequestException): get_last_iou(**request_args) # invalid JSON should raise a ServiceRequestFailed response = Mock() response.configure_mock(status_code=200) response.json = Mock(side_effect=ValueError) with pytest.raises(ServiceRequestFailed): with patch.object(requests, 'get', return_value=response): get_last_iou(**request_args) response = Mock() response.configure_mock(status_code=200) response.json = Mock(return_value={'other_key': 'other_value'}) with patch.object(requests, 'get', return_value=response): iou = get_last_iou(**request_args) assert iou is None, 'get_pfs_iou should return None if pfs returns no iou.' response = Mock() response.configure_mock(status_code=200) last_iou = make_iou( config=dict( pathfinding_eth_address=to_checksum_address( factories.UNIT_TRANSFER_TARGET), pathfinding_iou_timeout=500, pathfinding_max_fee=100, ), our_address=factories.UNIT_TRANSFER_INITIATOR, privkey=PRIVKEY, block_number=10, ) response.json = Mock(return_value=dict(last_iou=last_iou)) with patch.object(requests, 'get', return_value=response): iou = get_last_iou(**request_args) assert iou == last_iou new_iou_1 = update_iou(iou.copy(), PRIVKEY, added_amount=10) assert new_iou_1['amount'] == last_iou['amount'] + 10 assert all(new_iou_1[k] == iou[k] for k in ('expiration_block', 'sender', 'receiver')) assert 'signature' in new_iou_1 new_iou_2 = update_iou(iou, PRIVKEY, expiration_block=45) assert new_iou_2['expiration_block'] == 45 assert all(new_iou_2[k] == iou[k] for k in ('amount', 'sender', 'receiver')) assert 'signature' in new_iou_2
def test_two_new_decks_are_same(self): response_mock = Mock() response_mock.status_code = 200 response_mock.json.return_value = NEW_PARTIAL_DECK response_mock2 = Mock() response_mock2.status_code = 200 response_mock2.json.return_value = NEW_PARTIAL_DECK # expected to be true self.assertEqual(response_mock.json()['deck_id'], response_mock2.json()['deck_id']) == True
def test_cors(self): app = Goblet(function_name="goblet_cors") app2 = Goblet(function_name="goblet_cors", cors=CORSConfig(allow_origin="app-level")) @app.route("/test", cors=True) def mock_function(): return "200" @app2.route("/test2") def mock_function2(): return Response("200") @app2.route("/override", cors=CORSConfig(allow_origin="override")) def mock_function_override(): return Response("200") @app.route("/test3", cors=CORSConfig(allow_origin="localhost")) def mock_function3(): return jsonify("200") mock_event1 = Mock() mock_event1.path = "/test" mock_event1.method = "GET" mock_event1.headers = {} mock_event1.json = {} resp = app(mock_event1, None) assert resp.headers["Access-Control-Allow-Origin"] == "*" mock_event2 = Mock() mock_event2.path = "/test2" mock_event2.method = "GET" mock_event2.headers = {} mock_event2.json = {} resp2 = app2(mock_event2, None) assert resp2.headers["Access-Control-Allow-Origin"] == "app-level" mock_event_override = Mock() mock_event_override.path = "/override" mock_event_override.method = "GET" mock_event_override.headers = {} mock_event_override.json = {} resp2 = app2(mock_event_override, None) assert resp2.headers["Access-Control-Allow-Origin"] == "override" mock_event3 = Mock() mock_event3.path = "/test3" mock_event3.method = "GET" mock_event3.headers = {} mock_event3.json = {} resp3 = app(mock_event3, None) assert resp3[2]["Access-Control-Allow-Origin"] == "localhost"
def test_post_genre_serializer(self): """ Test correct format for post serializers """ data = {'name': 'rock', 'description': 'nice'} request = Mock() request.json = data PostGenreSerializer(request=request) data = {'description': 'nice'} request.json = data with pytest.raises(ValidationError) as excinfo: PostGenreSerializer(request=request) assert "'name' is a required property" in str(excinfo.value)
def test_069__pem_cert_chain_generate(self, mock_get): """ _pem_cert_chain_generate - request returns certificate and active, 2nd request is bogus """ cert_dic = { 'issuer': 'issuer', 'certificateBase64': 'certificateBase641' } mockresponse1 = Mock() mockresponse1.json = lambda: {'certificates': {'active': 'active'}} mockresponse2 = Mock() mockresponse2.json = lambda: {'foo': 'bar'} mock_get.side_effect = [mockresponse1, mockresponse2] self.assertEqual( '-----BEGIN CERTIFICATE-----\ncertificateBase641\n-----END CERTIFICATE-----\n', self.cahandler._pem_cert_chain_generate(cert_dic))
def test_072__pem_cert_chain_generate(self, mock_get): """ _pem_cert_chain_generate - issuerCa in """ cert_dic = { 'issuerCa': 'issuerCa', 'certificateBase64': 'certificateBase641' } mockresponse1 = Mock() mockresponse1.json = lambda: {'certificates': 'certificates'} mockresponse2 = Mock() mockresponse2.json = lambda: {'foo': 'bar'} mock_get.side_effect = [mockresponse1, mockresponse2] self.assertEqual( '-----BEGIN CERTIFICATE-----\ncertificateBase641\n-----END CERTIFICATE-----\n', self.cahandler._pem_cert_chain_generate(cert_dic))
def request(method: str, url: str, *args: Any, **kwargs: Any) -> Mock: response = Mock() response.status_code = 200 if "/idsrv" in url: response.json = Mock(return_value={ "token_type": "Bearer", "access_token": "SECRET", "expires_in": expires_in.total_seconds(), }) else: response.json = Mock(return_value={}) return response
def test_update_check_ignores_downgrades(fake_post_request): """Update checks do nothing on old or same versions""" app = create_ctfd() with app.app_context(): app.config["UPDATE_CHECK"] = True fake_response = Mock() fake_post_request.return_value = fake_response fake_response.json = lambda: { u"resource": { u"html_url": u"https://github.com/CTFd/CTFd/releases/tag/0.0.1", u"download_url": u"https://api.github.com/repos/CTFd/CTFd/zipball/0.0.1", u"published_at": u"Wed, 25 Oct 2017 19:39:42 -0000", u"tag": u"0.0.1", u"prerelease": False, u"id": 6, u"latest": True, } } update_check() assert get_config("version_latest") is None fake_response = Mock() fake_post_request.return_value = fake_response fake_response.json = lambda: { u"resource": { u"html_url": u"https://github.com/CTFd/CTFd/releases/tag/{}".format( app.VERSION), u"download_url": u"https://api.github.com/repos/CTFd/CTFd/zipball/{}".format( app.VERSION), u"published_at": u"Wed, 25 Oct 2017 19:39:42 -0000", u"tag": u"{}".format(app.VERSION), u"prerelease": False, u"id": 6, u"latest": True, } } update_check() assert get_config("version_latest") is None destroy_ctfd(app)
def happy_path_fixture(chain_state, token_network_state, our_address): token_network_state, addresses, channel_states = create_square_network_topology( token_network_state=token_network_state, our_address=our_address) address1, address2, address3, address4 = addresses chain_state.nodeaddresses_to_networkstates = { address1: NODE_NETWORK_REACHABLE, address2: NODE_NETWORK_REACHABLE, address3: NODE_NETWORK_REACHABLE, address4: NODE_NETWORK_REACHABLE, } json_data = { "result": [{ "path": [ to_checksum_address(our_address), to_checksum_address(address2), to_checksum_address(address3), to_checksum_address(address4), ], "fees": 0, }] } response = Mock() response.configure_mock(status_code=200) response.json = Mock(return_value=json_data) return addresses, chain_state, channel_states, response, token_network_state
def test_get_pfs_info_success(): json_data = { "price_info": 0, "network_info": { "chain_id": 1, "registry_address": "0xB9633dd9a9a71F22C933bF121d7a22008f66B908", }, "message": "This is your favorite pathfinding service", "operator": "John Doe", "version": "0.0.1", } response = Mock() response.configure_mock(status_code=200) response.json = Mock(return_value=json_data) with patched_get_for_succesful_pfs_info(): pathfinding_service_info = get_pfs_info("url") req_registry_address = "0xB9633dd9a9a71F22C933bF121d7a22008f66B908" assert pathfinding_service_info["price_info"] == 0 assert pathfinding_service_info["network_info"]["chain_id"] == 1 assert pathfinding_service_info["network_info"][ "registry_address"] == req_registry_address assert pathfinding_service_info[ "message"] == "This is your favorite pathfinding service" assert pathfinding_service_info["operator"] == "John Doe" assert pathfinding_service_info["version"] == "0.0.1"
def fake_get_delta(delta_token, item_id, drive_id): """To mock the get_delta iterator and get desired returns.""" item_list = [] if item_id == '0': root = dict() root['id'] = item_id item_list.append(root) file_b = dict() file_b['name'] = 'file_b' file_b['id'] = '2' file_b['parentReference'] = {'id': '0'} file_b['deleted'] = {} file_b['cTag'] = 'b_ctag' file_b['lastModifiedDateTime'] = '4:30:21.447' item_list.append(file_b) else: raise HTTPError( 'Recreating the error when accesing no longer existing file.') api = Mock() response = Mock() response.json = Mock(return_value={ 'value': item_list, '@delta.token': 'delta' }) api.get = Mock(return_value=response) iterator = onedrive.OneDriveIterator(api, 'fake') iterator.last_response = mock.Mock(return_value={'@delta.token': ''}) return iterator
def test_onedrive_iterator_with_pagination(): """Iterator must return all values until is '@odata.nextLink' not returned. """ def fake_responses(): """Fake json responses which contains '@odata.nextLink' for first but call only. """ if fake_responses.called == 0: res = {'value': [0, 1, 2, 3], '@odata.nextLink': 'blub'} else: res = {'value': [4, 5, 6, 7]} fake_responses.called += 1 return res fake_responses.called = 0 api = Mock() response = Mock() response.json = Mock(side_effect=fake_responses) api.get = Mock(return_value=response) iterator = onedrive.OneDriveIterator(api, 'xxx') assert list(iterator) == list(range(8)) api.get.assert_any_call(endpoint='xxx', params={}) api.get.assert_any_call(url='blub') assert api.get.call_count == 2
def test_process_callback(self, post_mock): mock_token = "AQUpBbh2h2cBV79XaDuI7BX7adhiCBsGZbJAk9U-NiVajfoXyY5Vg5evEByHd5XrTKXB87YjNZVfXqVJ8O0zD8kHJ_mTglttKNt4FmVxqo8yw_6ZSSn9kW8m2-rM4PAM7saq53TUc0EIFgmRo1l2DEhzSwXPcasLXTk2pCrW1u4cWoPxBo4BKaCL-iG4eIqZSMvgjjDJF-1wVttpFtU8NdrKMzSBcxJZ_jZMy98r7_WMw-Gusaz12ocjfJyhOHID5PVHJW0w9Wi40WJsXZ1iHw_Tlk2olrvew5Q6R7HFjW53yFLBvkafMRdpV4mI6n-92tq_hCHzQCgHUAqfZXnN-GG7Wz5hUw" mock_expires_in = 5183999 json_mock = Mock() json_mock.return_value = { "access_token": mock_token, "expires_in": mock_expires_in } response_mock = Mock() response_mock.json = json_mock response_mock.status_code = 200 response_mock.content = b'{"access_token":"AQUpBbh2h2cBV79XaDuI7BX7adhiCBsGZbJAk9U-NiVajfoXyY5Vg5evEByHd5XrTKXB87YjNZVfXqVJ8O0zD8kHJ_mTglttKNt4FmVxqo8yw_6ZSSn9kW8m2-rM4PAM7saq53TUc0EIFgmRo1l2DEhzSwXPcasLXTk2pCrW1u4cWoPxBo4BKaCL-iG4eIqZSMvgjjDJF-1wVttpFtU8NdrKMzSBcxJZ_jZMy98r7_WMw-Gusaz12ocjfJyhOHID5PVHJW0w9Wi40WJsXZ1iHw_Tlk2olrvew5Q6R7HFjW53yFLBvkafMRdpV4mI6n-92tq_hCHzQCgHUAqfZXnN-GG7Wz5hUw","expires_in":5183999}' post_mock.return_value = response_mock linkedin_received_request = { 'code': "L3g7vIst8EW3t9PdQN6HwxS2X9fZyaUKCJQJ8hzdRtDBn6", 'state': self.state } token, expires_in = self.authorization.process_callback( linkedin_received_request) self.assertTrue(token, mock_token) self.assertTrue(expires_in, mock_expires_in)
def test_checks_update_endpoint(self, json_response_mock): self.scheduler.scheduler.start() check = self.check async def _json(): return check request = Mock() request.json = _json response = self.loop.run_until_complete( self.scheduler.update(request) ) self.assertEqual(list(response), []) json_response_mock.assert_called_with( data={'status': 'scheduled'}, status=202 ) # test if already scheduled check will be removed check['triggers'] = [] response = self.loop.run_until_complete( self.scheduler.update(request) ) self.assertEqual(list(response), []) json_response_mock.assert_called_with( data={'status': 'deleted'}, status=202 )
def get(path, headers=None, flg=None): value = path.partition('?')[2] result_state_values = { 'run_id=1': 'SUCCESS', 'run_id=2': 'FAILED', 'run_id=3': 'TIMEDOUT', 'run_id=4': None, 'run_id=5': 'CANCELED', 'run_id=6': 'FAILED' } life_cycle_state_values = { 'run_id=1': 'TERMINATED', 'run_id=2': 'TERMINATED', 'run_id=3': 'TERMINATED', 'run_id=4': 'SKIPPED', 'run_id=5': 'TERMINATED', 'run_id=6': 'INTERNAL_ERROR' } mock_resp = Mock() mock_resp.json = Mock( return_value={'job_id': 1000, 'run_id': 1000, 'state': {'life_cycle_state': life_cycle_state_values.get(value), 'result_state': result_state_values.get(value), 'state_message': ''}, 'task': {'notebook_task': {'notebook_path': 'path/to/notebook/fail'}}, 'run_page_url': 'https://westeurope.azuredatabricks.net/12121212#job/999/run/1'} ) return mock_resp
def test_routing_mocked_pfs_invalid_json_structure(chain_state, token_network_state, our_address): token_network_state, addresses, channel_states = create_square_network_topology( token_network_state=token_network_state, our_address=our_address) address1, address2, address3, address4 = addresses channel_state1, channel_state2 = channel_states # test routing with all nodes available chain_state.nodeaddresses_to_networkstates = { address1: NODE_NETWORK_REACHABLE, address2: NODE_NETWORK_REACHABLE, address3: NODE_NETWORK_REACHABLE, } response = Mock() response.configure_mock(status_code=400) response.json = Mock(return_value={}) with patch.object(requests, "post", return_value=response): routes = get_best_routes_with_iou_request_mocked( chain_state=chain_state, token_network_state=token_network_state, from_address=our_address, to_address=address4, amount=50, ) # PFS doesn't work, so internal routing is used, so two possible routes are returned, # whereas the path via address1 is shorter ( # even if the route is not possible from a global perspective) # in case the mocked pfs response were used, we would not see address1 on the route assert routes[0].node_address == address1 assert routes[0].channel_identifier == channel_state1.identifier assert routes[1].node_address == address2 assert routes[1].channel_identifier == channel_state2.identifier
def test_xy_to_pir_API_single(self, image_id, x, y, mocker): """Test that xy to pir API works.""" # patching fake_response = Mock(spec=requests.Request) fake_response.status_code = 200 rv = { "success": True, "id": 0, "start_row": 0, "num_rows": 0, "total_rows": 0, "msg": { "image_to_reference": { "x": -983.5501122512056, "y": 335.1538167934086, "z": 4117.19706627407, } }, } fake_response.json = Mock(return_value=rv) mocker.patch("requests.get", return_value=fake_response) p, i, r = xy_to_pir_API_single(x, y, image_id=image_id) # Mock calls assert ( fake_response.json.call_count == 1 ) # assert_called not available in python 3.5 :( assert np.isfinite(p) assert np.isfinite(i) assert np.isfinite(r)
def test_update_check_identifies_update(fake_get_request): """Update checks properly identify new versions""" app = create_ctfd() with app.app_context(): app.config["UPDATE_CHECK"] = True fake_response = Mock() fake_get_request.return_value = fake_response fake_response.json = lambda: { "resource": { "download_url": "https://api.github.com/repos/CTFd/CTFd/zipball/9.9.9", "html_url": "https://github.com/CTFd/CTFd/releases/tag/9.9.9", "id": 12, "latest": True, "next": 1542212248, "prerelease": False, "published_at": "Wed, 25 Oct 2017 19:39:42 -0000", "tag": "9.9.9", } } update_check() assert (get_config("version_latest") == "https://github.com/CTFd/CTFd/releases/tag/9.9.9") assert get_config("next_update_check") == 1542212248 destroy_ctfd(app)
def test_graphjinj(): """ Tests whether graphjinj works correctly """ session = requests.Session() mock_response = Mock() mock_response.json = lambda: { "data": { "allTasks": { "edges": [ { "node": { "name": "task1" } }, { "node": { "name": "task2" } } ] } } } session.post = Mock(return_value=mock_response) result = graphjinj.run( "endpoint", read_text("test.examples", "getTasks.gjinj"), session=session ) assert "task1" in result.display assert "task2" in result.display
def _assert_is_vouched_on_mozillians(self, expected_vouched, email, mock_api_data, mock_requests_get): expected_api_url = '%(base_url)s/users/?api-key=%(api_key)s&email=%(email)s' % dict( base_url='https://example.com', api_key='8675309', email=email ) mock_json = Mock(return_value={ 'count': 1, 'next': None, 'previous': None, 'results': [ { '_url': 'https://mozillians.org/api/v2/users/12345/', 'is_vouched': expected_vouched, 'username': '******' } ] }) mock_response = Mock() mock_response.json = mock_json mock_requests_get.return_value = mock_response result_vouched = is_vouched_on_mozillians_org(User(email=email)) self.assertEqual(expected_vouched, result_vouched) mock_json.assert_called_with() mock_requests_get.assert_called_with(expected_api_url)
def test_assert_response_ok_fails_with_reason(self): response = Mock() response.ok = False response.json = MagicMock( return_value={'message': 'this is my message'}) with assert_raises_regex(ZnailError, '.*this is my message.*'): ZnailComponent('1.2.3.4')._assert_response_ok(response)
def test_superadmin_callback( client: FlaskClient, org_id: str, # pylint: disable=unused-argument ): with patch.object(auth0_sa, "authorize_access_token", return_value=None): mock_response = Mock() mock_response.json = MagicMock(return_value={"email": SA_EMAIL}) with patch.object(auth0_sa, "get", return_value=mock_response): rv = client.get("/auth/superadmin/callback?code=foobar") assert rv.status_code == 302 assert urlparse(rv.location).path == "/superadmin/" with client.session_transaction() as session: # type: ignore assert session["_superadmin"] is True assert_is_date(session["_created_at"]) assert datetime.now(timezone.utc) - datetime.fromisoformat( session["_created_at"]) < timedelta(seconds=1) assert_is_date(session["_last_request_at"]) assert datetime.now(timezone.utc) - datetime.fromisoformat( session["_last_request_at"]) < timedelta(seconds=1) assert list(session.keys()) == [ "_created_at", "_last_request_at", "_superadmin", ] assert auth0_sa.authorize_access_token.called assert auth0_sa.get.called
def setUpClass(cls): """ prepare for testing """ org = TEST_PAYLOAD[0][0] repos = TEST_PAYLOAD[0][1] org_mock = Mock() org_mock.json = Mock(return_value=org) cls.org_mock = org_mock repos_mock = Mock() repos_mock.json = Mock(return_value=repos) cls.repos_mock = repos_mock cls.get_patcher = patch('requests.get') cls.get = cls.get_patcher.start() options = {cls.org_payload["repos_url"]: repos_mock} cls.get.side_effect = lambda y: options.get(y, org_mock)
def test_get_pfs_info_success(): json_data = { 'price_info': 0, 'network_info': { 'chain_id': 1, 'registry_address': "0xB9633dd9a9a71F22C933bF121d7a22008f66B908", }, 'message': "This is your favorite pathfinding service", 'operator': "John Doe", 'version': "0.0.1", } response = Mock() response.configure_mock(status_code=200) response.json = Mock(return_value=json_data) with patch.object(requests, 'get', return_value=response): pathfinding_service_info = get_pfs_info("url") req_registry_address = '0xB9633dd9a9a71F22C933bF121d7a22008f66B908' assert pathfinding_service_info['price_info'] == 0 assert pathfinding_service_info['network_info']['chain_id'] == 1 assert pathfinding_service_info['network_info'][ 'registry_address'] == req_registry_address assert pathfinding_service_info[ 'message'] == 'This is your favorite pathfinding service' assert pathfinding_service_info['operator'] == 'John Doe' assert pathfinding_service_info['version'] == '0.0.1'
def test_handle_stream_output_stream(self, args: Mock, mock_output_stream: Mock): """ Test that the formatter does define the correct variables """ args.json = False args.subprocess_cmdline = False args.stream_url = False args.output = False args.stdout = False args.url = "URL" args.player_passthrough = [] args.player_external_http = False args.player_continuous_http = False mock_output_stream.return_value = True plugin = _TestPlugin("") plugin.author = "AUTHOR" plugin.category = "CATEGORY" plugin.title = "TITLE" stream = Stream(session=Mock()) streams = {"best": stream} handle_stream(plugin, streams, "best") self.assertEqual(mock_output_stream.call_count, 1) paramStream, paramFormatter = mock_output_stream.call_args[0] self.assertIs(paramStream, stream) self.assertIsInstance(paramFormatter, Formatter) self.assertEqual( paramFormatter.title( "{url} - {author} - {category}/{game} - {title}"), "URL - AUTHOR - CATEGORY/CATEGORY - TITLE")
def test_provider_chain_when_first_and_second_provider_fails(mock_fail_response): # GIVEN provider_it = iter(ShortyService.provider_map.values()) tinyurl_provider, bitly_provider, bitly_clone_provider = next(provider_it), next(provider_it), next(provider_it) valid_url = 'https://example.com' # Mock TinyUrlProvider's Response, and assign it to its post_data method tinyurl_provider.post_data = Mock(return_value = mock_fail_response) # Mock BitlyProvider's Response, and assign it to its post_data method bitly_provider.post_data = Mock(return_value = mock_fail_response) # Mock BitlyCloneProvider's Response, and assign it to its post_data method mock_bitly_clone_post_resp = Mock() mock_bitly_clone_post_resp.status_code = 200 mock_bitly_clone_post_resp.json = Mock(return_value = {'link': 'https://bit.ly/example'}) bitly_clone_provider.post_data = Mock(return_value = mock_bitly_clone_post_resp) # WHEN ShortyService().get_provider_chain().get_shortlink(valid_url) # THEN tinyurl_provider.post_data.assert_called_once() bitly_provider.post_data.assert_called_once() bitly_clone_provider.post_data.assert_called_once()
def test_resp_on_failure(self): blk = RESTPolling() blk._retry = Mock() r = Mock() r.json = Exception() self.assertFalse(blk._retry.called) blk._on_failure(r, paging=False, url='the_url') self.assertTrue(blk._retry.called)
def test_routing_mocked_pfs_bad_http_code( chain_state, payment_network_state, token_network_state, our_address, ): token_network_state, addresses, channel_states = create_square_network_topology( payment_network_state=payment_network_state, token_network_state=token_network_state, our_address=our_address, ) address1, address2, address3 = addresses channel_state1, channel_state2 = channel_states # test routing with all nodes available chain_state.nodeaddresses_to_networkstates = { address1: NODE_NETWORK_REACHABLE, address2: NODE_NETWORK_REACHABLE, address3: NODE_NETWORK_REACHABLE, } # channel 1 and 2 are flipped here, to see when the PFS gets called json_data = { 'result': [ { 'path': [to_checksum_address(our_address), to_checksum_address(address2)], 'fees': 0, }, { 'path': [to_checksum_address(our_address), to_checksum_address(address1)], 'fees': 0, }, ], } response = Mock() response.configure_mock(status_code=400) response.json = Mock(return_value=json_data) with patch.object(requests, 'get', return_value=response): routes = get_best_routes( chain_state=chain_state, token_network_id=token_network_state.address, from_address=our_address, to_address=address1, amount=50, previous_address=None, config={ 'services': { 'pathfinding_service_address': 'my-pfs', 'pathfinding_max_paths': 3, }, }, ) assert routes[0].node_address == address1 assert routes[0].channel_identifier == channel_state1.identifier assert routes[1].node_address == address2 assert routes[1].channel_identifier == channel_state2.identifier
def test_get_next_number_bad_response(self): """Verify the client can handle bad responses for the next number.""" mock_response = Mock() mock_response.status_code = 200 mock_response.json = Mock(return_value={}) mock_post = Mock(return_value=mock_response) # Act and assert with patch('requests.post', mock_post): self.assertRaises(DoorstopError, client.get_next_number, 'PREFIX')
def setUp(self): # Mockando Objetos response_mock = Mock() def json(): return {'avatar_url': 'https://avatars.githubusercontent.com/u/3457115?v=3'} response_mock.json = json self.response_mock = response_mock
def test_generate_mailgun_response_json(self): """ Tests that generate_mailgun_response_json() returns response.json() """ response = Mock( spec=Response, status_code=status.HTTP_200_OK, json=mocked_json() ) assert generate_mailgun_response_json(response) == response.json()
def test_serializer_to_model(self): request = Mock() user_dict = { 'username': '******', 'password': '******', 'email': '*****@*****.**'} request.json = user_dict user_serializer = PostUserSerializer(request=request) user_model = User(serializer=user_serializer) assert user_dict['username'] == user_model.username assert user_model.email == user_dict['email']
def test_get_next_number(self): """Verify the client can get the next number for a document.""" mock_response = Mock() mock_response.status_code = 200 mock_response.json = Mock(return_value={'next': 42}) mock_post = Mock(return_value=mock_response) # Act with patch('requests.post', mock_post): number = client.get_next_number('PREFIX') # Assert url = 'http://1.2.3.4:8080/documents/PREFIX/numbers' headers = {'content-type': 'application/json'} mock_post.assert_called_once_with(url, headers=headers) self.assertEqual(42, number)
def test_unsubscribe(self, mock_requests_post, mock_requests_get): """Newsletter unsubscribe should call Basket API as expected""" # http://basket.readthedocs.io/newsletter_api.html#news-lookup-user expected_get_params = { 'api_key': EXPECTED_BASKET_API_KEY, 'email': self.user.email } expected_user_token = '8675309' mock_get_response = Mock() mock_get_json = Mock(return_value={ 'token': expected_user_token }) mock_get_response.json = mock_get_json mock_requests_get.return_value = mock_get_response # http://basket.readthedocs.io/newsletter_api.html#news-unsubscribe expected_post_data = { 'newsletters': 'test-pilot', 'email': self.user.email } mock_post_response = Mock() mock_post_json = Mock(return_value={'status': 'ok'}) mock_post_response.json = mock_post_json mock_requests_post.return_value = mock_post_response profile = UserProfile.objects.get_profile(self.user) profile.unsubscribe() mock_requests_get.assert_called_with(EXPECTED_BASKET_LOOKUP_USER_URL, params=expected_get_params) mock_get_json.assert_called_with() expected_url = '%s%s/' % (EXPECTED_BASKET_UNSUBSCRIBE_URL, expected_user_token) mock_requests_post.assert_called_with(expected_url, data=expected_post_data) mock_post_json.assert_called_with()
def should_get_download_info(): revision = {'type': 'Revision', 'attributes': {'url': sentinel.url}} s = Mock(spec=session.Session) s.session = Mock() response = Mock() response.json = Mock(return_value=sentinel.result) s.session.get = Mock(return_value=response) s.token = sentinel.token result = download.revision_download_info(s, revision) assert_equal(result, sentinel.result) s.session.get.assert_called_with(sentinel.url, headers={'accept': 'application/json'}, params={'token': sentinel.token})
def test_routing_mocked_pfs_invalid_json_structure( chain_state, payment_network_state, token_network_state, our_address, ): token_network_state, addresses, channel_states = create_square_network_topology( payment_network_state=payment_network_state, token_network_state=token_network_state, our_address=our_address, ) address1, address2, address3 = addresses channel_state1, channel_state2 = channel_states # test routing with all nodes available chain_state.nodeaddresses_to_networkstates = { address1: NODE_NETWORK_REACHABLE, address2: NODE_NETWORK_REACHABLE, address3: NODE_NETWORK_REACHABLE, } response = Mock() response.configure_mock(status_code=400) response.json = Mock(return_value={}) with patch.object(requests, 'get', return_value=response): routes = get_best_routes( chain_state=chain_state, token_network_id=token_network_state.address, from_address=our_address, to_address=address1, amount=50, previous_address=None, config={ 'services': { 'pathfinding_service_address': 'my-pfs', 'pathfinding_max_paths': 3, }, }, ) assert routes[0].node_address == address1 assert routes[0].channel_identifier == channel_state1.identifier assert routes[1].node_address == address2 assert routes[1].channel_identifier == channel_state2.identifier
len(self.data.domain.attributes), 1) self.assertEqual(corp.X.shape[1] - self.data.X.shape[1], 1) self.assertEqual(np.sum(corp.X[:, -1]), 0) @patch(CHECK_ALIVE, Mock(return_value=False)) def test_transform_probabilities(self): text_var = self.data.domain.metas[1] corp = self.profiler.transform(self.data, text_var, MODELS[0], 'Classes') self.assertIs(corp, self.data) response_mock = Mock() response_mock.status_code = 200 response_mock.json = lambda: {} class TestErrorsRaising(unittest.TestCase): @patch(SERVER_CALL, MockServerCall()) @patch(CHECK_ALIVE, Mock(return_value=True)) def setUp(self): self.profiler = TweetProfiler() @patch('requests.get', Mock(side_effect=requests.exceptions.ConnectionError)) def test_get_server_address_connection_error(self): address = self.profiler.get_server_address() self.assertIsNone(address) @patch(CHECK_ALIVE, Mock(return_value=False)) def test_get_server_address_server_down(self):
def mock_response( status=200, content="CONTENT", json_data=None, raise_for_status=None, url=None): """ since we typically test a bunch of different requests calls for a service, we are going to do a lot of mock responses, so its usually a good idea to have a helper function that builds these things """ mock_resp = Mock() # mock raise_for_status call w/optional error mock_resp.raise_for_status = Mock() if raise_for_status: mock_resp.raise_for_status.side_effect = raise_for_status # set status code and content mock_resp.status_code = status mock_resp.content = content mock_resp.url = url # add json data if provided if json_data: mock_resp.json = Mock( return_value=json_data ) return mock_resp