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_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')])
