def test_upload_polls_status(client_mock, caplog, config): """Upload polls status url until the end is indicated.""" caplog.set_level(logging.DEBUG, logger="charmcraft.commands") store = Store(config.charmhub) # first and second response, for pushing bytes and let the store know about it test_upload_id = "test-upload-id" client_mock.push.return_value = test_upload_id test_status_url = "https://store.c.c/status" client_mock.post.return_value = {"status-url": test_status_url} # the status checking response, will answer something not done yet twice, then ok test_revision = 123 test_status_ok = "test-status" status_response_1 = { "revisions": [{"status": "still-scanning", "revision": None, "errors": None}] } status_response_2 = { "revisions": [{"status": "more-revisions", "revision": None, "errors": None}] } status_response_3 = { "revisions": [ {"status": test_status_ok, "revision": test_revision, "errors": None} ] } client_mock.get.side_effect = [ status_response_1, status_response_2, status_response_3, ] test_status_resolution = "clean and crispy" fake_statuses = {test_status_ok: test_status_resolution} with patch.dict( "charmcraft.commands.store.store.UPLOAD_ENDING_STATUSES", fake_statuses ): with patch("charmcraft.commands.store.store.POLL_DELAY", 0.01): result = store._upload("/test/endpoint/", "some-filepath") # check the status-checking client calls (kept going until third one) assert client_mock.mock_calls[2:] == [ call.get(test_status_url), call.get(test_status_url), call.get(test_status_url), ] # check result which must have values from final result assert result.ok == test_status_resolution assert result.status == test_status_ok assert result.revision == test_revision # check logs expected = [ "Upload test-upload-id started, got status url https://store.c.c/status", "Status checked: " + str(status_response_1), "Status checked: " + str(status_response_2), "Status checked: " + str(status_response_3), ] assert expected == [rec.message for rec in caplog.records]
def test_connect_is_called_with_env_credentials(env_mock, pyexasol_mock): with ExasolConnection().connect(): assert pyexasol_mock.connect.call_count == 1 assert "schema" not in pyexasol_mock.connect.call_args[1] assert call.get("SHREQT_DSN", "localhost:8999") in env_mock.method_calls assert call.get("SHREQT_USER", "sys") in env_mock.method_calls assert call.get("SHREQT_PASS", "exasol") in env_mock.method_calls
def test_accesslogger_log(mock_dumps, mock_logger_info): """Tests expected methods are called when using log()""" request = MagicMock() alogging.AccessLogger.log(MagicMock(), request=request, response=MagicMock(), time=0.0) assert request.method_calls[0] == call.query.keys() assert request.method_calls[1] == call.get('body', dict()) assert request.method_calls[2] == call.get('user', 'unknown_user')
def test_demo(mock_requests): demo() assert (mock_requests.mock_calls == [ call.get("http://127.0.0.1:5000/openapi.json"), call.post("http://127.0.0.1:5000/roll", json={"dice": 5}, headers={}), call.get("http://127.0.0.1:5000/roll/mockity-mock-mock", headers={}), call.get("http://mocked/roll/mockity-mock-mock", headers={}), call.patch("http://mocked/roll/mockity-mock-mock", json={"keep": [0, 1]}, headers={}), ])
def test_ssl_certificate_from_env_variable( client_library_compatible_version, monkeypatch, mocked_session ): monkeypatch.setitem(os.environ, "CA_BUNDLE", "/home/user/cert.pem") cl = ClientLibrary(url="http://0.0.0.0/fake_url/", username="******", password="******") assert cl.is_system_ready() assert cl.session.verify == "/home/user/cert.pem" assert cl.session.mock_calls[:4] == [ call.get("https://0.0.0.0/fake_url/api/v0/authok"), call.get().raise_for_status(), ]
def test_client_library_config(client_library_server_current, mocked_session, config): client_library = config.make_client() assert client_library._base_url.startswith(config.url) assert client_library.username == config.username assert client_library.password == config.password assert client_library.allow_http == config.allow_http assert client_library.session.verify == config.ssl_verify assert client_library.auto_sync == (config.auto_sync >= 0.0) assert client_library.auto_sync_interval == config.auto_sync assert client_library.session.mock_calls[:4] == [ call.get(client_library._base_url + "authok"), call.get().raise_for_status(), ]
def test_get_metric_with_overridden_granularities(self): test_settings = TEST_SETTINGS.copy() test_settings['MIN_GRANULARITY'] = 'daily' test_settings['MAX_GRANULARITY'] = 'weekly' with override_settings(REDIS_METRICS=test_settings): slug = 'test-metric' self.r.get_metric(slug) # Verify that we GET the keys from redis day, week = self.r._build_keys(slug) self.redis.assert_has_calls([ call.get(day), call.get(week), ])
def test_ssl_certificate(client_library_server_2_0_0, mocked_session): cl = ClientLibrary( url="http://0.0.0.0/fake_url/", username="******", password="******", ssl_verify="/home/user/cert.pem", ) cl.is_system_ready(wait=True) assert cl.session.verify == "/home/user/cert.pem" assert cl.session.mock_calls[:4] == [ call.get("https://0.0.0.0/fake_url/api/v0/authok"), call.get().raise_for_status(), ]
def test_ssl_certificate_from_env_variable(monkeypatch, mocked_session): monkeypatch.setitem(os.environ, "CA_BUNDLE", "/home/user/cert.pem") cl = ClientLibrary(url="http://0.0.0.0/fake_url/", username="******", password="******") cl.wait_for_lld_connected() assert cl.session.verify == "/home/user/cert.pem" assert cl.session.mock_calls == [ call.get("https://0.0.0.0/fake_url/api/v0/labs"), call.get().raise_for_status(), call.get("https://0.0.0.0/fake_url/api/v0/wait_for_lld_connected"), call.get().raise_for_status() ]
def test_list_revisions_errors(client_mock, config): """One revision with errors.""" store = Store(config.charmhub) client_mock.get.return_value = { "revisions": [ { "revision": 7, "version": "v7", "created-at": "2020-06-29T22:11:00.123", "status": "rejected", "errors": [ {"message": "error text 1", "code": "error-code-1"}, {"message": "error text 2", "code": "error-code-2"}, ], } ] } result = store.list_revisions("some-name") assert client_mock.mock_calls == [call.get("/v1/charm/some-name/revisions")] (item,) = result error1, error2 = item.errors assert error1.message == "error text 1" assert error1.code == "error-code-1" assert error2.message == "error text 2" assert error2.code == "error-code-2"
async def test_get_announce_url_succeeds(mocker): tracker = BbTracker(options={'base_url': 'http://bb.local'}) mocks = AsyncMock( get=mocker.patch('upsies.utils.http.get', AsyncMock( return_value=''' <html> <input type="text" value="https://bb.local:123/l33tb34f/announce"> </html> ''', )), post=mocker.patch('upsies.utils.http.post', AsyncMock()), login=AsyncMock(), logout=AsyncMock(), ) mocker.patch.object(tracker, 'login', mocks.login) mocker.patch.object(tracker, 'logout', mocks.logout) announce_url = await tracker.get_announce_url() assert announce_url == 'https://bb.local:123/l33tb34f/announce' assert mocks.mock_calls == [ call.login(), call.get('http://bb.local' + BbTracker._url_path['upload'], cache=False, user_agent=True), call.logout(), ]
def test_list_resource_revisions_ok(client_mock, config): """One resource revision ok.""" store = Store(config.charmhub) client_mock.get.return_value = { "revisions": [ { "created-at": "2021-02-11T13:43:22.396606", "name": "otherstuff", "revision": 1, "sha256": "1bf0399c2de1240777ba73785f1ff1de5331f12853765a0", "sha3-384": "deb9369cb2b9e86ad44160e93da43d240e6388c5dc67b8e2a5a3c2a36a26fe4c89", "sha384": "eaaba6aa119da415e6ad778358a8530c47fefbe3ceced258e8c25530107dc7908e", "sha512": ( "b8cfe885d49285d8546885167a72fd56ea23480e17c9cdd8e06b45239d79b774c6d6fc09d" ), "size": 500, }, ] } result = store.list_resource_revisions("charm-name", "resource-name") assert client_mock.mock_calls == [ call.get("/v1/charm/charm-name/resources/resource-name/revisions") ] (item,) = result assert item.revision == 1 assert item.created_at == parser.parse("2021-02-11T13:43:22.396606") assert item.size == 500
async def test_get_announce_url_succeeds(mocker): tracker = NblTracker(options={ 'username': '******', 'password': '******', 'base_url': 'http://nbl.local', 'announce': 'http://nbl.local/announce', 'exclude': 'some files', }, ) mocks = AsyncMock( get=mocker.patch( 'upsies.utils.http.get', AsyncMock(return_value=''' <html> <input type="text" value="https://nbl.local:123/l33tb34f/announce"> </html> ''', )), post=mocker.patch('upsies.utils.http.post', AsyncMock()), login=AsyncMock(), logout=AsyncMock(), ) mocker.patch.object(tracker, 'login', mocks.login) mocker.patch.object(tracker, 'logout', mocks.logout) announce_url = await tracker.get_announce_url() assert announce_url == 'https://nbl.local:123/l33tb34f/announce' assert mocks.mock_calls == [ call.login(), call.get('http://nbl.local' + NblTracker._url_path['upload'], cache=False, user_agent=True), call.logout(), ]
def test_list_resources_ok(client_mock, config): """One resource ok.""" store = Store(config.charmhub) client_mock.get.return_value = { 'resources': [ { 'name': 'testresource', 'optional': True, 'revision': 9, 'type': 'file', }, ] } result = store.list_resources('some-name') assert client_mock.mock_calls == [ call.get('/v1/charm/some-name/resources') ] (item, ) = result assert item.name == 'testresource' assert item.optional assert item.revision == 9 assert item.resource_type == 'file'
def test_clean_json_linkedIssues_ConnectionError_real_data(self) -> None: with patch('base_class.requests') as mock_requests: from test_extraction_V2 import TestExtractor, NAME from deployment_log_UAT import DeployExtractor from barros_request import BarrosExtractor dic = dict() dic['T2L-249'] = grab_tickets_json['T2L-249'] mock_requests.get.side_effect = [ ConnectionError, ConnectionError, ConnectionError, ConnectionError, ConnectionError, ConnectionError ] with self.assertRaises( ConnectionError ): # testing 2 linked tickets so the asynchronous call is triggered TestExtractor(NAME, False).clean_json(dic) with self.assertRaises( ConnectionError ): # testing 2 linked tickets so the asynchronous call is triggered DeployExtractor(NAME, False).clean_json(dic) with self.assertRaises( ConnectionError ): # testing 2 linked tickets so the asynchronous call is triggered BarrosExtractor(NAME, False).clean_json(dic) configuration = Loader.grab_configuration(self) creds = f"Basic {configuration.u}" mock_requests.assert_has_calls([ call.get(self.TEST_call_2, headers={ 'Authorization': creds, 'Content-Type': 'application/json' }, verify=False) ])
async def test_get_announce_url_fails(mocker): tracker = NblTracker(options={ 'username': '******', 'password': '******', 'base_url': 'http://nbl.local', 'announce': 'http://nbl.local/announce', 'exclude': 'some files', }, ) mocks = AsyncMock( get=mocker.patch('upsies.utils.http.get', AsyncMock(return_value='<html>foo</html>', )), post=mocker.patch('upsies.utils.http.post', AsyncMock()), login=AsyncMock(), logout=AsyncMock(), ) mocker.patch.object(tracker, 'login', mocks.login) mocker.patch.object(tracker, 'logout', mocks.logout) exp_cmd = f'{__project_name__} set trackers.{tracker.name}.announce_url <YOUR URL>' with pytest.raises( errors.RequestError, match=rf'^Failed to find announce URL - set it manually: {exp_cmd}$' ): await tracker.get_announce_url() assert mocks.mock_calls == [ call.login(), call.get('http://nbl.local' + NblTracker._url_path['upload'], cache=False, user_agent=True), call.logout(), ]
def test_get_library(client_mock, config): """Get all the information (including content) for a library revision.""" test_charm_name = 'test-charm-name' test_lib_name = 'test-lib-name' test_lib_id = 'test-lib-id' test_api = 'test-api-version' test_patch = 'test-patch-version' test_content = 'test content with quite a lot of funny Python code :p' test_hash = '1234' store = Store(config.charmhub) client_mock.get.return_value = { 'api': test_api, 'content': test_content, 'hash': test_hash, 'library-id': test_lib_id, 'library-name': test_lib_name, 'charm-name': test_charm_name, 'patch': test_patch, } result_lib = store.get_library(test_charm_name, test_lib_id, test_api) assert client_mock.mock_calls == [ call.get('/v1/charm/libraries/test-charm-name/{}?api={}'.format(test_lib_id, test_api)), ] assert result_lib.api == test_api assert result_lib.content == test_content assert result_lib.content_hash == test_hash assert result_lib.lib_id == test_lib_id assert result_lib.lib_name == test_lib_name assert result_lib.charm_name == test_charm_name assert result_lib.patch == test_patch
def test_list_resource_revisions_ok(client_mock, config): """One resource revision ok.""" store = Store(config.charmhub) client_mock.get.return_value = {'revisions': [ { 'created-at': '2021-02-11T13:43:22.396606', 'name': 'otherstuff', 'revision': 1, 'sha256': '1bf0399c2de1240777ba73785f1ff1de5331f12853765a0', 'sha3-384': 'deb9369cb2b9e86ad44160e93da43d240e6388c5dc67b8e2a5a3c2a36a26fe4c89', 'sha384': 'eaaba6aa119da415e6ad778358a8530c47fefbe3ceced258e8c25530107dc7908e', 'sha512': 'b8cfe885d49285d8546885167a72fd56ea23480e17c9cdd8e06b45239d79b774c6d6fc09d', 'size': 500 }, ]} result = store.list_resource_revisions('charm-name', 'resource-name') assert client_mock.mock_calls == [ call.get('/v1/charm/charm-name/resources/resource-name/revisions') ] (item,) = result assert item.revision == 1 assert item.created_at == parser.parse('2021-02-11T13:43:22.396606') assert item.size == 500
def test_list_resources_ok(client_mock, config): """One resource ok.""" store = Store(config.charmhub) client_mock.get.return_value = { "resources": [ { "name": "testresource", "optional": True, "revision": 9, "type": "file", }, ] } result = store.list_resources("some-name") assert client_mock.mock_calls == [ call.get("/v1/charm/some-name/resources") ] (item, ) = result assert item.name == "testresource" assert item.optional assert item.revision == 9 assert item.resource_type == "file"
def test_module_wraps_config_get(self): cfg = Mock(Config) cfg.get.return_value = 3 m = Module(cfg, Messages()) self.assert_equal(3, m.get('an.entry')) self.assert_equal([call.get('an.entry')], cfg.mock_calls)
def test_list_revisions_ok(client_mock, config): """One revision ok.""" store = Store(config.charmhub) client_mock.get.return_value = {'revisions': [ { 'revision': 7, 'version': 'v7', 'created-at': '2020-06-29T22:11:00.123', 'status': 'approved', 'errors': None, } ]} result = store.list_revisions('some-name') assert client_mock.mock_calls == [ call.get('/v1/charm/some-name/revisions') ] (item,) = result assert item.revision == 7 assert item.version == 'v7' assert item.created_at == parser.parse('2020-06-29T22:11:00.123') assert item.status == 'approved' assert item.errors == []
def test_list_revisions_errors(client_mock, config): """One revision with errors.""" store = Store(config.charmhub) client_mock.get.return_value = {'revisions': [ { 'revision': 7, 'version': 'v7', 'created-at': '2020-06-29T22:11:00.123', 'status': 'rejected', 'errors': [ {'message': "error text 1", 'code': "error-code-1"}, {'message': "error text 2", 'code': "error-code-2"}, ], } ]} result = store.list_revisions('some-name') assert client_mock.mock_calls == [ call.get('/v1/charm/some-name/revisions') ] (item,) = result error1, error2 = item.errors assert error1.message == "error text 1" assert error1.code == "error-code-1" assert error2.message == "error text 2" assert error2.code == "error-code-2"
def test__init__using_defaults__no_ssl(self): connection_params_dict_mock = RLockedMagicMock() connection_params_dict_mock.get.return_value = False self.meth.__init__(connection_params_dict=connection_params_dict_mock, exchange='my-exchange') # attrs self.assertIs(self.mock._connection_params_dict, connection_params_dict_mock) self.assertEqual(self.mock._exchange, {'exchange': 'my-exchange'}) self.assertEqual(self.mock._exchange_name, 'my-exchange') self.assertEqual(self.mock._queues_to_declare, []) self.assertIsNone(self.mock._serialize) self.assertEqual(self.mock._prop_kwargs, AMQPThreadedPusher.DEFAULT_PROP_KWARGS) self.assertEqual(self.mock._mandatory, False) self.assertIs(self.mock._output_fifo.__class__, queue.Queue) self.assertEqual(self.mock._output_fifo.maxsize, 20000) self.assertIsNone(self.mock._error_callback) # calls self.assertEqual(self.mock.mock_calls, [ call._setup_communication(), call._start_publishing(), ]) self.assertEqual( connection_params_dict_mock.mock_calls, [ call.get('ssl'), ('__contains__', ('client_properties', ), {}), # because cannot use `call.__contains__` call.__setitem__('client_properties', ANY), ]) self.assertIsInstance( # 2nd argument passed to __setitem__() connection_params_dict_mock.__setitem__.mock_calls[0][-2][1], dict)
def test_disconnect_request_sent_if_and_only_if_master_is_responsive( self, is_master_responsive): slave_creation_url = 'http://{}/v1/slave'.format(self._FAKE_MASTER_URL) master_connectivity_url = 'http://{}/v1'.format(self._FAKE_MASTER_URL) slave_info_url = 'http://{}/v1/slave/1'.format(self._FAKE_MASTER_URL) if not is_master_responsive: self.mock_network.get.side_effect = requests.ConnectionError # an offline master raises ConnectionError slave = self._create_cluster_slave() slave.connect_to_master(self._FAKE_MASTER_URL) slave._disconnect_from_master() # expect a connect call and a connectivity call, and if the master is responsive also expect a disconnect call expected_network_calls = [ call.post(slave_creation_url, data=ANY), call.get(master_connectivity_url), ] if is_master_responsive: expected_network_calls.append( call.put_with_digest(slave_info_url, request_params=ANY, secret=ANY, error_on_failure=ANY)) self.mock_network.assert_has_calls(expected_network_calls, any_order=True) self.assertEqual(len(self.mock_network.method_calls), len(expected_network_calls), 'All requests should be accounted for in the test.')
def test_list_registered_names_multiple(client_mock): """List registered names getting a multiple response.""" store = Store() auth_response = { 'results': [ { 'name': 'name1', 'private': False, 'status': 'status1' }, { 'name': 'name2', 'private': True, 'status': 'status2' }, ] } client_mock.get.return_value = auth_response result = store.list_registered_names() assert client_mock.mock_calls == [call.get('/v1/charm')] item1, item2 = result assert item1.name == 'name1' assert not item1.private assert item1.status == 'status1' assert item2.name == 'name2' assert item2.private assert item2.status == 'status2'
def test_list_revisions_ok(client_mock, config): """One revision ok.""" store = Store(config.charmhub) client_mock.get.return_value = { "revisions": [{ "revision": 7, "version": "v7", "created-at": "2020-06-29T22:11:00.123", "status": "approved", "errors": None, "bases": [{ "architecture": "amd64", "channel": "20.04", "name": "ubuntu" }], }] } result = store.list_revisions("some-name") assert client_mock.mock_calls == [ call.get("/v1/charm/some-name/revisions") ] (item, ) = result assert item.revision == 7 assert item.version == "v7" assert item.created_at == parser.parse("2020-06-29T22:11:00.123") assert item.status == "approved" assert item.errors == []
def test_list_registered_names_multiple(client_mock, config): """List registered names getting a multiple response.""" store = Store(config.charmhub) auth_response = { "results": [ { "name": "name1", "type": "charm", "private": False, "status": "status1" }, { "name": "name2", "type": "bundle", "private": True, "status": "status2" }, ] } client_mock.get.return_value = auth_response result = store.list_registered_names() assert client_mock.mock_calls == [call.get("/v1/charm")] item1, item2 = result assert item1.name == "name1" assert item1.entity_type == "charm" assert not item1.private assert item1.status == "status1" assert item2.name == "name2" assert item2.entity_type == "bundle" assert item2.private assert item2.status == "status2"
def test_get_library(client_mock, config): """Get all the information (including content) for a library revision.""" test_charm_name = "test-charm-name" test_lib_name = "test-lib-name" test_lib_id = "test-lib-id" test_api = "test-api-version" test_patch = "test-patch-version" test_content = "test content with quite a lot of funny Python code :p" test_hash = "1234" store = Store(config.charmhub) client_mock.get.return_value = { "api": test_api, "content": test_content, "hash": test_hash, "library-id": test_lib_id, "library-name": test_lib_name, "charm-name": test_charm_name, "patch": test_patch, } result_lib = store.get_library(test_charm_name, test_lib_id, test_api) assert client_mock.mock_calls == [ call.get("/v1/charm/libraries/test-charm-name/{}?api={}".format( test_lib_id, test_api)), ] assert result_lib.api == test_api assert result_lib.content == test_content assert result_lib.content_hash == test_hash assert result_lib.lib_id == test_lib_id assert result_lib.lib_name == test_lib_name assert result_lib.charm_name == test_charm_name assert result_lib.patch == test_patch
def test_ssl_certificate(mocked_session): cl = ClientLibrary( url="http://0.0.0.0/fake_url/", username="******", password="******", ssl_verify="/home/user/cert.pem", ) cl.wait_for_lld_connected() assert cl.session.verify == "/home/user/cert.pem" assert cl.session.mock_calls == [ call.get("https://0.0.0.0/fake_url/api/v0/labs"), call.get().raise_for_status(), call.get("https://0.0.0.0/fake_url/api/v0/wait_for_lld_connected"), call.get().raise_for_status() ]
def test_StorageLimit(self): storage = self.storage_mock renderer = self.renderer_mock ui = self.ui_mock storage.mock_add_spec(['get', 'step_next'], spec_set=True) img_next = Mock(spec_set=[], name='img_next') imgs = { -3: None, -2: Mock(spec_set=[], name='img_-2'), -1: Mock(spec_set=[], name='img_-1'), 0: Mock(spec_set=[], name='img_0'), 1: img_next, 2: Mock(spec_set=[], name='img_2'), 3: Mock(spec_set=[], name='img_3'), 4: None, } def _get(offset): return imgs[offset] storage.get.side_effect = _get expect_storage_get = [ call.get(0), call.get(-1), call.get(-2), call.get(-3), call.get(1), call.get(2), call.get(3), call.get(4) ] renderer.mock_add_spec(['calc', 'render_to_left'], spec_set=True) calc_result = [ # left side {'left': 0, 'left_done': False, 'right': 0, 'right_done': False}, {'left': 0, 'left_done': False, 'right': 1, 'right_done': False}, {'left': 0, 'left_done': False, 'right': 2, 'right_done': False}, # right side {'left': 0, 'left_done': False, 'right': 0, 'right_done': False}, {'left': 0, 'left_done': False, 'right': 1, 'right_done': False}, {'left': 0, 'left_done': False, 'right': 2, 'right_done': False} ] renderer.calc.side_effect = calc_result expect_renderer_calc = list(itertools.repeat(call.calc(ANY, ANY), len(calc_result))) render_result = list(itertools.repeat(Mock(spec_set=[]), 101)) renderer.render_to_left.side_effect = render_result args_render = [imgs[-2], imgs[-1], imgs[0], imgs[1], imgs[2], imgs[3]] expect_renderer_render = [ call.render_to_left(args_render, img_next, i) for i in range(101) ] expect_ui = [call.draw(pic) for pic in render_result] self.instance.to_left() storage.assert_has_calls(expect_storage_get + [call.step_next()]) self.assertEqual(renderer.calc.call_count, len(expect_renderer_calc)) self.assertEqual(renderer.render_to_left.call_count, len(expect_renderer_render)) renderer.assert_has_calls(expect_renderer_calc + expect_renderer_render) ui.assert_has_calls(expect_ui)
def test_get_metric(self): """Tests getting a single metric; ``R.get_metric``.""" slug = 'test-metric' self.r.get_metric(slug) # Verify that we GET the keys from redis sec, min, hour, day, week, month, year = self.r._build_keys(slug) self.redis.assert_has_calls([ call.get(sec), call.get(min), call.get(hour), call.get(day), call.get(week), call.get(month), call.get(year), ])
def test_none_to_literal_source(self, source_mgr): source = Mock(spec_set=Source) source_mgr.get.side_effect = lambda alias: source if alias == 'src_alias' else None source_mgr.default = None holder = Mock(_fit=None, state=State.offline, spec_set=CachingHolder(1)) fit = self.make_fit(source=None) fit.container.add(holder) holder_calls_before = len(holder.mock_calls) lt_calls_before = len(fit._link_tracker.mock_calls) rt_calls_before = len(fit._restriction_tracker.mock_calls) st_calls_before = len(fit.stats.mock_calls) sm_calls_before = len(source_mgr.mock_calls) fit._link_tracker.add_holder.side_effect = lambda h: self.assertIs(h._fit.source, source) fit._link_tracker.enable_states.side_effect = lambda h, s: self.assertIs(h._fit.source, source) fit._restriction_tracker.enable_states.side_effect = lambda h, s: self.assertIs(h._fit.source, source) fit.stats.enable_states.side_effect = lambda h, s: self.assertIs(h._fit.source, source) holder._refresh_source.side_effect = lambda: self.assertIs(holder._fit.source, source) # Action fit.source = 'src_alias' # Checks holder_calls_after = len(holder.mock_calls) lt_calls_after = len(fit._link_tracker.mock_calls) rt_calls_after = len(fit._restriction_tracker.mock_calls) st_calls_after = len(fit.stats.mock_calls) sm_calls_after = len(source_mgr.mock_calls) self.assertEqual(holder_calls_after - holder_calls_before, 2) holder_calls = holder.mock_calls[-2:] self.assertIn(call._refresh_source(), holder_calls) self.assertIn(call._clear_volatile_attrs(), holder_calls) self.assertEqual(lt_calls_after - lt_calls_before, 2) self.assertEqual(fit._link_tracker.mock_calls[-2], call.add_holder(holder)) self.assertEqual(fit._link_tracker.mock_calls[-1], call.enable_states(holder, {State.offline})) self.assertEqual(rt_calls_after - rt_calls_before, 1) self.assertEqual(fit._restriction_tracker.mock_calls[-1], call.enable_states(holder, {State.offline})) self.assertEqual(st_calls_after - st_calls_before, 2) self.assertEqual(fit.stats.mock_calls[-2], call._clear_volatile_attrs()) self.assertEqual(fit.stats.mock_calls[-1], call._enable_states(holder, {State.offline})) self.assertEqual(sm_calls_after - sm_calls_before, 1) self.assertEqual(source_mgr.mock_calls[-1], call.get('src_alias'))
def test_disconnect_request_sent_if_and_only_if_master_is_responsive(self, is_master_responsive): slave_creation_url = 'http://{}/v1/slave'.format(self._FAKE_MASTER_URL) master_connectivity_url = 'http://{}/v1'.format(self._FAKE_MASTER_URL) slave_info_url = 'http://{}/v1/slave/1'.format(self._FAKE_MASTER_URL) if not is_master_responsive: self.mock_network.get.side_effect = requests.ConnectionError # an offline master raises ConnectionError slave = self._create_cluster_slave() slave.connect_to_master(self._FAKE_MASTER_URL) slave._disconnect_from_master() # expect a connect call and a connectivity call, and if the master is responsive also expect a disconnect call expected_network_calls = [ call.post(slave_creation_url, data=ANY), call.get(master_connectivity_url), ] if is_master_responsive: expected_network_calls.append(call.put_with_digest(slave_info_url, request_params=ANY, secret=ANY, error_on_failure=ANY)) self.mock_network.assert_has_calls(expected_network_calls, any_order=True) self.assertEqual(len(self.mock_network.method_calls), len(expected_network_calls), 'All requests should be accounted for in the test.')
def test_get_gauge(self): """Tests retrieving a gague with ``R.get_gauge``. Verifies that the Redis GET command is called with the correct key.""" self.r.get_gauge('test-gauge') self.redis.assert_has_calls([call.get('g:test-gauge')])