def test_walk_passes_the_specified_argument_to_callback(listdir_mock):
listdir_mock.return_value = ['f1.py']
cb = MagicMock()
fs.walk('/dummy/path', cb, 'arg')
cb.assert_called_with(ANY, 'arg')
def test_patching_a_builtin(self):
mock = MagicMock(return_value=sentinel.file_handle)
with patch('__builtin__.open', mock):
handle = open('filename', 'r')
mock.assert_called_with('filename', 'r')
assert handle == sentinel.file_handle, "incorrect file handle returned"
def test_scalyr_facets(monkeypatch, fx_facets):
kwargs, res = fx_facets
read_key = '123'
post = MagicMock()
post.return_value.json.return_value = res
monkeypatch.setattr('requests.post', post)
scalyr = ScalyrWrapper(read_key)
result = scalyr.facets(**kwargs)
assert result == res
if 'minutes' not in kwargs:
kwargs['minutes'] = 30
query = get_query(
'facet', None, read_key, **kwargs)
query.pop('function', None)
query.pop('buckets', None)
query['maxCount'] = kwargs.get('max_count', 5)
post.assert_called_with(
scalyr._ScalyrWrapper__facet_url, json=query, headers={'Content-Type': 'application/json'})
def test_wait_list(self):
self.update_ci.deploy_jobs = MagicMock(
side_effect=[['autopilot-ci'], []])
sleep_mock = MagicMock()
with patch('time.sleep', sleep_mock):
self.update_ci.update_jenkins(self.jenkins, self.jjenv, self.stack)
sleep_mock.assert_called_with(10)
class TestGraphiteTarget(TestCase):
def setUp(self):
self.base_url = 'BASE_URL'
self.record_class = MagicMock(GraphiteDataRecord)
self.http_get = MagicMock(requests.get)
self.http_get().content = SAMPLE_RESPONSE
self.target = 'TARGET'
self.records = get_records(
self.base_url,
self.http_get,
self.record_class,
self.target,
)
def test_hits_correct_url(self):
url = 'BASE_URL/render/?target=TARGET&rawData=true&from=-1min'
self.http_get.assert_called_with(url, verify=False)
def should_create_two_records(self):
calls = [call(SAMPLE_1), call(SAMPLE_2)]
self.assertEqual(self.record_class.call_args_list, calls)
def should_return_data_records(self):
self.assertEqual(self.records[0], self.record_class(SAMPLE_1))
self.assertEqual(self.records[1], self.record_class(SAMPLE_2))
def should_raise_for_status(self):
self.http_get().raise_for_status.assert_called_with()
def test_run(self):
mock = MagicMock()
code = "some SDK code"
with patch('omnimax.sdk.base_sdk.execute', mock):
sdk = omnimax.sdk.BaseSDK('ruby')
sdk.run(code)
mock.assert_called_with(self.sdk_dir + '/run.sh', code, cwd=self.sdk_dir)
def test_metrics(monkeypatch):
client = client_mock(monkeypatch)
resp = MagicMock()
resp.text = 'metrics'
client.return_value.session.get.return_value = resp
parsed = MagicMock()
parsed.samples = [
('metric-1', {}, 20.17), ('metric-2', {'verb': 'GET'}, 20.16), ('metric-1', {'verb': 'POST'}, 20.18)
]
parser = MagicMock()
parser.return_value = [parsed]
monkeypatch.setattr('zmon_worker_monitor.builtins.plugins.kubernetes.text_string_to_metric_families', parser)
k = KubernetesWrapper()
metrics = k.metrics()
expected = {
'metric-1': [({}, 20.17), ({'verb': 'POST'}, 20.18)],
'metric-2': [({'verb': 'GET'}, 20.16)],
}
assert metrics == expected
parser.assert_called_with(resp.text)
client.return_value.session.get.assert_called_with(CLUSTER_URL + '/metrics')
def test_appdynamics_log_count(monkeypatch, fx_log_count):
es_url, kwargs, res = fx_log_count
count = MagicMock()
count.return_value = res
monkeypatch.setattr('zmon_worker_monitor.builtins.plugins.appdynamics.ElasticsearchWrapper.count', count)
timestamp = 1234
timestamp_mock = MagicMock()
timestamp_mock.return_value = timestamp
monkeypatch.setattr(AppdynamicsWrapper, '_AppdynamicsWrapper__get_timestamp', timestamp_mock)
cli = AppdynamicsWrapper(url=URL, es_url=es_url, username=USER, password=PASS, index_prefix='PREFIX_')
exp_q = ('{} AND eventTimestamp:>{}'
.format(kwargs.get('q', ''), timestamp)
.lstrip(' AND '))
result = cli.count_logs(**kwargs)
assert result == res['count']
kwargs['q'] = exp_q
kwargs['indices'] = ['PREFIX_*']
if 'body' not in kwargs:
kwargs['body'] = None
count.assert_called_with(**kwargs)
def test_appdynamics_log_query(monkeypatch, fx_log_hits):
es_url, kwargs, res = fx_log_hits
search = MagicMock()
search.return_value = res
monkeypatch.setattr('zmon_worker_monitor.builtins.plugins.appdynamics.ElasticsearchWrapper.search', search)
timestamp = 1234
timestamp_mock = MagicMock()
timestamp_mock.return_value = timestamp
monkeypatch.setattr(AppdynamicsWrapper, '_AppdynamicsWrapper__get_timestamp', timestamp_mock)
cli = AppdynamicsWrapper(url=URL, es_url=es_url, username=USER, password=PASS, index_prefix='PREFIX_')
exp_q = ('{} AND eventTimestamp:>{}'
.format(kwargs.get('q', ''), timestamp)
.lstrip(' AND '))
result = cli.query_logs(**kwargs)
expected = res['hits']['hits'] if not kwargs.get('raw_result', False) else res
assert result == expected
kwargs.pop('raw_result', None)
kwargs['q'] = exp_q
kwargs['size'] = 100
kwargs['indices'] = ['PREFIX_*']
if 'body' not in kwargs:
kwargs['body'] = None
search.assert_called_with(**kwargs)
def test_install_pre_argument_in_resulting_command(self):
# Lower than 1.4 versions don't end-up with `--pre` in the resulting
# output
mock = MagicMock(side_effect=[
{'retcode': 0, 'stdout': 'pip 1.2.0 /path/to/site-packages/pip'},
{'retcode': 0, 'stdout': ''}
])
with patch.dict(pip.__salt__, {'cmd.run_all': mock}):
pip.install(
'pep8', pre_releases=True
)
mock.assert_called_with(
'pip install pep8',
runas=None,
cwd=None
)
mock = MagicMock(side_effect=[
{'retcode': 0, 'stdout': 'pip 1.4.0 /path/to/site-pacakges/pip'},
{'retcode': 0, 'stdout': ''}
])
with patch.dict(pip.__salt__, {'cmd.run_all': mock}):
pip.install(
'pep8', pre_releases=True
)
mock.assert_called_with(
'pip install --pre pep8',
runas=None,
cwd=None
)
def test_load(self):
"""tests load method"""
mock_run_statement = MagicMock()
MySqlDatabase.run_statement = mock_run_statement
config = MagicMock()
config.schema = self.schema
config.data = self.data
fixture = MySqlFixture(
config=config
)
fixture.load()
# Brittle way of testing that insert statement is run
# Assumes the keys of first row in self.data are the fields to insert
data_row = self.data[0]
stmnt_fields, expected_statement = MySqlInsertStatementMixin.create_insert_statement(
table=self.schema.config.get_table(),
fields=data_row.keys(),
statement_string=True
)
expected_params = [data_row[field] for field in stmnt_fields]
mock_run_statement.assert_called_with(
expected_statement,
params=expected_params,
commit=True
)
def test_list(self):
# Patch S3Connection and its get_bucket method:
with patch('gifshare.s3.S3Connection',
name='S3Connection') as MockS3Connection:
mock_get_bucket = MagicMock(name='get_bucket')
mock_bucket = MagicMock(name='bucket')
mock_get_bucket.return_value = mock_bucket
mock_bucket.list.return_value = [
DummyKey('image1.jpeg'),
DummyKey('image2.jpeg')
]
MockS3Connection.return_value.get_bucket = mock_get_bucket
self.bucket = gifshare.s3.Bucket(config_stub)
keys = list(self.bucket.list())
self.assertEqual(keys, [
'http://dummy.web.root/image1.jpeg',
'http://dummy.web.root/image2.jpeg',
])
MockS3Connection.assert_called_with(
'dummy-access-id', 'dummy-secret-access-key')
mock_get_bucket.assert_called_with('not.a.bucket')
mock_bucket.list.assert_called_once_with()
def test_refresh_invalid_response(monkeypatch, tmpdir):
tokens.configure(dir=str(tmpdir), url='https://example.org')
tokens.manage('mytok', ['myscope'])
tokens.start() # this does not do anything..
response = MagicMock()
response.json.return_value = {'foo': 'bar'}
post = MagicMock()
post.return_value = response
monkeypatch.setattr('requests.post', post)
monkeypatch.setattr('tokens.read_credentials', lambda path: (VALID_USER_JSON, VALID_CLIENT_JSON))
with pytest.raises(tokens.InvalidTokenResponse) as exc_info:
tokens.get('mytok')
assert str(exc_info.value) == """Invalid token response: Expected a JSON object with keys "expires_in" and "access_token": 'expires_in'"""
# verify that we use a proper HTTP timeout..
post.assert_called_with('https://example.org',
data={'username': '******', 'scope': 'myscope', 'password': '******', 'grant_type': 'password'},
headers={'User-Agent': 'python-tokens/{}'.format(tokens.__version__)},
timeout=(1.25, 2.25), auth=('cid', 'sec'))
response.json.return_value = {'access_token': '', 'expires_in': 100}
with pytest.raises(tokens.InvalidTokenResponse) as exc_info:
tokens.get('mytok')
assert str(exc_info.value) == 'Invalid token response: Empty "access_token" value'
class TestDisableInterface(unittest.TestCase):
def setUp(self):
self.connection = MagicMock(name='connection')
self.html = MagicMock(name='html')
self.connection.return_value = self.html
self.html.text = open('radio_5_asp.html').read()
return
def test_24_ghz(self):
"""
Does it setup the right data dictionary and make the right call?
"""
command = DisableInterface(connection=self.connection,
band='2.4')
expected_data = {'action':'Apply',
'wl_unit':'0',
'wl_radio':'0'}
self.assertEqual(command.data, expected_data)
command()
self.connection.assert_called_with(data=expected_data)
self.assertEqual(self.connection.path, 'radio.asp')
return
def test_5_ghz(self):
"""
Does it set up the right data dictionary to disable the 5 Ghz interface?
"""
command = DisableInterface(connection=self.connection,
band='5')
expected_data = {'action':'Apply',
'wl_unit':'1',
'wl_radio':'0'}
self.assertEqual(command.data, expected_data)
def test_open(self):
"""
Does it open a file with the given filename?
"""
name = 'aoeu'
dict_writer = MagicMock()
dict_writer_instance = MagicMock()
storage = MagicMock()
dict_writer.return_value = dict_writer_instance
self.file_storage.open = MagicMock()
opened = MagicMock()
self.file_storage.open.return_value = opened
with patch('csv.DictWriter', dict_writer):
# the call to `open`
writer = self.storage.open(name)
# did it open a file using the filename?
self.file_storage.open.assert_called_with(name)
# Did it create and store a DictWriter?
self.assertEqual(writer.writer, dict_writer_instance)
# Did it create the DictWriter using the opened file and headers?
dict_writer.assert_called_with(opened,
self.headers)
# Did it write the header to the file?
dict_writer_instance.writeheader.assert_called_with()
# did it return a copy of itself?
self.assertIsInstance(writer, CsvDictStorage)
self.assertNotEqual(writer, self.storage)
return
def test_execute_fails(self):
engine = Mock()
engine.log = Mock()
engine.log.info = MagicMock()
engine.log.failed = MagicMock()
topics = [Mock()]
get_topics_mock = Mock(return_value=topics)
execute_mock1 = MagicMock(side_effect=Exception)
execute_mock2 = MagicMock(side_effect=Exception)
self.tracker1.execute = execute_mock1
self.tracker1.get_topics = get_topics_mock
self.tracker2.execute = execute_mock2
self.tracker2.get_topics = get_topics_mock
self.trackers_manager.execute(engine, None)
self.assertTrue(engine.log.info.called)
self.assertTrue(engine.log.failed.called)
get_topics_mock.assert_called_with(None)
execute_mock1.assert_called_with(topics, engine)
execute_mock2.assert_called_with(topics, engine)
def pyodbc_exception_test(self):
"""
Test that exceptions raised by pyodbc are handled
"""
# GIVEN: A mocked out SongImport class, a mocked out pyodbc module, a mocked out translate method,
# a mocked "manager" and a mocked out logError method.
with patch('openlp.plugins.songs.lib.worshipcenterproimport.SongImport'), \
patch('openlp.plugins.songs.lib.worshipcenterproimport.pyodbc.connect') as mocked_pyodbc_connect, \
patch('openlp.plugins.songs.lib.worshipcenterproimport.translate') as mocked_translate:
mocked_manager = MagicMock()
mocked_log_error = MagicMock()
mocked_translate.return_value = 'Translated Text'
importer = WorshipCenterProImport(mocked_manager)
importer.logError = mocked_log_error
importer.import_source = 'import_source'
pyodbc_errors = [pyodbc.DatabaseError, pyodbc.IntegrityError, pyodbc.InternalError, pyodbc.OperationalError]
mocked_pyodbc_connect.side_effect = pyodbc_errors
# WHEN: Calling the doImport method
for effect in pyodbc_errors:
return_value = importer.doImport()
# THEN: doImport should return None, and pyodbc, translate & logError are called with known calls
self.assertIsNone(return_value, 'doImport should return None when pyodbc raises an exception.')
mocked_pyodbc_connect.assert_called_with( 'DRIVER={Microsoft Access Driver (*.mdb)};DBQ=import_source')
mocked_translate.assert_called_with('SongsPlugin.WorshipCenterProImport',
'Unable to connect the WorshipCenter Pro database.')
mocked_log_error.assert_called_with('import_source', 'Translated Text')
def test_scalyr_timeseries_aligned(monkeypatch, fx_timeseries_aligned):
kwargs, res, exp = fx_timeseries_aligned
read_key = '123'
post = MagicMock()
post.return_value.json.return_value = res
monkeypatch.setattr('requests.post', post)
scalyr = ScalyrWrapper(read_key)
result = scalyr.timeseries(**kwargs)
assert result == exp
query = get_query('facet', kwargs.get('function', 'count'), read_key, **kwargs)
query.pop('queryType')
final_q = {
'token': query.pop('token'),
'queries': [query]
}
post.assert_called_with(
scalyr._ScalyrWrapper__timeseries_url, json=final_q, headers={'Content-Type': 'application/json'})
def test_aws_relationship_external(self):
fake_class_instance = MagicMock()
FakeClass = MagicMock(return_value=fake_class_instance)
mock_func = MagicMock()
@decorators.aws_relationship(class_decl=FakeClass)
def test_with_mock(*args, **kwargs):
mock_func(*args, **kwargs)
_ctx = self._gen_decorators_realation_context(test_properties={
'use_external_resource': True
})
test_with_mock(ctx=_ctx)
mock_func.assert_not_called()
# force run
test_with_mock(ctx=_ctx, force_operation=True)
mock_func.assert_called_with(
ctx=_ctx,
iface=fake_class_instance, resource_config={},
force_operation=True, resource_type='AWS Resource')
def test_no_error_loading_users(self, base, toolkit, model, g, logic):
# actions
default_user = {'user_name': 'test', 'another_val': 'example value'}
user_show = MagicMock(return_value=default_user)
acquisitions_list = MagicMock()
toolkit.get_action = MagicMock(side_effect=lambda action: user_show if action == 'user_show' else acquisitions_list)
# Call the function
returned = views.acquired_datasets()
# User_show called correctly
expected_context = {
'auth_user_obj': g.userobj,
'for_view': True,
'model': model,
'session': model.Session,
'user': g.user,
}
user_show.assert_called_once_with(expected_context, {'user_obj': g.userobj})
acquisitions_list.assert_called_with(expected_context, None)
# Check that the render method has been called
base.render.assert_called_once_with('user/dashboard_acquired.html', {'user_dict': default_user, 'acquired_datasets': acquisitions_list()})
self.assertEqual(returned, base.render())
def test_setup_func(self):
# Run it when the collection doesn't exist
with mock.patch('anki.storage.Collection') as anki_storage_Collection:
col = anki_storage_Collection.return_value
setup_new_collection = MagicMock()
self.assertFalse(os.path.exists(self.collection_path))
wrapper = CollectionWrapper(self.collection_path, setup_new_collection)
wrapper.open()
anki_storage_Collection.assert_called_with(self.collection_path)
setup_new_collection.assert_called_with(col)
wrapper = None
# Make sure that no collection was actually created
self.assertFalse(os.path.exists(self.collection_path))
# Create a faux collection file
with file(self.collection_path, 'wt') as fd:
fd.write('Collection!')
# Run it when the collection does exist
with mock.patch('anki.storage.Collection'):
setup_new_collection = lambda col: self.fail("Setup function called when collection already exists!")
self.assertTrue(os.path.exists(self.collection_path))
wrapper = CollectionWrapper(self.collection_path, setup_new_collection)
wrapper.open()
anki_storage_Collection.assert_called_with(self.collection_path)
wrapper = None
def test_user_not_allowed_actions_user(self, caching_mock):
"""Test POST, PUT and DELETE for USER actions are not allowed for user
in the API"""
clean_user_mock = MagicMock()
caching_mock.get.return_value = dict(refresh=clean_user_mock)
admin = UserFactory.create()
auth = UserFactory.create()
user = UserFactory.create()
url = 'api/user'
res = self.app.post(url + '?api_key=%s' % auth.api_key,
data=json.dumps(user.to_public_json()))
data = json.loads(res.data)
assert res.status_code == 405, res.status_code
assert data['status_code'] == 405, data
# Update another user
url += '/%s' % user.id
res = self.app.put(url + '?api_key=%s' % auth.api_key,
data=json.dumps(dict(name='new')))
assert res.status_code == 403, res.data
res = self.app.delete(url + '?apikey=%s' % auth.api_key)
assert res.status_code == 405, res.status_code
# Update the same user
url = 'api/user/%s' % auth.id
res = self.app.put(url + '?api_key=%s' % auth.api_key,
data=json.dumps(dict(name='new')))
data = json.loads(res.data)
assert res.status_code == 200, res.data
assert data['name'] == 'new', data
clean_user_mock.assert_called_with(data['id'])
def it_calls_the_actions_passing_the_program_name(self):
on_raw = MagicMock()
parser = Parser()
parser.add_option('raw', on_raw)
parser(['trash-list', '--raw'])
on_raw.assert_called_with('trash-list')
def test_from_settings(self, stringport):
mock_backend = MagicMock('Mock Backend')
stringport.return_value = mock_backend
with self.settings(OPAL_SEARCH_BACKEND='mybackend'):
backend = queries.create_query(self.user, [])
self.assertEqual(mock_backend.return_value, backend)
mock_backend.assert_called_with(self.user, [])
def test_get_client_missing(config):
mock_factory = MagicMock()
mock_factory.return_value = None
registry = config.registry
registry.registerUtility(mock_factory, interfaces.IClientFactory)
request = testing.DummyRequest(registry=config.registry)
assert auth.get_client(request, '9876') is None
mock_factory.assert_called_with(request, '9876')
def test_cluster_complete(self):
mock_set_status = MagicMock()
self.manager.appStatus.set_status = mock_set_status
self.manager.appStatus._get_actual_db_status = MagicMock(
return_value=rd_instance.ServiceStatuses.RUNNING)
self.manager.cluster_complete(self.context)
mock_set_status.assert_called_with(
rd_instance.ServiceStatuses.RUNNING, force=True)
def how_getopt_works_with_an_invalid_option(self):
invalid_option_callback = MagicMock()
parser = Parser()
parser.on_invalid_option(invalid_option_callback)
parser(['command-name', '-x'])
invalid_option_callback.assert_called_with('command-name', 'x')
def test_get_upsi_config(monkeypatch):
service_guid = 'some-fake-guid'
mock_cf_curl_get = MagicMock(return_value=json.loads(UPSI_CONFIG))
monkeypatch.setattr('apployer.cf_api._cf_curl_get', mock_cf_curl_get)
assert cf_api.get_upsi_credentials(service_guid) == {'creds-key-44': 'creds-val-44'}
mock_cf_curl_get.assert_called_with(
'/v2/user_provided_service_instances/{}'.format(service_guid))
def test_update_topic_1(self, value):
topic_settings = {'display_name': self.DISPLAY_NAME1}
update_topic_mock = MagicMock(return_value=value)
self.tracker1.update_topic = update_topic_mock
self.assertEqual(value, self.trackers_manager.update_topic(self.tracker1_id1, topic_settings))
update_topic_mock.assert_called_with(self.tracker1_id1, topic_settings)
def test_get_data_request_uri(self):
mock = MagicMock(return_value=RequestsResponse(
{'votering': {'dokvotering': []}})
)
with patch('requests.get', mock):
get_votation(self.votation_id)
mock.assert_called_with(
'{0}/votering/{1}/json'.format(API_URL, self.votation_id))
def test_initialize():
model_fn = MagicMock()
_transformer.Transformer(model_fn=model_fn).initialize()
model_fn.assert_called_with(_env.model_dir)
def test_set_author_flair(self):
post = helpers.post()
mod = Moderator(post)
flair_mock = MagicMock()
post.subreddit.flair.set = flair_mock
old_get_flair = ModeratorAuthorChecks.flair_text.__wrapped__
get_flair_mock = MagicMock(return_value=None)
ModeratorAuthorChecks.flair_text.__wrapped__ = get_flair_mock
# Sets text
mod.moderate(Rule({'id': post.id, 'author': {'set_flair': 'test'}}))
flair_mock.assert_called_with(text='test')
# Sets both text and css
flair_mock.reset_mock()
mod.moderate(
Rule({
'id': post.id,
'author': {
'set_flair': ['test', 'csstest']
}
}))
flair_mock.assert_called_with(text='test', css_class='csstest')
# Raises an exception if a dictionary is passed with no template_id
with self.assertRaises(Exception):
mod.moderate(
Rule({
'id': post.id,
'author': {
'set_flair': {
'text': 'test'
}
}
}))
# Sets template_id, text, and css
flair_mock.reset_mock()
mod.moderate(
Rule({
'id': post.id,
'author': {
'set_flair': {
'template_id': 'idtest',
'text': 'test',
'css_class': 'csstest'
}
}
}))
flair_mock.assert_called_with(text='test',
css_class='csstest',
template_id='idtest')
# Does not set new flair, because overwrite_flair is not set
flair_mock.reset_mock()
get_flair_mock.return_value = 'before'
mod.moderate(Rule({'id': post.id, 'author': {'set_flair': 'test'}}))
flair_mock.assert_not_called()
mod.moderate(
Rule({
'id': post.id,
'author': {
'set_flair': 'test',
'overwrite_flair': True
}
}))
flair_mock.assert_called_with(text='test')
ModeratorAuthorChecks.flair_text.__wrapped__ = old_get_flair
class TestVTab(unittest.TestCase):
def setUp(self):
self.log = Log("testlog.txt")
self.log.add = MagicMock()
self.root = Tk()
self.root.title("kbase test")
self.root.geometry("400x500")
self.dummy = MagicMock()
self.actionlist = {"tabChangeAction": self.dummy}
self.vtab = VTab(parent=self.root,
log=self.log,
actions=self.actionlist)
self.results = None
self.vsearchdrawtemp = VSearch.drawSearchResults
VSearch.drawSearchResults = MagicMock()
self.vsearchremovetemp = VSearch.removeOldResults
VSearch.removeOldResults = MagicMock()
self.entryDrawTemp = VEntry.drawEntry
def tearDown(self):
VEntry.drawEntry = self.entryDrawTemp
VSearch.removeOldResults = self.vsearchremovetemp
VSearch.drawSearchResults = self.vsearchdrawtemp
self.vtab.grid()
self.root.update()
self.root.destroy()
def testTabChangedEvent(self):
'''Tests if right method is called at tab change event'''
# test with overview active
self.vtab.setOverview(dict())
self.vtab.grid()
self.root.update()
self.vtab.focus_force()
self.vtab.event_generate("<<NotebookTabChanged>>")
self.dummy.assert_called_with(self.vtab.overview.name)
# test with search active
self.vtab.setSearch(self.results)
self.vtab.grid()
self.root.update()
self.vtab.focus_force()
self.vtab.event_generate("<<NotebookTabChanged>>")
self.dummy.assert_called_with(self.vtab.vsearch.name)
# test with entry active
e = ModelEntry(self.log, "entry")
self.vtab.addEntry(e)
self.vtab.grid()
self.root.update()
self.vtab.focus_force()
self.vtab.event_generate("<<NotebookTabChanged>>")
self.dummy.assert_called_with(e.name)
def testHasTabs(self):
'''Tests whether hasTabs works correctly'''
self.assertFalse(self.vtab.hasTabs())
self.vtab.setSearch(self.results)
self.assertTrue(self.vtab.hasTabs())
def testSetSearchInitial(self):
'''Tests whether initial search works'''
self.vtab.setSearch(self.results)
# get all tab names. The names also include vtab's name
tabs = self.vtab.tabs()
# gets the full name of vsearch widget
vsearchName = "." + self.vtab._name + "." + self.vtab.vsearch._name
# first tab should be
self.assertEqual(vsearchName, tabs[0])
self.vtab.vsearch.drawSearchResults.assert_called_with(self.results)
self.assertEqual(vsearchName, self.vtab.select(),
"wrong tab is active")
def testSetSearchASecondTime(self):
'''Tests whether a second search overwrites the first one'''
secondResults = None
self.vtab.setSearch(self.results)
self.vtab.setSearch(secondResults)
# get all tab names. The names also include vtab's name
tabs = self.vtab.tabs()
# gets the full name of vsearch widget
vsearchName = "." + self.vtab._name + "." + self.vtab.vsearch._name
# first tab should be
self.assertEqual(vsearchName, tabs[0])
self.vtab.vsearch.removeOldResults.assert_called()
self.vtab.vsearch.drawSearchResults.assert_called_with(secondResults)
self.assertEqual(vsearchName, self.vtab.select(),
"wrong tab is active")
def testAddEntry(self):
'''Tests whether add works'''
e = ModelEntry(self.log, "entry")
self.vtab.addEntry(e)
# get all tab names. The names also include vtab's name
tabs = self.vtab.tabs()
# gets the full name of ventry widget
ventryName = "." + self.vtab._name + "." + self.vtab.ventries[
e.name]._name
# first tab should be
self.assertEqual(ventryName, tabs[0])
self.assertEqual(ventryName, self.vtab.select(), "wrong tab is active")
def testAddExistingEntry(self):
'''Trys to add an already existing entry'''
e1 = ModelEntry(self.log, "e1")
e2 = ModelEntry(self.log, "e2")
self.vtab.addEntry(e1)
self.vtab.addEntry(e2)
self.vtab.addEntry(e1)
self.assertEqual(2, self.vtab.tabs().__len__())
self.assertEqual(2, self.vtab.ventries.__len__())
# check if e1 is active tab
ventryName = "." + self.vtab._name + "." + self.vtab.ventries[
e1.name]._name
self.assertEqual(ventryName, self.vtab.select(), "wrong tab is active")
def testRemoveEntry(self):
'''Removes an existing entry'''
e = ModelEntry(self.log, "entry")
self.vtab.addEntry(e)
self.assertEqual(1, self.vtab.tabs().__len__())
self.assertEqual(1, self.vtab.ventries.__len__())
self.vtab.removeEntry(e)
self.assertEqual(0, self.vtab.tabs().__len__())
self.assertEqual(0, self.vtab.ventries.__len__())
def testRemoveNotExistingEntry(self):
'''Trys to remove a not existing entry'''
e1 = ModelEntry(self.log, "e1")
e2 = ModelEntry(self.log, "e2")
self.vtab.addEntry(e1)
self.vtab.addEntry(e2)
self.assertEqual(2, self.vtab.tabs().__len__())
self.assertEqual(2, self.vtab.ventries.__len__())
self.vtab.removeEntry(e1)
self.assertEqual(1, self.vtab.tabs().__len__())
self.assertEqual(1, self.vtab.ventries.__len__())
# get all tab names. The names also include vtab's name
tabs = self.vtab.tabs()
# gets the full name of ventry widget
ventryName = "." + self.vtab._name + "." + self.vtab.ventries[
e2.name]._name
# first tab should be
self.assertEqual(ventryName, tabs[0])
def testRemoveSearch(self):
self.vtab.setSearch(self.results)
self.assertTrue(self.vtab.vsearchDrawn)
self.assertEqual(1, self.vtab.children.values().__len__())
self.vtab.removeSearch()
self.assertEqual(0, self.vtab.children.values().__len__())
def testGetActiveTabId(self):
exp = "2342342"
inp = "98739457345." + exp
self.vtab.select = MagicMock()
self.vtab.select.return_value = inp
act = self.vtab.getActiveTabId()
self.assertEqual(exp, act)
def testGetNameOfActiveTab(self):
# test overview
self.vtab.setOverview(dict())
self.vtab.grid()
self.vtab.update()
id = self.vtab.getTabId(self.vtab.overview)
self.vtab.select(id)
self.vtab.update()
exp = self.vtab.overview.name
act = self.vtab.getNameOfActiveTab()
self.assertEqual(exp, act)
# test search
self.vtab.setSearch(None)
self.vtab.grid()
self.vtab.update()
id = self.vtab.getTabId(self.vtab.vsearch)
self.vtab.select(id)
self.vtab.update()
exp = self.vtab.vsearch.name
act = self.vtab.getNameOfActiveTab()
self.assertEqual(exp, act)
# test entry
self.vtab.addEntry(ModelEntry(self.log, "blu"))
self.vtab.grid()
self.vtab.update()
id = self.vtab.getTabId(self.vtab.ventries["blu"])
self.vtab.select(id)
self.vtab.update()
exp = self.vtab.ventries["blu"].getName()
act = self.vtab.getNameOfActiveTab()
self.assertEqual(exp, act)
def test_formats_output(self):
for format in self.expected_formats:
mock_f = MagicMock()
setattr(self.of, format, mock_f)
self.of.format_output(self.output_data, format)
mock_f.assert_called_with(self.output_data)
def test_with_empty_args(self):
callback = MagicMock()
cuckoo = Cuckoo(callback=callback)
cuckoo()
callback.assert_called_with()
def test_file_loaded(self, content_mock: mock.MagicMock) -> None:
"""Test file loaded."""
FileLookup.handle("plain:file://tmp/test")
content_mock.assert_called_with("file://tmp/test")
class TestDeleteTagsByAge(unittest.TestCase):
def setUp(self):
self.registry = Registry()
self.registry.http = MockRequests()
self.get_tag_config_mock = MagicMock(
return_value={
'mediaType':
'application/vnd.docker.container.image.v1+json',
'size':
12953,
'digest':
'sha256:8d71dfbf239c0015ad66993d55d3954cee2d52d86f829fdff9ccfb9f23b75aa8'
})
self.registry.get_tag_config = self.get_tag_config_mock
self.get_image_age_mock = MagicMock(
return_value="2017-12-27T12:47:33.511765448Z")
self.registry.get_image_age = self.get_image_age_mock
self.list_tags_mock = MagicMock(return_value=["image"])
self.registry.list_tags = self.list_tags_mock
self.get_tag_digest_mock = MagicMock()
self.registry.get_tag_digest = self.get_tag_digest_mock
self.registry.http = MockRequests()
self.registry.hostname = "http://testdomain.com"
self.registry.http.reset_return_value(200, "MOCK_DIGEST")
@patch('registry.delete_tags')
def test_delete_tags_by_age_no_keep(self, delete_tags_patched):
delete_tags_by_age(self.registry, "imagename", False, 24, [])
self.list_tags_mock.assert_called_with("imagename")
self.list_tags_mock.assert_called_with("imagename")
self.get_tag_config_mock.assert_called_with("imagename", "image")
delete_tags_patched.assert_called_with(self.registry, "imagename",
False, ["image"], [])
@patch('registry.delete_tags')
def test_delete_tags_by_age_keep_tags(self, delete_tags_patched):
delete_tags_by_age(self.registry, "imagename", False, 24, ["latest"])
self.list_tags_mock.assert_called_with("imagename")
self.list_tags_mock.assert_called_with("imagename")
self.get_tag_config_mock.assert_called_with("imagename", "image")
delete_tags_patched.assert_called_with(self.registry, "imagename",
False, ["image"], ["latest"])
@patch('registry.delete_tags')
def test_delete_tags_by_age_dry_run(self, delete_tags_patched):
delete_tags_by_age(self.registry, "imagename", True, 24, ["latest"])
self.list_tags_mock.assert_called_with("imagename")
self.list_tags_mock.assert_called_with("imagename")
self.get_tag_config_mock.assert_called_with("imagename", "image")
delete_tags_patched.assert_called_with(self.registry, "imagename",
True, ["image"], ["latest"])
def test_lambda_handler(ami_pattern, pipeline_override_ami, event_override_ami,
expected_error, exception_message, monkeypatch):
"""Test trigger_build_function.lambda_handler"""
# Setup mock input
soe_image_name = 'plt-baking-soe-ami-for-unit-test'
mock_automation_execution_id = 'mock_automation_execution_id'
ssm_document = 'SSMDocument'
soe_type = 'lnx'
ami_owner = 'self'
# Set Environment Variables
monkeypatch.setenv("SSMDocument", ssm_document)
monkeypatch.setenv("SOEType", soe_type)
monkeypatch.setenv("AMIPattern", ami_pattern)
monkeypatch.setenv("AMIOwner", ami_owner)
monkeypatch.setenv("OverrideAMI", pipeline_override_ami)
# We need to reload the module so it re-reads the os.environ values we set above
reload(trigger_build_function)
# patch trigger_ssm as moto does NOT support start_automation_execution yet
# https://github.com/spulec/moto/blame/603f7c58a230919da3ee836575351366e46cc26c/IMPLEMENTATION_COVERAGE.md#L4022
mock_trigger_ssm = MagicMock(return_value=mock_automation_execution_id)
monkeypatch.setattr('trigger_build.trigger_build_function.trigger_ssm',
mock_trigger_ssm)
if pipeline_override_ami:
ami_id = pipeline_override_ami
else:
# Setup mock Public AMI (we need to create a AMI and modify launch permissions)
# 1. Create a mock SOE image from a instance
ec2_client = boto3.client('ec2', region_name=CONST_REGION)
run_ec2_response = ec2_client.run_instances(ImageId='ami-12345678',
MaxCount=1,
MinCount=1)
instance_id = run_ec2_response['Instances'][0]['InstanceId']
print(instance_id)
create_ami_response = ec2_client.create_image(
Description='Moto unit test image 1',
InstanceId=instance_id,
Name=soe_image_name)
ami_id = create_ami_response['ImageId']
# 2. Make mock SOE image Public
exec_user_id = '123456789012'
# We need to override the EXEC_USERS in the actual module as moto does not support 'all' yet
# https://github.com/spulec/moto/blob/d8dbc6a49ccf969f50ed3f7b52f341db3a7715f0/moto/ec2/models.py#L1190
monkeypatch.setattr('trigger_build.trigger_build_function.EXEC_USERS',
exec_user_id)
modify_image_response = ec2_client.modify_image_attribute(
Attribute='launchPermission',
ImageId=ami_id,
OperationType='add',
UserIds=[exec_user_id],
UserGroups=['all'])
print("modify_image_response")
print(modify_image_response)
# Setup Input
event = {}
context = ContextMock()
if event_override_ami:
event['OverrideAMI'] = event_override_ami
ami_id = event_override_ami
# Test Lambda handler
if isinstance(expected_error, type):
with pytest.raises(expected_error) as excinfo:
trigger_build_function.lambda_handler(event, context)
#TODO: Improve the error handling in the lambda_handler
assert exception_message in str(excinfo.value)
mock_trigger_ssm.assert_not_called()
else:
output_event = trigger_build_function.lambda_handler(
copy.deepcopy(event), context)
print("output_event")
print(output_event)
# Verify the output
assert output_event != event # Assert that the event has been modified
assert output_event[
"BuildAutomationExecutionId"] == mock_automation_execution_id
mock_trigger_ssm.assert_called_with(CONST_SOL_NAMING, CONST_REGION,
ssm_document, soe_type, ami_id)
def test_should_calls_load_account_by_id_correct_values(
mock_load: MagicMock, sut: AuthMiddleware):
sut.handle(HttpRequest(headers={"x-access-token": "any_token"}, body=None))
mock_load.assert_called_with(access_token="any_token", role=None)
class TestClient(unittest.TestCase):
def setUp(self):
self.api_key = 'heythere'
self.api_url = taxjar.DEFAULT_API_URL + "/" + taxjar.API_VERSION + "/"
self.headers = {"Authorization": "Bearer heythere"}
self.responder_mock = MagicMock()
self.client = taxjar.Client(api_key=self.api_key, options={}, responder=self.responder_mock)
def test_client_params(self):
self.client = taxjar.Client(api_key=self.api_key, api_url='https://api.sandbox.taxjar.com', options={
'headers': {
'X-TJ-Expected-Response': '422'
}
}, responder=self.responder_mock)
self.assertEqual(self.client.api_url, 'https://api.sandbox.taxjar.com/v2/')
self.assertEqual(self.client.headers, { 'X-TJ-Expected-Response': '422' })
def test_set_api_config(self):
self.client.set_api_config('api_url', 'https://api.sandbox.taxjar.com')
self.assertEqual(self.client.api_url, 'https://api.sandbox.taxjar.com/v2/')
def test_get_api_config(self):
self.client.set_api_config('api_url', 'https://api.sandbox.taxjar.com')
self.assertEqual(self.client.get_api_config('api_url'), self.client.api_url)
def test_custom_headers(self):
self.client.set_api_config('headers', {
'X-TJ-Expected-Response': '422'
})
self.assertEqual(self.client.headers, {
'X-TJ-Expected-Response': '422'
})
self.assertEqual(self.client._headers()['X-TJ-Expected-Response'], '422')
self.assertEqual(self.client._headers()['Authorization'], 'Bearer heythere')
self.assertRegexpMatches(self.client._headers()['User-Agent'], re.compile('TaxJar/Python \\(.+\\) taxjar-python/\\d+\\.\\d+\\.\\d+'))
def test_rates_for_location(self):
action = lambda _: self.client.rates_for_location('90210')
self.assert_request_occurred(action, 'get', 'rates/90210', {})
def test_rates_for_location_with_deets(self):
action = lambda _: self.client.rates_for_location('90210', {
'city': 'Beverly Hills',
'country': 'US'
})
self.assert_request_occurred(action, 'get', 'rates/90210', {
'city': 'Beverly Hills',
'country': 'US'
})
def test_categories(self):
action = lambda _: self.client.categories()
self.assert_request_occurred(action, 'get', 'categories', {})
def test_tax_for_order(self):
data = {'shipping': 0}
action = lambda _: self.client.tax_for_order(data)
self.assert_request_occurred(action, 'post', 'taxes', data)
def test_list_orders(self):
data = {'dummy': 'data'}
action = lambda _: self.client.list_orders(data)
self.assert_request_occurred(action, 'get', 'transactions/orders', data)
action = lambda _: self.client.list_orders()
self.assert_request_occurred(action, 'get', 'transactions/orders', {})
def test_show_order(self):
action = lambda _: self.client.show_order('1001')
self.assert_request_occurred(action, 'get', 'transactions/orders/1001', {})
action = lambda _: self.client.show_order('1001', {'provider': 'api'})
self.assert_request_occurred(action, 'get', 'transactions/orders/1001', {
'provider': 'api'
})
def test_create_order(self):
data = {'dummy': 'data'}
action = lambda _: self.client.create_order(data)
self.assert_request_occurred(action, 'post', 'transactions/orders', data)
def test_update_order(self):
data = {'dummy': 'data'}
action = lambda _: self.client.update_order(1, data)
self.assert_request_occurred(action, 'put', 'transactions/orders/1', data)
def test_delete_order(self):
action = lambda _: self.client.delete_order(1)
self.assert_request_occurred(action, 'delete', 'transactions/orders/1', {})
action = lambda _: self.client.delete_order(1, {'provider': 'api'})
self.assert_request_occurred(action, 'delete', 'transactions/orders/1', {
'provider': 'api'
})
def test_list_refunds(self):
data = {'from_transaction_date': '2016/01/01', 'to_transaction_date': '2017/01/01'}
action = lambda _: self.client.list_refunds(data)
self.assert_request_occurred(action, 'get', 'transactions/refunds', data)
action = lambda _: self.client.list_refunds()
self.assert_request_occurred(action, 'get', 'transactions/refunds', {})
def test_show_refund(self):
action = lambda _: self.client.show_refund('1001')
self.assert_request_occurred(action, 'get', 'transactions/refunds/1001', {})
action = lambda _: self.client.show_refund('1001', {'provider': 'api'})
self.assert_request_occurred(action, 'get', 'transactions/refunds/1001', {
'provider': 'api'
})
def test_create_refund(self):
data = {'dummy': 'data'}
action = lambda _: self.client.create_refund(data)
self.assert_request_occurred(action, 'post', 'transactions/refunds', data)
def test_update_refund(self):
data = {'dummy': 'data'}
action = lambda _: self.client.update_refund(1, data)
self.assert_request_occurred(action, 'put', 'transactions/refunds/1', data)
def test_delete_refund(self):
action = lambda _: self.client.delete_refund(1)
self.assert_request_occurred(action, 'delete', 'transactions/refunds/1', {})
action = lambda _: self.client.delete_refund(1, {'provider': 'api'})
self.assert_request_occurred(action, 'delete', 'transactions/refunds/1', {
'provider': 'api'
})
def test_list_customers(self):
action = lambda _: self.client.list_customers()
self.assert_request_occurred(action, 'get', 'customers', {})
def test_show_customer(self):
action = lambda _: self.client.show_customer('123')
self.assert_request_occurred(action, 'get', 'customers/123', {})
def test_create_customer(self):
data = {'dummy': 'data'}
action = lambda _: self.client.create_customer(data)
self.assert_request_occurred(action, 'post', 'customers', data)
def test_update_customer(self):
data = {'dummy': 'data'}
action = lambda _: self.client.update_customer('123', data)
self.assert_request_occurred(action, 'put', 'customers/123', data)
def test_delete_customer(self):
action = lambda _: self.client.delete_customer('123')
self.assert_request_occurred(action, 'delete', 'customers/123', {})
def test_nexus_regions(self):
action = lambda _: self.client.nexus_regions()
self.assert_request_occurred(action, 'get', 'nexus/regions', {})
def test_validate_address(self):
data = {'country': 'US', 'state': 'AZ', 'zip': '85297', 'city': 'Gilbert', 'street': '3301 South Greenfield Rd'}
action = lambda _: self.client.validate_address(data)
self.assert_request_occurred(action, 'post', 'addresses/validate', data)
def test_validate(self):
action = lambda _: self.client.validate({'vat': '1234'})
self.assert_request_occurred(action, 'get', 'validation', {'vat': '1234'})
def test_summary_rates(self):
action = lambda _: self.client.summary_rates()
self.assert_request_occurred(action, 'get', 'summary_rates', {})
def assert_request_occurred(self, action, request_method, uri, params):
url = self.api_url + uri
with patch.object(requests, request_method) as request_mock:
action(0)
request_mock.assert_called_with(
url,
headers=self.client._headers(),
**self._request_args(request_method, params)
)
self.responder_mock.assert_called_with(request_mock.return_value)
def _request_args(self, method, params):
args = {'timeout': 5}
if method == 'get' or method == 'delete':
args['params'] = params
else:
args['json'] = params
return args
class TestReverseEngineerDDL(BaseTestGenerator):
scenarios = [
('#execute When retriving the DDL for the creation of external '
'tables, '
'it retrieves information of the columns and the tables '
'and generate the SQL to create the table',
dict(test_type='execute',
function_parameters=dict(table_oid=14),
find_columns_return_value=dict(somevalue='value'),
table_information_return_value=dict(someother='bamm'),
expect_find_columns_called_with=14,
expect_table_information_called_with=14,
expect_render_template_called_with=dict(
template_name_or_list='sql/#gpdb#80323#/create.sql',
table=dict(someother='bamm',
columns=dict(somevalue='value'))))),
('#find_columns When an external table exists, '
'and have 3 columns, '
'it returns a list with 1 object that as the table name to inherit '
'from',
dict(
test_type='find_columns',
function_parameters={'table_oid': 123},
execute_2darray_return_value=(True,
dict(rows=[{
'name': 'column_1',
'cltype': 'text',
'inheritedFrom': 'other_table',
'inheritedid': '1234',
}, {
'name': 'column_2',
'cltype': 'int',
'inheritedFrom': 'other_table',
'inheritedid': '1234',
}, {
'name': 'column_3',
'cltype': 'numeric',
'inheritedFrom': 'other_table',
'inheritedid': '1234',
}])),
expect_render_template_called_with=dict(
template_name_or_list='sql/#gpdb#80323#/get_columns.sql',
table_oid=123),
expected_result=[
{
'name': 'column_1',
'type': 'text'
},
{
'name': 'column_2',
'type': 'int'
},
{
'name': 'column_3',
'type': 'numeric'
},
],
)),
('#find_columns When error happens while retrieving '
'column information, '
'it raise an exception',
dict(
test_type='find_columns',
function_parameters={'table_oid': 123},
execute_2darray_return_value=(False, 'Some error message'),
expect_render_template_called_with=dict(
template_name_or_list='sql/#gpdb#80323#/get_columns.sql',
table_oid=123),
expected_exception=ReverseEngineerDDLException(
'Some error message'),
)),
('#table_information When error happens while retrieving '
'table generic information, '
'it raise an exception',
dict(
test_type='table_information',
function_parameters={'table_oid': 123},
execute_2darray_return_value=(False, 'Some error message'),
expect_render_template_called_with=dict(
template_name_or_list='sql/#gpdb#80323#/'
'get_table_information.sql',
table_oid=123),
expected_exception=ReverseEngineerDDLException(
'Some error message'),
)),
('#table_information When cannot find the table, '
'it raise an exception',
dict(
test_type='table_information',
function_parameters={'table_oid': 123},
execute_2darray_return_value=(True, {
'rows': []
}),
expect_render_template_called_with=dict(
template_name_or_list='sql/#gpdb#80323#/'
'get_table_information.sql',
table_oid=123),
expected_exception=ReverseEngineerDDLException('Table not found'),
)),
('#table_information When retrieving generic information '
'about a Web table, '
'it returns the table information',
dict(
test_type='table_information',
function_parameters={'table_oid': 123},
execute_2darray_return_value=(
True,
dict(rows=[{
'urilocation': '{http://someurl.com}',
'execlocation': ['ALL_SEGMENTS'],
'fmttype': 'a',
'fmtopts': 'delimiter \',\' null \'\' '
'escape \'"\' quote \'"\'',
'command': None,
'rejectlimit': None,
'rejectlimittype': None,
'errtblname': None,
'errortofile': None,
'pg_encoding_to_char': 'UTF8',
'writable': False,
'options': None,
'distribution': None,
'name': 'some_table',
'namespace': 'public'
}])),
expect_render_template_called_with=dict(
template_name_or_list='sql/#gpdb#80323#/'
'get_table_information.sql',
table_oid=123),
expected_result={
'uris': ['http://someurl.com'],
'isWeb': True,
'executionLocation': dict(type='all_segments', value=None),
'formatType': 'avro',
'formatOptions': 'delimiter = $$,$$,escape = $$"$$,'
'null = $$$$,quote = $$"$$',
'command': None,
'rejectLimit': None,
'rejectLimitType': None,
'errorTableName': None,
'erroToFile': None,
'pgEncodingToChar': 'UTF8',
'writable': False,
'options': None,
'distribution': None,
'name': 'some_table',
'namespace': 'public'
},
)),
]
def __init__(self, *args, **kwargs):
super(TestReverseEngineerDDL, self).__init__(*args, **kwargs)
self.connection = None
self.subject = None
self.render_template_mock = None
def runTest(self):
self.render_template_mock = MagicMock()
self.connection = MagicMock(execute_2darray=MagicMock())
if hasattr(self, 'execute_2darray_return_value'):
self.connection.execute_2darray.return_value = \
self.execute_2darray_return_value
self.subject = ReverseEngineerDDL('sql/#gpdb#80323#/',
self.render_template_mock,
self.connection, 1, 2, 3)
if self.test_type == 'find_columns':
self.__test_find_columns()
elif self.test_type == 'table_information':
self.__test_table_information()
elif self.test_type == 'execute':
self.__test_execute()
def __test_find_columns(self):
if hasattr(self, 'expected_exception'):
try:
self.subject.find_columns(**self.function_parameters)
self.fail('Exception not raise')
except ReverseEngineerDDLException as exception:
self.assertEqual(str(exception), str(self.expected_exception))
else:
result = self.subject.find_columns(**self.function_parameters)
self.assertEqual(self.expected_result, result)
self.render_template_mock.assert_called_with(
**self.expect_render_template_called_with)
def __test_table_information(self):
if hasattr(self, 'expected_exception'):
try:
self.subject.table_information(**self.function_parameters)
self.fail('Exception not raise')
except ReverseEngineerDDLException as exception:
self.assertEqual(str(exception), str(self.expected_exception))
else:
result = self.subject.table_information(**self.function_parameters)
self.assertEqual(self.expected_result, result)
self.render_template_mock.assert_called_with(
**self.expect_render_template_called_with)
def __test_execute(self):
self.subject.find_columns = MagicMock(
return_value=self.find_columns_return_value)
self.subject.table_information = MagicMock(
return_value=self.table_information_return_value)
self.subject.execute(**self.function_parameters)
self.subject.find_columns.assert_called_with(
self.expect_find_columns_called_with)
self.subject.table_information.assert_called_with(
self.expect_table_information_called_with)
self.render_template_mock.assert_called_with(
**self.expect_render_template_called_with)
def test_callback_with_mixed_args_and_kwargs(self):
callback = MagicMock()
cuckoo = Cuckoo(callback=callback)
cuckoo(1, 2, c=3, d=4)
callback.assert_called_with(1, 2, c=3, d=4)
class SessionAwareSemaphoreMockTest(unittest.TestCase):
def setUp(self):
self.acquire_session = MagicMock()
self.release_session = MagicMock()
self.invalidate_session = MagicMock()
self.session_manager = MagicMock(
acquire_session=self.acquire_session,
release_session=self.release_session,
invalidate_session=self.invalidate_session,
)
context = MagicMock(proxy_session_manager=self.session_manager)
self.group_id = RaftGroupId("test", 0, 42)
self.semaphore = SessionAwareSemaphore(
context, self.group_id, SEMAPHORE_SERVICE, "semaphore@mygroup", "semaphore"
).blocking()
def test_acquire(self):
# Everything works
self.prepare_acquire_session(1)
self.mock_request_acquire(True)
self.assertIsNone(self.semaphore.acquire())
self.assert_call_counts(1, 0, 0)
self.assert_acquire_count(1)
def test_acquire_when_acquire_session_fails(self):
# First call to acquire session fails, should not retry
self.prepare_acquire_session(-1, HazelcastRuntimeError())
with self.assertRaises(HazelcastRuntimeError):
self.semaphore.acquire()
self.assert_call_counts(1, 0, 0)
self.assert_acquire_count(1)
def test_acquire_on_session_expired_error(self):
# Session expired error comes from the server on acquire request,
# retries and succeeds
self.prepare_acquire_session(1)
self.mock_request_acquire(True, SessionExpiredError())
self.assertIsNone(self.semaphore.acquire())
self.assert_call_counts(2, 0, 1)
self.assert_acquire_count(1)
def test_acquire_on_wait_key_cancelled_error(self):
# Wait key cancelled error comes from the server, should not retry
self.prepare_acquire_session(12)
self.mock_request_acquire(True, WaitKeyCancelledError())
with self.assertRaises(IllegalStateError):
self.semaphore.acquire()
self.assert_call_counts(1, 1, 0)
self.assert_acquire_count(1)
self.assert_release_count(12, 1)
def test_acquire_on_unspecified_error(self):
# Server sends another error, should not retry
self.prepare_acquire_session(123)
self.mock_request_acquire(False, HazelcastRuntimeError())
with self.assertRaises(HazelcastRuntimeError):
self.semaphore.acquire(15)
self.assert_call_counts(1, 1, 0)
self.assert_acquire_count(15)
self.assert_release_count(123, 15)
def test_drain(self):
# Everything works
self.prepare_acquire_session(42)
self.mock_request_drain(10)
self.assertEqual(10, self.semaphore.drain_permits())
self.assert_call_counts(1, 1, 0)
self.assert_acquire_count(DRAIN_SESSION_ACQ_COUNT)
self.assert_release_count(42, DRAIN_SESSION_ACQ_COUNT - 10)
def test_drain_when_acquire_session_fails(self):
# First call to acquire session fails, should not retry
self.prepare_acquire_session(-1, HazelcastRuntimeError())
with self.assertRaises(HazelcastRuntimeError):
self.semaphore.drain_permits()
self.assert_call_counts(1, 0, 0)
self.assert_acquire_count(DRAIN_SESSION_ACQ_COUNT)
def test_drain_on_session_expired_error(self):
# Session expired error comes from the server on drain request,
# retries and succeeds
self.prepare_acquire_session(99)
self.mock_request_drain(101, SessionExpiredError())
self.assertEqual(101, self.semaphore.drain_permits())
self.assert_call_counts(2, 1, 1)
self.assert_acquire_count(DRAIN_SESSION_ACQ_COUNT)
self.assert_release_count(99, DRAIN_SESSION_ACQ_COUNT - 101)
def test_drain_on_unspecified_error(self):
# Server sends another error, should not retry
self.prepare_acquire_session(123)
self.mock_request_drain(False, HazelcastRuntimeError())
with self.assertRaises(HazelcastRuntimeError):
self.semaphore.drain_permits()
self.assert_call_counts(1, 1, 0)
self.assert_acquire_count(DRAIN_SESSION_ACQ_COUNT)
self.assert_release_count(123, DRAIN_SESSION_ACQ_COUNT)
def test_reduce_permits(self):
# Everything works
self.prepare_acquire_session(42)
self.mock_request_change()
self.assertIsNone(self.semaphore.reduce_permits(15))
self.assert_call_counts(1, 1, 0)
self.assert_acquire_count(1)
self.assert_release_count(42, 1)
def test_reduce_permits_when_acquire_session_fails(self):
# First call to acquire session fails, should not retry
self.prepare_acquire_session(-1, HazelcastRuntimeError())
with self.assertRaises(HazelcastRuntimeError):
self.semaphore.reduce_permits(12)
self.assert_call_counts(1, 0, 0)
self.assert_acquire_count(1)
def test_reduce_permits_on_session_expired_error(self):
# Session expired error comes from the server on change request
self.prepare_acquire_session(99)
self.mock_request_change(SessionExpiredError())
with self.assertRaises(IllegalStateError):
self.semaphore.reduce_permits(123)
self.assert_call_counts(1, 1, 1)
# Session will be invalidated before released, so release call is actually a no-op
self.assert_acquire_count(1)
self.assert_release_count(99, 1)
def test_reduce_permits_on_unspecified_error(self):
# Server sends another error
self.prepare_acquire_session(1123)
self.mock_request_change(HazelcastRuntimeError())
with self.assertRaises(HazelcastRuntimeError):
self.semaphore.reduce_permits(54)
self.assert_call_counts(1, 1, 0)
self.assert_acquire_count(1)
self.assert_release_count(1123, 1)
def test_increase_permits(self):
# Everything works
self.prepare_acquire_session(42)
self.mock_request_change()
self.assertIsNone(self.semaphore.increase_permits(15))
self.assert_call_counts(1, 1, 0)
self.assert_acquire_count(1)
self.assert_release_count(42, 1)
def test_increase_permits_when_acquire_session_fails(self):
# First call to acquire session fails, should not retry
self.prepare_acquire_session(-1, HazelcastRuntimeError())
with self.assertRaises(HazelcastRuntimeError):
self.semaphore.increase_permits(12)
self.assert_call_counts(1, 0, 0)
self.assert_acquire_count(1)
def test_increase_permits_on_session_expired_error(self):
# Session expired error comes from the server on change request
self.prepare_acquire_session(99)
self.mock_request_change(SessionExpiredError())
with self.assertRaises(IllegalStateError):
self.semaphore.increase_permits(123)
self.assert_call_counts(1, 1, 1)
# Session will be invalidated before released, so release call is actually a no-op
self.assert_acquire_count(1)
self.assert_release_count(99, 1)
def test_increase_permits_on_unspecified_error(self):
# Server sends another error
self.prepare_acquire_session(1123)
self.mock_request_change(HazelcastRuntimeError())
with self.assertRaises(HazelcastRuntimeError):
self.semaphore.increase_permits(54)
self.assert_call_counts(1, 1, 0)
self.assert_acquire_count(1)
self.assert_release_count(1123, 1)
def test_release(self):
# Everything works
self.prepare_get_session(42)
self.mock_request_release()
self.assertIsNone(self.semaphore.release(15))
self.assert_call_counts(0, 1, 0)
self.assert_release_count(42, 15)
def test_release_no_session(self):
# No session found for the release request on the client.
self.prepare_get_session(-1)
with self.assertRaises(IllegalStateError):
self.semaphore.release()
self.assert_call_counts(0, 0, 0)
def test_release_on_session_expired_error(self):
# Session expired error comes from the server on release request,
self.prepare_get_session(99)
self.mock_request_release(SessionExpiredError())
with self.assertRaises(IllegalStateError):
self.semaphore.release(123)
self.assert_call_counts(0, 1, 1)
# Session will be invalidated before released, so release call is actually a no-op
self.assert_release_count(99, 123)
def test_release_on_unspecified_error(self):
# Server sends another error
self.prepare_get_session(1123)
self.mock_request_release(HazelcastRuntimeError())
with self.assertRaises(HazelcastRuntimeError):
self.semaphore.release(54)
self.assert_call_counts(0, 1, 0)
self.assert_release_count(1123, 54)
def test_try_acquire(self):
# Everything works
self.prepare_acquire_session(1)
self.mock_request_acquire(True)
self.assertTrue(self.semaphore.try_acquire(15))
self.assert_call_counts(1, 0, 0)
self.assert_acquire_count(15)
def test_try_acquire_when_acquire_session_fails(self):
# First call to acquire session fails, should not retry
self.prepare_acquire_session(-1, HazelcastRuntimeError())
with self.assertRaises(HazelcastRuntimeError):
self.semaphore.try_acquire()
self.assert_call_counts(1, 0, 0)
self.assert_acquire_count(1)
def test_try_acquire_on_session_expired_error(self):
# Session expired error comes from the server on acquire request,
# determines the timeout
self.prepare_acquire_session(1)
self.mock_request_acquire(True, SessionExpiredError())
self.assertFalse(self.semaphore.try_acquire())
self.assert_call_counts(1, 0, 1)
self.assert_acquire_count(1)
def test_try_acquire_on_session_expired_error_when_not_timed_out(self):
# Session expired error comes from the server on acquire request,
# retries and succeeds
self.prepare_acquire_session(123)
self.mock_request_acquire(True, SessionExpiredError())
self.assertTrue(self.semaphore.try_acquire(15, 3))
self.assert_call_counts(2, 0, 1)
self.assert_acquire_count(15)
def test_try_acquire_on_wait_key_cancelled_error(self):
# Wait key cancelled error comes from the server, should not retry
self.prepare_acquire_session(12)
self.mock_request_acquire(True, WaitKeyCancelledError())
self.assertFalse(self.semaphore.try_acquire())
self.assert_call_counts(1, 1, 0)
self.assert_acquire_count(1)
self.assert_release_count(12, 1)
def test_try_acquire_on_unspecified_error(self):
# Server sends another error, should not retry
self.prepare_acquire_session(123)
self.mock_request_acquire(False, HazelcastRuntimeError())
with self.assertRaises(HazelcastRuntimeError):
self.semaphore.try_acquire()
self.assert_call_counts(1, 1, 0)
self.assert_acquire_count(1)
self.assert_release_count(123, 1)
def assert_call_counts(self, acquire, release, invalidate):
self.assertEqual(acquire, self.acquire_session.call_count)
self.assertEqual(release, self.release_session.call_count)
self.assertEqual(invalidate, self.invalidate_session.call_count)
def assert_acquire_count(self, count):
self.acquire_session.assert_called_with(self.group_id, count)
def assert_release_count(self, session_id, count):
self.release_session.assert_called_with(self.group_id, session_id, count)
def prepare_acquire_session(self, session_id, err=None):
if err:
val = ImmediateExceptionFuture(err)
else:
val = ImmediateFuture(session_id)
acquire_mock = MagicMock(return_value=val)
release_mock = MagicMock()
invalidate_mock = MagicMock()
self.session_manager.acquire_session = acquire_mock
self.session_manager.release_session = release_mock
self.session_manager.invalidate_session = invalidate_mock
self.acquire_session = acquire_mock
self.release_session = release_mock
self.invalidate_session = invalidate_mock
def prepare_get_session(self, session_id):
self.session_manager.get_session_id = MagicMock(return_value=session_id)
def mock_request_acquire(self, acquired, first_call_err=None):
mock_request(self.semaphore, "_request_acquire", acquired, first_call_err)
def mock_request_drain(self, count, first_call_err=None):
mock_request(self.semaphore, "_request_drain", count, first_call_err)
def mock_request_change(self, first_call_err=None):
mock_request(self.semaphore, "_request_change", None, first_call_err)
def mock_request_release(self, first_call_err=None):
mock_request(self.semaphore, "_request_release", None, first_call_err)
def test_callback_with_multiple_args(self):
callback = MagicMock()
cuckoo = Cuckoo(callback=callback)
cuckoo(1, 2, 3)
callback.assert_called_with(1, 2, 3)
def test_opsgenie_notification(monkeypatch, is_alert, priority, override_description):
post = MagicMock()
monkeypatch.setattr('requests.post', post)
alert = {
'alert_changed': True, 'changed': True, 'is_alert': is_alert, 'entity': {'id': 'e-1'}, 'worker': 'worker-1',
'alert_evaluation_ts': 1234,
'alert_def': {
'name': 'Alert',
'team': 'zmon',
'responsible_team': 'zmon',
'id': 123,
'priority': 1,
}
}
NotifyOpsgenie._config = {'notifications.opsgenie.apikey': API_KEY}
kwargs = {}
if priority:
kwargs['priority'] = priority
else:
priority = 'P1'
if override_description:
r = NotifyOpsgenie.notify(
alert,
message=MESSAGE,
include_alert=False,
teams=['team-1', 'team-2'],
description=override_description,
**kwargs
)
else:
r = NotifyOpsgenie.notify(
alert,
message=MESSAGE,
include_alert=False,
teams=['team-1', 'team-2'],
**kwargs
)
params = {}
if is_alert:
data = {
'alias': 'ZMON-123',
'message': '[zmon] - {}'.format(MESSAGE),
'description': '',
'entity': 'e-1',
'priority': priority,
'tags': [],
'teams': [{'name': 'team-1'}, {'name': 'team-2'}],
'source': 'worker-1',
'note': '',
'details': {'alert_evaluation_ts': 1234},
}
if override_description:
data['description'] = override_description
else:
data = {
'user': '******',
'source': 'worker-1',
'note': '',
}
params = {'identifierType': 'alias'}
assert r == 0
URL = URL_CREATE if is_alert else URL_CLOSE.format('ZMON-123')
post.assert_called_with(URL, data=json.dumps(data, cls=JsonDataEncoder, sort_keys=True), headers=HEADERS, timeout=5,
params=params)
def test_nested_simple(self):
np1_sub1 = MagicMock()
np1_sub2 = MagicMock()
np2_sub1 = MagicMock()
p = Publisher()
np1 = Publisher()
np2 = Publisher()
np1_subs = p.subscribe(np1, start=False)
np2_subs = p.subscribe(np2, start=False)
self.assertEqual(p.active, False)
self.assertEqual(np1.active, False)
self.assertEqual(np2.active, False)
#subscribe to np1
np1.subscribe(np1_sub1, start=False)
np1.subscribe(np1_sub2, start=False)
self.assertEqual(p.active, False)
self.assertEqual(np1.active, False)
self.assertEqual(np2.active, False)
np1_sub1_subs = np1.subscribe(np1_sub1)
self.assertEqual(p.active, True)
self.assertEqual(np1.active, True)
self.assertEqual(np2.active, False)
np1_sub2_subs = np1.subscribe(np1_sub2)
self.assertEqual(p.active, True)
self.assertEqual(np1.active, True)
self.assertEqual(np2.active, False)
#send message to p
p.send(1)
np1_sub1.assert_called_with(1)
np1_sub2.assert_called_with(1)
self.assertEqual(np2_sub1.call_count, 0)
#subscribe to np2
np2_sub1_subs = np2.subscribe(np2_sub1)
self.assertEqual(p.active, True)
self.assertEqual(np1.active, True)
self.assertEqual(np2.active, True)
#send message to p
p.send(2)
np1_sub1.assert_called_with(2)
np1_sub2.assert_called_with(2)
np2_sub1.assert_called_with(2)
self.assertEqual(np1_sub1.call_count, 2)
self.assertEqual(np1_sub2.call_count, 2)
self.assertEqual(np2_sub1.call_count, 1)
#unsubscribe to np2
np2_sub1_subs.stop()
self.assertEqual(p.active, True)
self.assertEqual(np1.active, True)
self.assertEqual(np2.active, False)
#send message to p
p.send(3)
np1_sub1.assert_called_with(3)
np1_sub2.assert_called_with(3)
np2_sub1.assert_called_with(2)
self.assertEqual(np1_sub1.call_count, 3)
self.assertEqual(np1_sub2.call_count, 3)
self.assertEqual(np2_sub1.call_count, 1)
#unsubscribe to np1_sub2
np1_sub2_subs.stop()
self.assertEqual(p.active, True)
self.assertEqual(np1.active, True)
self.assertEqual(np2.active, False)
#send message to p
p.send(4)
np1_sub1.assert_called_with(4)
np1_sub2.assert_called_with(3)
np2_sub1.assert_called_with(2)
self.assertEqual(np1_sub1.call_count, 4)
self.assertEqual(np1_sub2.call_count, 3)
self.assertEqual(np2_sub1.call_count, 1)
#unsubscribe to np1_sub1
np1_sub1_subs.stop()
self.assertEqual(p.active, False)
self.assertEqual(np1.active, False)
self.assertEqual(np2.active, False)
#send message to p
p.send(5)
np1_sub1.assert_called_with(4)
np1_sub2.assert_called_with(3)
np2_sub1.assert_called_with(2)
self.assertEqual(np1_sub1.call_count, 4)
self.assertEqual(np1_sub2.call_count, 3)
self.assertEqual(np2_sub1.call_count, 1)
class TestVSearch(unittest.TestCase):
def setUp(self):
self.log = Log("testlog.txt")
self.log.add = MagicMock()
self.root = Tk()
self.root.title("kbase test")
self.root.geometry("400x500")
self.dummy = MagicMock()
self.actionlist = {"showEntryAction": self.dummy}
self.vsearch = VSearch(self.root, self.log, self.actionlist)
self.e1 = ModelEntry(self.log, "e1")
self.e2 = ModelEntry(self.log, "e2")
self.e3 = ModelEntry(self.log, "e3")
self.e4 = ModelEntry(self.log, "e4")
self.results = {
"name": [self.e1],
"tag": [self.e2],
"description": [self.e3, self.e4]
}
def tearDown(self):
self.vsearch.grid()
self.root.update()
self.root.destroy()
def testRemoveOldResults(self):
'''Tests whether the remove method removes entire content'''
self.vsearch.drawSearchResults(self.results)
n = self.vsearch.children.__len__()
self.assertGreater(n, 0)
self.vsearch.removeOldResults()
n = self.vsearch.children.__len__()
self.assertEqual(0, n)
def testDrawSearchResults(self):
'''Tests whether all buttons are drawn'''
self.vsearch.drawSearchResults(self.results)
self.assertEqual(self.e1.name, self.vsearch.buttonName[0]["text"])
self.assertEqual(self.e2.name, self.vsearch.buttonTag[0]["text"])
self.assertEqual(self.e3.name,
self.vsearch.buttonDescription[0]["text"])
self.assertEqual(self.e4.name,
self.vsearch.buttonDescription[1]["text"])
def testButtonClicked(self):
'''Tests whether the right buttons are clicked'''
self.vsearch.drawSearchResults(self.results)
self.vsearch.grid()
self.root.update()
# by name
self.vsearch.buttonName[0].focus_force()
self.vsearch.buttonName[0].invoke()
self.dummy.assert_called_with(self.e1.name)
# by tag
self.vsearch.buttonTag[0].focus_force()
self.vsearch.buttonTag[0].invoke()
self.dummy.assert_called_with(self.e2.name)
# by description
self.vsearch.buttonDescription[1].focus_force()
self.vsearch.buttonDescription[1].invoke()
self.dummy.assert_called_with(self.e4.name)
def test_should_call_load_by_survey_id_on_load_survey_result_repo_correct_values(
load_by_survey_id: MagicMock, sut: DbLoadSurveyResult):
sut.load("any_survey_id")
load_by_survey_id.assert_called_with("any_survey_id")
def test_simple(self):
c1_sub1 = MagicMock()
c1_sub2 = MagicMock()
c2_sub1 = MagicMock()
p = MultitopicPublisher()
self.assertEqual(p.active, False)
#send messages to random topics
p.send(9, "c1")
p.send(9, "c2")
p.send(9, "something")
p.send(9, "mytopic")
#subscribe to c1
c1_sub1_subs = p.subscribe(c1_sub1, "c1")
self.assertEqual(p.active, True)
c1_sub2_subs = p.subscribe(c1_sub2, "c1")
#send message to c1
p.send(1, "c1")
c1_sub1.assert_called_with(1)
c1_sub2.assert_called_with(1)
self.assertEqual(c2_sub1.call_count, 0)
#subscribe to c2
c2_sub1_subs = p.subscribe(c2_sub1, "c2")
#send message to c2
p.send(2, "c2")
c1_sub1.assert_called_with(1)
c1_sub2.assert_called_with(1)
c2_sub1.assert_called_with(2)
self.assertEqual(c1_sub1.call_count, 1)
self.assertEqual(c1_sub2.call_count, 1)
self.assertEqual(c2_sub1.call_count, 1)
#unsubscribe to c2
c2_sub1_subs.stop()
self.assertEqual(p.active, True)
#send message to c2
p.send(3, "c2")
c1_sub1.assert_called_with(1)
c1_sub2.assert_called_with(1)
c2_sub1.assert_called_with(2)
self.assertEqual(c1_sub1.call_count, 1)
self.assertEqual(c1_sub2.call_count, 1)
self.assertEqual(c2_sub1.call_count, 1)
#unsubscribe to c1_sub2
c1_sub2_subs.stop()
self.assertEqual(p.active, True)
#send message to c1
p.send(4, "c1")
c1_sub1.assert_called_with(4)
c1_sub2.assert_called_with(1)
c2_sub1.assert_called_with(2)
self.assertEqual(c1_sub1.call_count, 2)
self.assertEqual(c1_sub2.call_count, 1)
self.assertEqual(c2_sub1.call_count, 1)
#unsubscribe to c1_sub1
c1_sub1_subs.stop()
self.assertEqual(p.active, False)
#send message to c1
p.send(5, "c1")
c1_sub1.assert_called_with(4)
c1_sub2.assert_called_with(1)
c2_sub1.assert_called_with(2)
self.assertEqual(c1_sub1.call_count, 2)
self.assertEqual(c1_sub2.call_count, 1)
self.assertEqual(c2_sub1.call_count, 1)
self.assertEqual(p.active, False)
def test_callback(self):
callback = MagicMock()
message = 'a'
cuckoo = Cuckoo(callback=callback)
cuckoo(message)
callback.assert_called_with(message)
def test_should_call_hash_with_correct_values(mock_hashpw: MagicMock,
sut: BcryptAdapter):
value = "any_value"
sut.hash(value)
mock_hashpw.assert_called_with(value.encode("utf-8"), SALT)
def test_all_channels_send(self):
c1_sub = MagicMock()
c2_sub = MagicMock()
all_sub = MagicMock()
p = MultitopicPublisher()
#subscribe
c1_sub_subs = p.subscribe(c1_sub, "c1")
c2_sub_subs = p.subscribe(c2_sub, "c2")
all_sub_subs = p.subscribe(all_sub, MultitopicPublisher.ALL_TOPICS)
#send message to ALL_TOPICS
p.send(1,MultitopicPublisher.ALL_TOPICS)
c1_sub.assert_called_with(1)
c2_sub.assert_called_with(1)
all_sub.assert_called_with(1)
self.assertEqual(c1_sub.call_count, 1)
self.assertEqual(c2_sub.call_count, 1)
self.assertEqual(all_sub.call_count, 1)
#send message to ALL_TOPICS
p.send(2, MultitopicPublisher.ALL_TOPICS)
c1_sub.assert_called_with(2)
c2_sub.assert_called_with(2)
all_sub.assert_called_with(2)
self.assertEqual(c1_sub.call_count, 2)
self.assertEqual(c2_sub.call_count, 2)
self.assertEqual(all_sub.call_count, 2)
def test_opsgenie_notification_per_entity(monkeypatch):
post = MagicMock()
monkeypatch.setattr('requests.post', post)
alert = {
'changed': True,
'is_alert': True,
'entity': {
'id': 'e-1'
},
'worker': 'worker-1',
'time': datetime.now(),
'alert_def': {
'name': 'Alert',
'team': 'team-1',
'responsible_team': 'zmon',
'id': 123,
'priority': 3,
'tags': ['tag-1']
},
}
NotifyOpsgenie._config = {
'notifications.opsgenie.apikey': API_KEY,
'zmon.host': 'https://zmon.example.org/'
}
r = NotifyOpsgenie.notify(alert,
message=MESSAGE,
per_entity=True,
teams='team-1')
data = {
'alias': 'ZMON-123-e-1',
'message': '[zmon] - {}'.format(MESSAGE),
'description': '',
'source': 'worker-1',
'note': 'https://zmon.example.org/#/alert-details/123',
'entity': 'e-1',
'details': {
'worker': alert['worker'],
'id': alert['alert_def']['id'],
'name': alert['alert_def']['name'],
'team': alert['alert_def']['team'],
'responsible_team': alert['alert_def']['responsible_team'],
'entity': alert['entity']['id'],
'infrastructure_account': 'UNKNOWN',
},
'priority': 'P3',
'tags': ['tag-1'],
'teams': [{
'name': 'team-1'
}],
}
assert r == 0
post.assert_called_with(URL_CREATE,
data=json.dumps(data,
cls=JsonDataEncoder,
sort_keys=True),
headers=HEADERS,
timeout=5,
params={})
def test_should_call_load_accout_by_email_correct_value(
mock_load_by_email: MagicMock, sut: DbAuthentication):
sut.auth(
AuthenticationModel(email="*****@*****.**",
password="******"))
mock_load_by_email.assert_called_with("*****@*****.**")
def test_should_call_hash_compare_correct_values(mock_compare: MagicMock,
sut: DbAuthentication):
authentication = AuthenticationModel(email="*****@*****.**",
password="******")
sut.auth(authentication)
mock_compare.assert_called_with("valid_password", "hashed_password")
def test_bootstrap(self):
mock = MagicMock()
with patch('omnimax.sdk.base_sdk.execute_file', mock):
sdk = omnimax.sdk.BaseSDK('ruby')
sdk.bootstrap()
mock.assert_called_with(self.sdk_dir + '/bootstrap.sh', wrapper='bash', cwd=self.sdk_dir)
class TestRosControlAdapter(unittest.TestCase):
def select_mock(self, *args, **kwargs):
mock = {
'/gazebo/get_physics_properties': self.__get_physics,
'/gazebo/get_world_properties': self.__get_world,
'/gazebo/set_physics_properties': self.__set_physics,
'/gazebo/pause_physics': self.__pause_physics,
'/gazebo/unpause_physics': self.__unpause_physics,
'/gazebo/reset_sim': self.__reset_sim,
'/gazebo/end_world': self.__end_world,
# These are due to the GazeboHelper
'/gazebo/spawn_sdf_entity': self.__spawn_sdf_entity,
'/gazebo/set_model_state': self.__set_model_state,
'/gazebo/delete_model': self.__delete_model,
'/gazebo/delete_light': self.__delete_light,
'/gazebo/delete_lights': self.__delete_lights,
'/gazebo/get_lights_name': self.__get_lights_name,
'/gazebo/wait_for_rendering': self.__wait_for_rendering
}[args[0]]
for key, value in kwargs.items():
setattr(mock, key, value)
return mock
@patch(
'hbp_nrp_cle.robotsim.RosControlAdapter.AsynchonousRospyServiceProxy')
@patch(
'hbp_nrp_cle.robotsim.RosCommunicationAdapter.rospy.wait_for_service')
@patch('hbp_nrp_cle.robotsim.RosCommunicationAdapter.rospy.ServiceProxy')
def setUp(self, rospy_proxy, rospy_wfs, async_proxy_mock):
self.__advance_simulation = MagicMock()
self.__get_physics = MagicMock()
self.__get_world = MagicMock()
self.__set_physics = MagicMock()
self.__pause_physics = MagicMock()
self.__unpause_physics = MagicMock()
self.__reset_sim = MagicMock()
self.__end_world = MagicMock()
# These are due to GazeboHelper
self.__spawn_sdf_entity = MagicMock()
self.__set_model_state = MagicMock()
self.__delete_light = MagicMock()
self.__delete_model = MagicMock()
self.__delete_lights = MagicMock()
self.__get_lights_name = MagicMock()
self.__wait_for_rendering = MagicMock()
async_proxy_mock.return_value = self.__advance_simulation
rospy_proxy.side_effect = self.select_mock
self._rca = RosControlAdapter()
self._rca.initialize()
@patch(
'hbp_nrp_cle.robotsim.RosControlAdapter.AsynchonousRospyServiceProxy')
@patch(
'hbp_nrp_cle.robotsim.RosCommunicationAdapter.rospy.wait_for_service')
@patch('hbp_nrp_cle.robotsim.RosCommunicationAdapter.rospy.ServiceProxy')
def test_initialize(self, rospy_proxy, rospy_wfs, async_proxy_mock):
self.__pause_physics = MagicMock()
self.__get_physics = MagicMock()
physics_mock = MagicMock(pause=False, time_step=1.0)
physics_mock.pause = False
physics_mock.time_step = 1.0
self.__get_physics.return_value = physics_mock
rospy_proxy.side_effect = self.select_mock
with LogCapture('hbp_nrp_cle.robotsim.RosControlAdapter') as l:
rca = RosControlAdapter()
self.assertFalse(self.__pause_physics.called)
rca.initialize()
self.assertTrue(self.__pause_physics.called)
self.assertEqual(rca.time_step, 1.0)
l.check(('hbp_nrp_cle.robotsim.RosControlAdapter', 'INFO',
'Robot control adapter initialized'))
def test_time_step(self):
with LogCapture(
'hbp_nrp_cle.robotsim.RosControlAdapter') as logcapture:
self.assertEquals(self.__get_physics.call_count, 1)
self.__set_physics.return_value = True
self.assertTrue(self._rca.set_time_step(0.01))
self.assertEquals(self._rca.time_step, 0.01)
self.__set_physics.return_value = False
self.assertFalse(self._rca.set_time_step(42))
self.assertEquals(self._rca.time_step, 0.01)
logcapture.check(
('hbp_nrp_cle.robotsim.RosControlAdapter', 'INFO',
'new time step = 0.010000'),
('hbp_nrp_cle.robotsim.RosControlAdapter', 'WARNING',
'impossible to set the new time step'))
self.assertEquals(self.__get_physics.call_count, 3)
def test_is_paused(self):
self.__get_physics.return_value.pause = True
self.assertTrue(self._rca.is_paused)
self.__get_physics.return_value.pause = False
self.assertFalse(self._rca.is_paused)
def test_is_alive(self):
self.__get_world.return_value.success = True
self.assertTrue(self._rca.is_alive)
self.__get_world.return_value.success = False
self.assertFalse(self._rca.is_alive)
def test_run_step_logging(self):
with LogCapture(
'hbp_nrp_cle.robotsim.RosControlAdapter') as logcapture:
self.__set_physics.return_value = True
self._rca.set_time_step(0.01)
with self.assertRaises(ValueError):
self._rca.run_step(0.0001)
logcapture.check(
('hbp_nrp_cle.robotsim.RosControlAdapter', 'INFO',
'new time step = 0.010000'),
('hbp_nrp_cle.robotsim.RosControlAdapter', 'ERROR',
'dt is not multiple of the physics time step'))
def test_run_step(self):
future_mock = MagicMock()
self.__advance_simulation.return_value = future_mock
future_mock.result.return_value = 100
self._rca.set_time_step(0.01)
result = self._rca.run_step(0.01)
self.__advance_simulation.assert_called_with(1.0)
self.assertEqual(result, 100)
def test_run_step_async(self):
future_mock = MagicMock()
self.__advance_simulation.return_value = future_mock
self._rca.set_time_step(0.01)
result = self._rca.run_step_async(0.01)
self.assertEqual(result, future_mock)
self.__advance_simulation.assert_called_with(1.0)
def test_reset(self):
with LogCapture(
'hbp_nrp_cle.robotsim.RosControlAdapter') as logcapture:
self.__set_physics.return_value = True
self._rca.set_time_step(0.01)
self._rca.run_step(0.05)
self._rca.reset()
logcapture.check(('hbp_nrp_cle.robotsim.RosControlAdapter', 'INFO',
'new time step = 0.010000'),
('hbp_nrp_cle.robotsim.RosControlAdapter',
'DEBUG', 'Advancing simulation'),
('hbp_nrp_cle.robotsim.RosControlAdapter', 'INFO',
'Resetting the world simulation'))
def test_reset_world(self):
rca_module_name = 'hbp_nrp_cle.robotsim.RosControlAdapter'
user_notifications_module_name = 'hbp_nrp_cle.user_notifications'
robots = {}
robots["robot"] = "robot"
self._rca.set_robots(robots)
with LogCapture(rca_module_name) as logcapture:
with LogCapture(
user_notifications_module_name) as logcapture_user_notif:
# mock world (which is loaded during simulation startup)
mock_sdf = '<sdf/>'
world_models_sdf = {
'model1': {
'model_sdf': mock_sdf,
'model_state_sdf': mock_sdf
},
'model2': {
'model_sdf': mock_sdf,
'model_state_sdf': mock_sdf
}
}
world_lights_sdf = {"light1": mock_sdf, "light2": mock_sdf}
# mock current world status
mock_world_properties = GetWorldProperties()
mock_world_properties.model_names = [
"model1", "model2", "robot"
]
mock_world_lights = GetLightsName()
mock_world_lights.light_names = ["light1", "light2", "sun"]
# mock ros services
self._rca.gazebo_helper.get_lights_name_proxy = Mock(
return_value=mock_world_lights)
self._rca._RosControlAdapter__get_world_properties = Mock(
return_value=mock_world_properties)
# delete services
self._rca.gazebo_helper.delete_light_proxy = Mock(
return_value=True)
self._rca.gazebo_helper.delete_model_proxy = Mock(
return_value=True)
# spawn sdf service
self._rca.gazebo_helper.spawn_sdf_entity_proxy = Mock(
return_value=True)
# call the method under test
self._rca.reset_world(world_models_sdf, world_lights_sdf)
# check deletion
lights_to_delete_and_respawn = ["light1", "light2"]
models_to_delete_and_respawn = ["model1", "model2"]
# LIGHTS
for light in lights_to_delete_and_respawn:
self._rca.gazebo_helper.delete_light_proxy.assert_any_call(
light)
# MODELS
self.assertTrue(
False in map(
lambda c: 'robot' in c[0], self._rca.gazebo_helper.
delete_model_proxy.call_args_list),
'The robot must not be deleted from the scene')
for model in models_to_delete_and_respawn:
self._rca.gazebo_helper.delete_model_proxy.assert_any_call(
model)
# check reLoading
self.assertFalse(
False in map(
lambda c: c[0][0] in models_to_delete_and_respawn +
lights_to_delete_and_respawn, self._rca.gazebo_helper.
spawn_sdf_entity_proxy.call_args_list),
'Some entity has not been re-spawned')
# check log
logcapture.check(
(rca_module_name, 'DEBUG', 'Resetting the Environment'),
(rca_module_name, 'DEBUG',
"active_model_set: set(['model2', 'model1'])"),
(rca_module_name, 'DEBUG',
"original_model_set: frozenset(['model2', 'model1'])"),
(rca_module_name, 'DEBUG',
"active_lights_set: set(['light2', 'light1'])"),
(rca_module_name, 'DEBUG',
"original_lights_set: frozenset(['light2', 'light1'])"))
# check log on user notification logger
logcapture_user_notif.check(
(user_notifications_module_name, 'INFO',
"Deleting: light2"), (user_notifications_module_name,
'INFO', "Deleting: light1"),
(user_notifications_module_name, 'INFO',
"Deleting: model2"), (user_notifications_module_name,
'INFO', "Deleting: model1"),
(user_notifications_module_name, 'INFO',
"Loading: light2"), (user_notifications_module_name,
'INFO', "Loading: light1"),
(user_notifications_module_name, 'INFO',
"Loading: model2"), (user_notifications_module_name,
'INFO', "Loading: model1"))
def test_shutdown(self):
with LogCapture(
'hbp_nrp_cle.robotsim.RosControlAdapter') as logcapture:
self._rca.shutdown()
logcapture.check(('hbp_nrp_cle.robotsim.RosControlAdapter', 'INFO',
'Shutting down the world simulation'),
('hbp_nrp_cle.robotsim.RosControlAdapter', 'INFO',
'Robot control adapter stopped'))
def test_perform_get_mds_when_not_managed_via_omci(mds_task):
test = MagicMock()
mds_task.deferred.addCallback(test)
mds_task.perform_get_mds()
test.assert_called_with(mds_task.omci_agent.get_device().mib_synchronizer.mib_data_sync)
def test_callback_with_multiple_kwargs(self):
callback = MagicMock()
cuckoo = Cuckoo(callback=callback)
cuckoo(a=1, b=2)
callback.assert_called_with(a=1, b=2)
def test_scalyr_logs(monkeypatch, fx_logs):
kwargs, res, exp = fx_logs
read_key = '123'
post = MagicMock()
post.return_value.json.return_value = res
monkeypatch.setattr('requests.post', post)
def expected_query():
query = get_query('log', None, read_key, **kwargs)
query.pop('function', None)
query.pop('buckets', None)
query['maxCount'] = kwargs.get('max_count', 100)
if 'continuation_token' in kwargs:
query['continuationToken'] = kwargs['continuation_token']
if 'columns' in kwargs:
query['columns'] = ','.join(kwargs['columns']) if type(
kwargs['columns']) is list else kwargs['columns']
return query
scalyr = ScalyrWrapper(read_key)
try:
result = scalyr.logs(**kwargs)
assert result == exp
query = expected_query()
post.assert_called_with(scalyr._ScalyrWrapper__query_url,
json=query,
headers={
'Content-Type': 'application/json',
'errorStatus': 'always200'
})
except CheckError as e:
if not res:
assert '{}'.format(
e) == 'query "{}" is not allowed to be blank'.format(
kwargs['query'])
post.assert_not_called
elif 'message' in res:
assert '{}'.format(e) == res['message']
query = expected_query()
post.assert_called_with(scalyr._ScalyrWrapper__query_url,
json=query,
headers={
'Content-Type': 'application/json',
'errorStatus': 'always200'
})
elif not exp:
assert '{}'.format(
e) == 'No logs or error message was returned from scalyr'
query = expected_query()
post.assert_called_with(scalyr._ScalyrWrapper__query_url,
json=query,
headers={
'Content-Type': 'application/json',
'errorStatus': 'always200'
})
else:
raise
