def test_get_hash_success(self, m_get): mock_resp = Mock() mock_resp.ok = True mock_resp.text = "the_hash" m_get.return_value = mock_resp result = util.get_gitbuilder_hash() assert result == "the_hash"
def test_version_strip_v(self): resp = Mock() resp.ok = True resp.text = "v0.90.0" self.m_get_response.return_value = resp super(TestGitbuilderProject, self)\ .test_get_package_version_found()
def test_download_graphs(self): dest_dir = '/fake/path' obj = self.klass( hosts=['host1'], time_from='now-3h', dest_dir=dest_dir, ) _format = obj.graph_defaults.get('format') with patch('teuthology.task.pcp.requests.get', create=True) as m_get: m_resp = Mock() m_resp.ok = True m_get.return_value = m_resp with patch('teuthology.task.pcp.open', create=True) as m_open: m_open.return_value = MagicMock(spec=file) obj.download_graphs() expected_filenames = [] for metric in obj.metrics: expected_filenames.append( "{}.{}".format( os.path.join( dest_dir, obj._sanitize_metric_name(metric), ), _format, ) ) graph_filenames = [] for metric in obj.graphs.keys(): graph_filenames.append(obj.graphs[metric]['file']) assert sorted(graph_filenames) == sorted(expected_filenames)
def setUp(self): # mock request object request = Request() request.method = "GET" request.url = "http://example.com/" request.params = {} request.data = {} request.params_and_data = {} self.request = request # mock response object response = Mock() response.content = "access_token=321" response.headers = {"content-type": "text/html; charset=UTF-8"} response.ok = True response.status_code = 200 self.response = response # mock raise_for_status with an error def raise_for_status(): raise Exception("Response not OK!") self.raise_for_status = raise_for_status # mock hook object hook = Mock() hook.consumer_key = "123" hook.consumer_secret = "456" hook.access_token = "321" hook.access_token_secret = "654" self.hook = hook
def __one_bad_two_ok(*args): response = Mock() response.ok = args[0] == 'http://example.com/oembed2' response.text = 'hello, world' response.headers = {'content-type': 'application/json'} return response
def generic_successful_response(): mock_network_response = Mock(DefaultNetworkResponse) mock_network_response.content = b'{"message": "success"}' mock_network_response.status_code = 200 mock_network_response.ok = True mock_network_response.raw = Mock() return mock_network_response
def setUp(self): response = Mock() response.content = json.dumps({'status': 'ok'}) response.headers = {'Content-Type': 'application/json'} response.ok = True response.status_code = requests.codes.ok self.response = response
def test_package_version_for_hash(self, m_get): mock_resp = Mock() mock_resp.ok = True mock_resp.text = "the_version" m_get.return_value = mock_resp result = util.package_version_for_hash("hash") assert result == "the_version"
def test_get_hash_fail(self, m_get, m_get_gitbuilder_url): m_get_gitbuilder_url.return_value = "http://baseurl.com" mock_resp = Mock() mock_resp.ok = False m_get.return_value = mock_resp result = suite.get_hash() assert result is None
def non_json_response(): mock_network_response = Mock(DefaultNetworkResponse) mock_network_response.content = b'' mock_network_response.ok = True mock_network_response.status_code = 200 mock_network_response.json.side_effect = ValueError('No JSON object could be decoded') return mock_network_response
def setUp(self): # mock request object request = Request() request.method = 'GET' request.url = 'http://example.com/' request.params = {} request.data = {} request.params_and_data = {} self.request = request # mock response object response = Mock() response.content = 'access_token=321' response.headers = {'content-type': 'text/html; charset=UTF-8'} response.ok = True response.status_code = 200 self.response = response # mock raise_for_status with an error def raise_for_status(): raise Exception('Response not OK!') self.raise_for_status = raise_for_status # mock hook object hook = Mock() hook.consumer_key = '123' hook.consumer_secret = '456' hook.access_token = '321' hook.access_token_secret = '654' self.hook = hook
def test_api_get_fail(self, mock_login, mock_get, mock_headers): """ Test ._api_get() raises an exception """ mock_login.return_value = self.account_id mock_headers.return_value = {} mock_response = Mock(spec=requests.Response) mock_response.status_code = 500 mock_response.text = "Server error" mock_response.ok = False mock_get.return_value = mock_response url = 'https://logentries.com/app/{account_id}/rest/tag'.format(account_id=self.account_id) alert = SpecialAlertBase(self.username, self.password) with self.assertRaises(ServerException): alert._api_get( url=url, data={'k': 'v'} ) mock_get.assert_called_once_with( alert.session, url=url, headers={}, data={'k': 'v'} )
def test_get_package_sha1_fetched_found(self): resp = Mock() resp.ok = True resp.json.return_value = [dict(sha1='the_sha1')] self.m_get.return_value = resp super(TestShamanProject, self)\ .test_get_package_sha1_fetched_found()
def test_wait_for_snapshot_status_good_response_code_config_wait_period( self): client = Mock(spec=VolumesClient) config = Mock(spec=VolumesAPIConfig) config.snapshot_status_poll_frequency = 1 snapshot_model = Mock(spec=VolumeSnapshotResponse) snapshot_model.status = self.defaults.expected_status response = Mock(spec=Response) response.ok = True response.entity = snapshot_model client.get_snapshot_info = MagicMock( return_value=response) behavior = VolumesAPI_Behaviors(client, config) resp = behavior.wait_for_snapshot_status( self.defaults.snapshot_name, self.defaults.expected_status, self.defaults.timeout) self.assertIsNone(resp)
def test_load_post(self, RequestsGetMock): # set up a mock response with stubbed json to simulate the API def read_post_json(): with open(os.path.join(os.path.dirname(__file__), "data", "post.json")) as post_json_file: return json.load(post_json_file) mock_response = Mock(Response) mock_response.ok = True mock_response.text = "some text" mock_response.json = read_post_json RequestsGetMock.return_value = mock_response # call we're testing post = self.loader.load_post(1) # some validations self.assertIsInstance(post, Post) self.assertEqual(post.wp_id, 1) self.assertEqual(post.title, "This is a Test Post") self.assertEqual(post.author.name, "testauthor") self.assertEqual(post.categories.first().name, "News") self.assertEqual(post.tags.first().name, "Testing") self.assertEqual(post.attachments.first().url, "https://test.local/testpost.jpg")
def test_arbitrary_member(self, mock_request): mock_response = Mock() mock_response.ok = True mock_response.content = json.dumps({"short_codes": []}) mock_request.return_value = mock_response self.assertEqual([], self.client.sms.short_codes.list()) mock_request.assert_called_once_with("GET", ANY, params=ANY, auth=AUTH, timeout=sentinel.timeout)
def test_get_package_sha1_fetched_found(self): resp = Mock() resp.ok = True resp.text = "the_sha1" self.m_get.return_value = resp super(TestGitbuilderProject, self)\ .test_get_package_sha1_fetched_found()
def test_revoke_sends_revoke_request( client_id, client_secret, mock_network_layer, access_token, refresh_token, expected_token_to_revoke, ): mock_network_response = Mock() mock_network_response.ok = True mock_network_layer.request.return_value = mock_network_response oauth = OAuth2( client_id=client_id, client_secret=client_secret, access_token=access_token, refresh_token=refresh_token, network_layer=mock_network_layer, ) oauth.revoke() mock_network_layer.request.assert_called_once_with( 'POST', '{0}/revoke'.format(API.OAUTH2_API_URL), data={ 'client_id': client_id, 'client_secret': client_secret, 'token': expected_token_to_revoke, }, access_token=access_token, ) assert oauth.access_token is None
def test_wait_for_volume_status_good_response_code_bad_status(self): volume_name = 'mock_volume' expected_status = 'available' timeout = 10 poll_rate = 2 client = Mock(spec=VolumesClient) config = Mock(spec=VolumesAPIConfig) config.volume_status_poll_frequency = 1 volume_model = Mock(spec=VolumeResponse) volume_model.status = expected_status response = Mock(spec=Response) response.ok = True response.entity = volume_model client.get_volume_info = MagicMock( return_value=response) behavior = VolumesAPI_Behaviors(client, config) resp = behavior.wait_for_volume_status( volume_name, expected_status, timeout, poll_rate=poll_rate) self.assertIsNone(resp)
def test_wait_for_volume_status_good_response_code_configured_poll_rate( self): client = Mock(spec=VolumesClient) config = Mock(spec=VolumesAPIConfig) config.volume_status_poll_frequency = 1 volume_model = Mock(spec=VolumeResponse) volume_model.status = self.defaults.expected_status response = Mock(spec=Response) response.ok = True response.entity = volume_model client.get_volume_info = MagicMock( return_value=response) behavior = VolumesAPI_Behaviors(client, config) resp = behavior.wait_for_volume_status( self.defaults.volume_name, self.defaults.expected_status, self.defaults.timeout) self.assertIsNone(resp)
def test_wait_for_snapshot_status_good_response_and_entity_bad_status( self): recieved_status = 'error' client = Mock(spec=VolumesClient) config = Mock(spec=VolumesAPIConfig) config.snapshot_status_poll_frequency = 1 snapshot_model = Mock(spec=VolumeSnapshotResponse) snapshot_model.status = recieved_status response = Mock(spec=Response) response.ok = True response.entity = snapshot_model client.get_snapshot_info = MagicMock( return_value=response) behavior = VolumesAPI_Behaviors(client, config) with self.assertRaises(VolumesAPIBehaviorException): behavior.wait_for_snapshot_status( self.defaults.snapshot_name, self.defaults.expected_status, self.defaults.timeout, poll_rate=self.defaults.poll_rate)
def test_make_twilio_request_bad_data(mock): resp = Mock() resp.ok = False mock.return_value = resp url = "http://random/url" make_twilio_request("POST", url) mock.assert_called_with("POST", "http://random/url.json", headers=post_headers)
def test_get_branch_info(self, m_get): mock_resp = Mock() mock_resp.ok = True mock_resp.json.return_value = "some json" m_get.return_value = mock_resp result = suite.get_branch_info("teuthology", "master") m_get.assert_called_with("https://api.github.com/repos/ceph/teuthology/git/refs/heads/master") assert result == "some json"
def network_response_with_missing_tokens(request): mock_network_response = Mock(DefaultNetworkResponse) mock_network_response.ok = True json_dict = {} for key in request.param: json_dict[key] = 'fake_token' mock_network_response.json.return_value = json_dict return mock_network_response
def test_get_hash_success(self, m_get, m_get_gitbuilder_url): m_get_gitbuilder_url.return_value = "http://baseurl.com" mock_resp = Mock() mock_resp.ok = True mock_resp.text = "the_hash" m_get.return_value = mock_resp result = suite.get_hash() m_get.assert_called_with("http://baseurl.com/ref/master/sha1") assert result == "the_hash"
def test_package_version_for_hash(self, m_get, m_get_gitbuilder_url): m_get_gitbuilder_url.return_value = "http://baseurl.com" mock_resp = Mock() mock_resp.ok = True mock_resp.text = "the_version" m_get.return_value = mock_resp result = suite.package_version_for_hash("hash") m_get.assert_called_with("http://baseurl.com/sha1/hash/version") assert result == "the_version"
def test_should_raise_error_on_all_request_errors(): with patch('requests.get') as mock_get, \ pytest.raises(consumer.PyEmbedConsumerError): response = Mock() response.ok = False response.text = 'hello, world' mock_get.return_value = response consumer.get_first_oembed_response(['http://example.com/oembed1', 'http://example.com/oembed2'])
def test_get_package_version_not_found(self, m_get_response): rem = self._get_remote() ctx = dict(foo="bar") resp = Mock() resp.ok = False m_get_response.return_value = resp gp = self.klass("ceph", {}, ctx=ctx, remote=rem) with pytest.raises(VersionNotFoundError): gp.version
def generic_successful_response(): mock_network_response = Mock(Response) content = '{"message": "success"}' mock_network_response.content = content.encode('utf-8') mock_network_response.status_code = 200 mock_network_response.ok = True mock_network_response.raw = Mock() mock_network_response.json.return_value = json.loads(content) return mock_network_response
def get_response(limit, offset): items_json, items = mock_items mock_box_response = Mock(BoxResponse) mock_network_response = Mock(DefaultNetworkResponse) mock_box_response.network_response = mock_network_response mock_box_response.json.return_value = mock_json = {'entries': items_json[offset:limit + offset]} mock_box_response.content = json.dumps(mock_json).encode() mock_box_response.status_code = 200 mock_box_response.ok = True return mock_box_response, items[offset:limit + offset]
def test_get_package_version_not_found(self, m_get_config_value, m_config, m_get_response): m_config.baseurl_template = 'http://{host}/{proj}-{pkg_type}-{dist}-{arch}-{flavor}/{uri}' m_config.gitbuilder_host = "gitbuilder.ceph.com" m_get_config_value.return_value = None rem = self._get_remote() ctx = dict(foo="bar") resp = Mock() resp.ok = False m_get_response.return_value = resp gp = packaging.GitbuilderProject("ceph", {}, ctx=ctx, remote=rem) with pytest.raises(VersionNotFoundError): gp.version
def test_get_package_sha1_fetched_found(self, m_get, m_get_config_value, m_config): m_config.baseurl_template = 'http://{host}/{proj}-{pkg_type}-{dist}-{arch}-{flavor}/{uri}' m_config.gitbuilder_host = "gitbuilder.ceph.com" m_get_config_value.return_value = None resp = Mock() resp.ok = True resp.text = "the_sha1" m_get.return_value = resp rem = self._get_remote() ctx = dict(foo="bar") gp = packaging.GitbuilderProject("ceph", {}, ctx=ctx, remote=rem) assert gp.sha1 == "the_sha1"
def test_get_sl_type(self, mock_get): """Test get_sl_type""" sl_type = { 'id': 1, 'name': 'security_fixes', 'description': 'security_fixes', } mock_rv = Mock() mock_rv.ok = True mock_rv.json.return_value = {'count': 1, 'results': [sl_type]} mock_get.return_value = mock_rv rv = utils.get_sl_type('http://pdc.local/', 'securty_fixes') self.assertEqual(rv, sl_type)
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_get_sl_type_pdc_error(self, mock_request_get): """Test get_sl_type when PDC errors""" mock_rv = Mock() mock_rv.ok = False mock_rv.text = 'Some error' mock_request_get.return_value = mock_rv try: utils.get_sl_type('http://pdc.local/', 'securty_fixes') assert False, 'rpkgError not raised' except rpkgError as error: expected_error = ('The following error occurred while validating ' 'the passed in service level in PDC: Some error') self.assertEqual(str(error), expected_error)
def test_create_container(self): response = Mock(spec=requests.Response) response.ok = True client = Mock(spec=obj_client.ObjectStorageAPIClient) client.create_container = MagicMock(return_value=response) config = Mock(spec=obj_config.ObjectStorageAPIConfig) behavior = behaviors.ObjectStorageAPI_Behaviors(client, config) behavior.create_container(test_client.VALID_CONTAINER_NAME) client.create_container.assert_called_with( test_client.VALID_CONTAINER_NAME, headers={})
def get_oembed_urls(fixture='valid_oembed.html', oembed_format=None, ok=True): with patch('requests.get') as mock_get: response = Mock() response.ok = ok response.text = open('pyembed/core/test/fixtures/auto_discovery/' + fixture).read() mock_get.return_value = response result = list(discovery.AutoDiscoverer().get_oembed_urls( 'http://example.com', oembed_format)) mock_get.assert_called_with('http://example.com') return result
def empty_events_response(final_stream_position): # pylint:disable=redefined-outer-name mock_box_response = Mock(BoxResponse) mock_network_response = Mock(DefaultNetworkResponse) mock_box_response.network_response = mock_network_response mock_box_response.json.return_value = mock_json = { 'next_stream_position': final_stream_position, 'entries': [] } mock_box_response.content = json.dumps(mock_json).encode() mock_box_response.status_code = 200 mock_box_response.ok = True return mock_box_response
def get_mocks(self): client = Mock(spec=VolumesClient) config = Mock(spec=VolumesAPIConfig) volume_model = Mock(spec=VolumeResponse) response = Mock(spec=Response) config.volume_status_poll_frequency = 1 volume_model.status = self.defaults.expected_status response.ok = True response.entity = volume_model client.get_volume_info = MagicMock(return_value=response) return (client, config, volume_model, response)
def unsuccessful_jwt_response(box_datetime, status_code, error_description, include_date_header, error_code): headers = { 'Date': box_datetime.strftime('%a, %d %b %Y %H:%M:%S %Z') } if include_date_header else {} unsuccessful_response = Mock(requests.Response(), headers=headers) unsuccessful_response.json.return_value = { 'error_description': error_description, 'error': error_code } unsuccessful_response.status_code = status_code unsuccessful_response.ok = False return unsuccessful_response
def get_response(limit, offset): mock_box_response = Mock(BoxResponse) mock_network_response = Mock(DefaultNetworkResponse) mock_box_response.network_response = mock_network_response mock_box_response.json.return_value = mock_json = { 'entries': entries[offset:limit + offset], 'total_count': len(entries), 'limit': limit, } mock_box_response.content = json.dumps(mock_json).encode() mock_box_response.status_code = 200 mock_box_response.ok = True return mock_box_response
def test_create_container(self): response = Mock(spec=Response) response.ok = True client = Mock(spec=ObjectStorageAPIClient) client.create_container = MagicMock(return_value=response) config = Mock(spec=ObjectStorageAPIConfig) behavior = ObjectStorageAPI_Behaviors(client, config) behavior.create_container(client_test.VALID_CONTAINER_NAME) client.create_container.assert_called_with( client_test.VALID_CONTAINER_NAME)
def test_requests_returns_not_ok(self): req = test_bse_utils.requests = Mock() mock_not_ok = Mock() mock_not_ok.ok = False req.get = Mock(return_value=mock_not_ok) bse_utils_gen = test_bse_utils.bse_get_all_stocks_list(start=0, count=-1) with self.assertRaises(StopIteration) as context: next(bse_utils_gen) self.assertTrue(context)
def test_read_yield_data_normally(self, get): rv = Mock() rv.ok = True rv.json.side_effect = [{ 'results': ['item1', 'item2'], 'next': 'http://localhost/?page=2' }, { 'results': ['item3'], 'next': None }] get.return_value = rv result = utils.query_pdc('http://localhost/', 'endpoint', {}) self.assertEqual(['item1', 'item2', 'item3'], list(result))
def test_generate_html_static(self): obj = self.klass( hosts=['host1'], time_from='now-3h', dest_dir='/fake/path', ) with patch('teuthology.task.pcp.requests.get', create=True) as m_get: m_resp = Mock() m_resp.ok = True m_get.return_value = m_resp with patch('teuthology.task.pcp.open', mock_open(), create=True): obj.download_graphs() html = obj.generate_html(mode='static') assert config.pcp_host not in html
def test_download_chunked_file(self, client, rest_client, target_file, target_file_id): file_data = b64encode(target_file.read()) client._check_chunked_file_validity = Mock( return_value=(True, { "file_id": target_file_id, "number_of_chunks": 1 })) response = Mock() response.ok = True response.json = Mock(return_value={"data": file_data}) rest_client.get_chunked_file.return_value = response byte_obj = client.download_chunked_file("file_id") assert byte_obj.read() == b64decode(file_data)
def mock_coverage_rule(): """ rule_coverage mock value """ mock_rep = Mock() mock_rep.ok = True mock_rep.json.return_value = { "coverage": { "evolution": { "translation_platform": { "German": { "Total": 5600, "Translated": 5482, "Untranslated": 102, "Remaining": 1.82 }, }, "build_system": { "f30": { "German": { "Total": 1841, "Translated": 1841, "Untranslated": 0, "Remaining": 0 }, } } }, "libuser": { "translation_platform": { "German": { "Total": 301, "Translated": 301, "Untranslated": 0, "Remaining": 0 }, }, "build_system": { "f30": { "Statistics": "Not Synced with Build System for f30" } } }, "release": "fedora-30", "coverage_rule": "rhinstaller" } } return mock_rep
def testPassThrough(self, mock_request): mock_response = Mock() mock_response.ok = True, mock_response.content = json.dumps({'key': 'value'}) mock_request.return_value = mock_response assert_equal(self.r.timeout, sentinel.timeout) assert_equal((mock_response, { 'key': 'value' }), self.r.request('GET', base_uri)) mock_request.assert_called_once_with('GET', base_uri + '.json', headers=ANY, timeout=sentinel.timeout, auth=ANY)
def test_release_exists_current(self, mock_get): mock_rv = Mock() mock_rv.ok = True mock_rv.json.return_value = { 'name': 'F30', 'long_name': 'Fedora 30', 'version': '30', 'branch': 'f30', 'state': 'current', # this item is only important for the test } mock_get.return_value = mock_rv config = Mock() config.get.return_value = 'https://service_url/releases/F30' rv = utils.get_fedora_release_state(config, 'fedpkg', 'F30') self.assertEqual(rv, 'current')
def test_get_release_branches(self, mock_request_get): """Test that get_release_branches returns all the active Fedora release branches. """ mock_rv = Mock() mock_rv.ok = True # This abbreviated data returned from the product-versions PDC API mock_rv.json.return_value = { 'count': 7, 'next': None, 'previous': None, 'results': [{ 'short': 'epel', 'version': '6' }, { 'short': 'epel', 'version': '7' }, { 'short': 'fedora', 'version': '25' }, { 'short': 'fedora', 'version': '26' }, { 'short': 'fedora', 'version': '27' }, { 'short': 'fedora', 'version': '28' }, { 'short': 'fedora', 'version': 'rawhide' }] } mock_request_get.return_value = mock_rv expected = set(['el6', 'epel7', 'f25', 'f26', 'f27', 'f28']) expected = { 'epel': ['el6', 'epel7'], 'fedora': ['f25', 'f26', 'f27', 'f28'], } actual = utils.get_release_branches('http://pdc.local') self.assertEqual(expected, actual)
def membership_responses(total, page_size, hidden_in_batch=None): offset = 0 for number_entries in number_entries_per_response(total, page_size, hidden_in_batch): entries = take(mock_membership_dict_stream, number_entries) mock_box_response = Mock(BoxResponse) mock_network_response = Mock(DefaultNetworkResponse) mock_box_response.network_response = mock_network_response mock_box_response.json.return_value = { 'entries': entries, 'total_count': total, 'offset': offset, 'limit': page_size, } offset += number_entries mock_box_response.status_code = 200 mock_box_response.ok = True yield mock_box_response
def test_should_find_oembed_urls(): response = Mock() response.ok = True with open('pyembed/core/test/fixtures/static_discovery/valid.json') as f: response.json.return_value = json.load(f) with patch('requests.get') as mock_get: mock_get.return_value = response discoverer = discovery.UrlDiscoverer( 'http://example.com/providers.json') result = discoverer.get_oembed_urls('http://example.com/simple/123') assert list(result) == [ 'http://example.com/simple/oembed?url=http%3A%2F%2Fexample.com%2Fsimple%2F123&format=json', 'http://example.com/simple/oembed?url=http%3A%2F%2Fexample.com%2Fsimple%2F123&format=xml' ] mock_get.assert_called_with('http://example.com/providers.json')
def mock_package_status(): """ package_status mock value """ mock_rep = Mock() mock_rep.ok = True mock_rep.json.return_value = { "systemd": { "translation_stats": { "Upstream": { "French": 100, "Japanese": 0.0, "Spanish": 100, "Russian": 100, "German": 100 } }, "percentage_calculated_on": "Messages" } } return mock_rep
def get_mocks(self): client = Mock(spec=VolumesClient) volume_model = Mock(spec=VolumeResponse) volume_create_response = Mock(spec=Response) volume_model.id_ = "mock" volume_create_response.entity = volume_model volume_create_response.ok = True client.create_volume = MagicMock(return_value=volume_create_response) config = Mock(spec=VolumesAPIConfig) config.serialize_format = "json" config.deserialize_format = "json" config.max_volume_size = 1024 config.min_volume_size = 1 config.volume_status_poll_frequency = 5 config.volume_create_min_timeout = 1 config.volume_create_max_timeout = 10 config.volume_create_wait_per_gigabyte = 1 config.volume_create_base_timeout = 0 return (client, config, volume_model, volume_create_response)
def mock_release_workload_detail(): """ release_workload_detail mock value """ mock_rep = Mock() mock_rep.ok = True mock_rep.json.return_value = { "German": { "anaconda": { "Total": 1208, "Translated": 1199, "Untranslated": 9, "Remaining": 0.75 }, "abrt": { "Total": 476, "Translated": 476, "Untranslated": 0, "Remaining": 0.0 }, "Calculated on": "Messages" }, "Japanese": { "abrt": { "Total": 476, "Translated": 390, "Untranslated": 86, "Remaining": 18.07 }, "python-meh": { "Total": 23, "Translated": 20, "Untranslated": 3, "Remaining": 13.04 }, "Calculated on": "Messages" }, "Release": "fedora-27", } return mock_rep
def test_revoke_sends_revoke_request( client_id, client_secret, mock_box_session, access_token, oauth, expected_token_to_revoke, ): mock_network_response = Mock() mock_network_response.ok = True mock_box_session.request.return_value = mock_network_response oauth.revoke() mock_box_session.request.assert_called_once_with( 'POST', '{0}/revoke'.format(API.OAUTH2_API_URL), data={ 'client_id': client_id, 'client_secret': client_secret, 'token': expected_token_to_revoke, }, access_token=access_token, ) assert oauth.access_token is None
def mock_package_status_health(): """ package_status_health mock value """ mock_rep = Mock() mock_rep.ok = True mock_rep.json.return_value = { "abrt": { "fedora-30": { "Arabic": 2, "Basque": 3, "Esperanto": 7, "Friulian": 24, "Serbian": 14, "Turkish": 13, "Urdu": 3 }, "fedora-31": { "Friulian": 24 } } } return mock_rep
def mock_release_status(): """ release_status mock value """ mock_rep = Mock() mock_rep.ok = True mock_rep.json.return_value = { "fedora-27": { "anaconda": { "Total": 12080, "Translated": 11191, "Untranslated": 876, "Remaining": 7.25 }, "abrt": { "Total": 4760, "Translated": 4495, "Untranslated": 262, "Remaining": 5.5 }, "Calculated on": "Messages" } } return mock_rep
def get_response(limit, marker): mock_box_response = Mock(BoxResponse) mock_network_response = Mock(DefaultNetworkResponse) mock_box_response.network_response = mock_network_response mock_json = {} # The marker string should be of format: "marker_i", where i is the offset. Parse that out. # If the marker is None, then begin paging from the start of the entries. offset = 0 if marker is not None: offset = int(marker.split('_')[1]) mock_json['entries'] = entries[offset:limit + offset] # A next_marker is only returned if there are more pages left. if (offset + limit) < len(entries): mock_json['next_marker'] = 'marker_{0}'.format(offset + limit) elif next_marker_value_for_last_page is not self.NO_NEXT_MARKER: mock_json['next_marker'] = next_marker_value_for_last_page mock_box_response.json.return_value = mock_json mock_box_response.content = json.dumps(mock_json).encode() mock_box_response.status_code = 200 mock_box_response.ok = True return mock_box_response
def test_get_package_sha1_fetched_not_found(self): resp = Mock() resp.ok = False self.m_get.return_value = resp super(TestGitbuilderProject, self)\ .test_get_package_sha1_fetched_not_found()