def test_resolve_categories_for_rooms(self):
should_be_called = MagicMock(return_value = True)
all_rooms = self.generate_rooms_with_text("Some text")
with patch("__main__.DXFRoomCatsResolver._resolve_category_for_room", should_be_called):
r = DXFRoomCatsResolver._resolve_categories_for_rooms(
all_rooms,
self.cats
)
# 3 matches
self.assertEqual(r, 3)
for r in all_rooms:
MagicMock.assert_any_call(
should_be_called,
r,
self.cats
)
self.assertEqual(should_be_called.call_count, len(all_rooms))
# Now we ensure it counts correctly the amount of rooms matched
should_be_called = MagicMock(side_effect = [True, False, False])
with patch("__main__.DXFRoomCatsResolver._resolve_category_for_room", should_be_called):
r = DXFRoomCatsResolver._resolve_categories_for_rooms(
all_rooms,
self.cats
)
# 1 match
self.assertEqual(r, 1)
def test_run_spark_with_store_correct_calls():
run_cell_method = MagicMock()
run_cell_method.return_value = (True, "")
spark_controller.run_command = run_cell_method
command = "-s"
name = "sessions_name"
context = "-c"
context_name = "spark"
meth = "-m"
method_name = "sample"
output = "-o"
output_var = "var_name"
coer = "--coerce"
coerce_value = "True"
line = " ".join([
command, name, context, context_name, meth, method_name, output,
output_var, coer, coerce_value
])
cell = "cell code"
result = magic.spark(line, cell)
run_cell_method.assert_any_call(Command(cell), name)
run_cell_method.assert_any_call(
SparkStoreCommand(output_var, samplemethod=method_name, coerce=True),
name)
def test_handle_request_happy_path_no_failures(
self,
mock_store_validation_results: MagicMock,
mock_fetch_validations: MagicMock,
mock_run_job: MagicMock,
mock_emit_failures: MagicMock,
mock_rematerialize_views: MagicMock,
) -> None:
mock_fetch_validations.return_value = self._TEST_VALIDATIONS
mock_run_job.return_value = DataValidationJobResult(
validation_job=self._TEST_VALIDATIONS[0],
result_details=FakeValidationResultDetails(passed=True),
)
headers = {"X-Appengine-Cron": "test-cron"}
response = self.client.get("/validate", headers=headers)
self.assertEqual(200, response.status_code)
self.assertEqual(_API_RESPONSE_IF_NO_FAILURES, response.get_data().decode())
self.assertEqual(4, mock_run_job.call_count)
for job in self._TEST_VALIDATIONS:
mock_run_job.assert_any_call(job)
mock_rematerialize_views.assert_called()
mock_emit_failures.assert_not_called()
mock_store_validation_results.assert_called_once()
((results,), _kwargs) = mock_store_validation_results.call_args
self.assertEqual(4, len(results))
def test_allowed_user_convert(self, users, previous_users, expected_users):
key_str = 'allowed_users_str'
key = 'allowed_users'
# Configure mock
name_validator = MagicMock()
conv_val.toolkit.get_validator = MagicMock(return_value=name_validator)
# Fullfill the data dictionary
# * list should be included in the allowed_users filed
# * strings should be included in the allowed_users_str field
if isinstance(users, basestring):
data_key = key_str
else:
data_key = key
data = {(data_key,): users}
for i in range(0, previous_users):
data[(key, i)] = i
# Call the function
context = {'user': '******', 'auth_obj_id': {'id': 1}}
conv_val.allowed_users_convert((key,), data, {}, context)
# Check that the users are set properly
for i in range(previous_users, previous_users + len(expected_users)):
name_validator.assert_any_call(expected_users[i - previous_users], context)
self.assertEquals(expected_users[i - previous_users], data[(key, i)])
def test_run_spark_command_exception_while_storing():
run_cell_method = MagicMock()
exception = LivyUnexpectedStatusException('WOW')
run_cell_method.side_effect = [(True, ""), exception]
spark_controller.run_command = run_cell_method
command = "-s"
name = "sessions_name"
context = "-c"
context_name = "spark"
meth = "-m"
method_name = "sample"
output = "-o"
output_var = "var_name"
line = " ".join([
command, name, context, context_name, meth, method_name, output,
output_var
])
cell = "cell code"
result = magic.spark(line, cell)
run_cell_method.assert_any_call(Command(cell), name)
run_cell_method.assert_any_call(
SparkStoreCommand(output_var, samplemethod=method_name), name)
ipython_display.write.assert_called_once_with("")
ipython_display.send_error.assert_called_once_with(
EXPECTED_ERROR_MSG.format(exception))
def test_allowed_user_convert(self, users, previous_users, expected_users):
key_str = 'allowed_users_str'
key = 'allowed_users'
# Configure mock
name_validator = MagicMock()
conv_val.toolkit.get_validator = MagicMock(return_value=name_validator)
# Fullfill the data dictionary
# * list should be included in the allowed_users filed
# * strings should be included in the allowed_users_str field
if isinstance(users, basestring):
data_key = key_str
else:
data_key = key
data = {(data_key, ): users}
for i in range(0, previous_users):
data[(key, i)] = i
# Call the function
context = {'user': '******', 'auth_obj_id': {'id': 1}}
conv_val.allowed_users_convert((key, ), data, {}, context)
# Check that the users are set properly
for i in range(previous_users, previous_users + len(expected_users)):
name_validator.assert_any_call(expected_users[i - previous_users],
context)
self.assertEquals(expected_users[i - previous_users],
data[(key, i)])
def test_serialize_returns_expected(self):
obj_with_ser = MagicMock(spec=object)
mock_serialize = MagicMock(return_value={'a': 'b'})
obj_with_ser.attach_mock(mock_serialize, 'serialize')
obj_without_ser = MagicMock(spec=object)
class ICanSerialize(mixins.SerializableMixin):
def __init__(self):
self.attr1 = obj_with_ser
self.attr2 = obj_without_ser
serialize_me = ICanSerialize()
actual = serialize_me.serialize()
expected = {
'attr1': {
'a': 'b',
},
'attr2': obj_without_ser,
}
self.assertEqual(actual, expected)
mock_serialize.assert_any_call()
def test_resolve_room_categories(self):
a_floor = MagicMock()
should_be_called = MagicMock(return_value = True)
cats = MagicMock(return_value = "cats_result")
class_ns = "__main__.DXFRoomCatsResolver"
with patch(class_ns+".get_room_categories_dict", cats):
with patch(class_ns+"._resolve_room_categories_for_floor", should_be_called):
# Chiamata 1 - un solo floor, passato come parametro
r = DXFRoomCatsResolver.resolve_room_categories(MagicMock(), a_floor)
self.assertEqual(r, 1)
MagicMock.assert_called_once_with(cats)
MagicMock.assert_called_once_with(
should_be_called,
a_floor,
"cats_result",
)
MagicMock.reset_mock(should_be_called)
b = {
"dxf": { "floors": ["firstfloor", "secondfloor", "thirdfloor"] }
}
r = DXFRoomCatsResolver.resolve_room_categories(b)
for f in b["dxf"]["floors"]:
MagicMock.assert_any_call(
should_be_called,
f,
"cats_result"
)
self.assertEqual(r, 3)
def test_check_if_command_exits_when_fixture_path_does_not_exist(
self, os_path_exists_mock: MagicMock) -> None:
os_path_exists_mock.return_value = False
with self.assertRaises(SystemExit):
call_command(self.COMMAND_NAME, fixture=self.fixture_path, url=self.url)
os_path_exists_mock.assert_any_call(os.path.join(settings.DEPLOY_ROOT, self.fixture_path))
def test_check_if_command_exits_when_fixture_path_does_not_exist(
self, os_path_exists_mock: MagicMock) -> None:
os_path_exists_mock.return_value = False
with self.assertRaises(SystemExit):
call_command(self.COMMAND_NAME, fixture=self.fixture_path, url=self.url)
os_path_exists_mock.assert_any_call(os.path.join(settings.DEPLOY_ROOT, self.fixture_path))
def test_read_from_file(self):
read_csv = MagicMock(return_value=pandas.DataFrame())
with patch('pandas.read_csv', read_csv):
allocator = HouseholdAllocator.from_csvs('households_file',
'persons_file')
assert type(allocator) == HouseholdAllocator
read_csv.assert_any_call('households_file')
read_csv.assert_any_call('persons_file')
def test_read_from_file(self):
read_csv = MagicMock(return_value=pandas.DataFrame())
with patch('pandas.read_csv', read_csv):
population = Population.from_csvs('persons_file',
'households_file')
assert type(population) == Population
read_csv.assert_any_call('households_file')
read_csv.assert_any_call('persons_file')
def test_scan(self, connect_mock, tpl_mock):
self.maxDiff = None
now = '2013-09-20 11:48:33'
tpl_mock.return_value = {
'status': 'unknown',
'date': now,
'plugin': 'ssh_cisco_asa',
'messages': [],
}
ip = '10.10.10.10'
asa_ssh_mock = MagicMock()
command_mock = MagicMock()
asa_ssh_mock.asa_command = command_mock
command_mock.side_effect = cisco_asa_ssh_mock
connect_mock.return_value = asa_ssh_mock
correct_ret = {
'status': 'success',
'plugin': 'ssh_cisco_asa',
'messages': [],
'device': {
'model_name':
'Cisco SOME_ASA_MODEL',
'type':
'firewall',
'serial_number':
'SOME-SN',
'mac_addresses': [
u'AB12BC235556',
u'AB12BC235558',
u'DEF113DE4567',
u'DEF113DE4566',
u'DEF113DE5677',
u'DEF113DE5676',
u'DEF113DE6785',
u'DEF113DE6784',
],
'boot_firmware':
'SOME-BOOT-FIRMWARE',
'management_ip_addresses': [
ip,
],
'memory': [{
'size': 12288,
}],
'processors': [{
'family': 'AMD Opteron',
'model_name': 'AMD Opteron',
'speed': 2600,
}],
},
}
ret = ssh_cisco_asa.scan_address(ip, snmp_name='Cisco Software:UCOS')
correct_ret['date'] = ret['date'] # assuming datetime is working.
self.assertEqual(ret, correct_ret)
command_mock.assert_any_call(
"show version | grep (^Hardware|Boot microcode|^Serial|address is)",
)
self.assertEqual(command_mock.call_count, 1)
def test_local_import_source_corrupted_full_progress(
self,
is_cancelled_mock,
cancel_mock,
path_mock,
isfile_mock,
annotation_mock,
files_to_transfer_mock,
channel_list_status_mock,
):
"""
Ensure that when a file is imported that does not match the file size in the database
that the overall progress tracking for the content import process is properly updated
to reflect the size of the file in the database, not the file on disk.
This is important, as the total progress for the overall process is measured against
the total file size recorded in the database for all files, not for the the
transferred file size.
"""
local_src_path = tempfile.mkstemp()[1]
with open(local_src_path, "w") as f:
f.write("This is just a test")
src_file_size = os.path.getsize(local_src_path)
expected_file_size = 10000
local_dest_path = tempfile.mkstemp()[1]
os.remove(local_dest_path)
# Delete all but one file associated with ContentNode to reduce need for mocking
files = ContentNode.objects.get(
id="32a941fb77c2576e8f6b294cde4c3b0c").files.all()
first_file = files.first()
files.exclude(id=first_file.id).delete()
LocalFile.objects.filter(
files__contentnode="32a941fb77c2576e8f6b294cde4c3b0c").update(
file_size=expected_file_size)
files_to_transfer_mock.return_value = (
LocalFile.objects.filter(
files__contentnode="32a941fb77c2576e8f6b294cde4c3b0c"),
10,
)
path_mock.side_effect = [local_dest_path, local_src_path]
mock_overall_progress = MagicMock()
mock_file_progress = MagicMock()
with patch(
"kolibri.core.tasks.management.commands.base.ProgressTracker"
) as progress_mock:
progress_mock.return_value.__enter__.side_effect = [
mock_overall_progress,
mock_file_progress,
]
call_command(
"importcontent",
"disk",
self.the_channel_id,
"destination",
node_ids=["32a941fb77c2576e8f6b294cde4c3b0c"],
)
mock_overall_progress.assert_any_call(expected_file_size -
src_file_size)
def test_tuners(self, tuner: MagicMock):
main = Main(self.config)
g1 = Geo()
g2 = Geo()
main.geos = [g1, g2]
main._init_tuners()
self.assertEqual(len(main.tuners), 2)
tuner.assert_any_call(g1, main.config, main.ssdp, port=6077)
tuner.assert_any_call(g1, main.config, main.ssdp, port=6078)
def test_tuners_multiplex(self, tuner: MagicMock):
self.config.multiplex = True
main = Main(self.config)
g1 = Geo()
g2 = Geo()
main.geos = [g1, g2]
main._init_tuners()
self.assertEqual(len(main.tuners), 2)
tuner.assert_any_call(g1, main.config, main.ssdp, port=None)
tuner.assert_any_call(g2, main.config, main.ssdp, port=None)
def test_parallel_execution_without_arguments(self):
# Fixture
func = MagicMock()
# Test
self.sut.parallel(func)
# Assert
for uri, mock in self.factory.mocks.items():
func.assert_any_call(mock)
def test_parallel_execution_without_arguments(self):
# Fixture
func = MagicMock()
# Test
self.sut.parallel(func)
# Assert
for uri, mock in self.factory.mocks.items():
func.assert_any_call(mock)
def test_calcErrors(self):
diffMock = MagicMock(return_value=1)
with patch('miscFuncs.calcDiffErrors', diffMock):
an = AnalysisNodeData('node', ['K1', 'K2'], 'areas')
an.results = {'K1': ['1r1', '1r2'], 'K2': ['2r1', '2r2']}
an.anSol = {'K1': ['1a1', '1a2'], 'K2': ['2a1', '2a2']}
an.calcErrors()
diffMock.assert_any_call(['1a1', '1a2'], ['1r1', '1r2'])
diffMock.assert_any_call(['2a1', '2a2'], ['2r1', '2r2'])
self.assertEqual(2, diffMock.call_count)
expected = {'difference': {'K1': 1, 'K2': 1}, 'normedDiff': {}}
def file_import_test(self):
"""
Test the actual import of real song files and check that the imported data is correct.
"""
# GIVEN: Test files with a mocked out SongImport class, a mocked out "manager", a mocked out "import_wizard",
# and mocked out "author", "add_copyright", "add_verse", "finish" methods.
with patch('openlp.plugins.songs.lib.ewimport.SongImport'), \
patch('openlp.plugins.songs.lib.ewimport.retrieve_windows_encoding') as mocked_retrieve_windows_encoding:
mocked_retrieve_windows_encoding.return_value = 'cp1252'
mocked_manager = MagicMock()
mocked_import_wizard = MagicMock()
mocked_add_author = MagicMock()
mocked_add_verse = MagicMock()
mocked_finish = MagicMock()
mocked_title = MagicMock()
mocked_finish.return_value = True
importer = EasyWorshipSongImportLogger(mocked_manager)
importer.import_wizard = mocked_import_wizard
importer.stop_import_flag = False
importer.addAuthor = mocked_add_author
importer.addVerse = mocked_add_verse
importer.title = mocked_title
importer.finish = mocked_finish
importer.topics = []
# WHEN: Importing each file
importer.import_source = os.path.join(TEST_PATH, 'Songs.DB')
# THEN: doImport should return none, the song data should be as expected, and finish should have been
# called.
self.assertIsNone(importer.doImport(), 'doImport should return None when it has completed')
for song_data in SONG_TEST_DATA:
print mocked_title.mocked_calls()
title = song_data['title']
author_calls = song_data['authors']
song_copyright = song_data['copyright']
ccli_number = song_data['ccli_number']
add_verse_calls = song_data['verses']
verse_order_list = song_data['verse_order_list']
self.assertIn(title, importer._title_assignment_list, 'title for %s should be "%s"' % (title, title))
for author in author_calls:
mocked_add_author.assert_any_call(author)
if song_copyright:
self.assertEqual(importer.copyright, song_copyright)
if ccli_number:
self.assertEquals(importer.ccliNumber, ccli_number, 'ccliNumber for %s should be %s'
% (title, ccli_number))
for verse_text, verse_tag in add_verse_calls:
mocked_add_verse.assert_any_call(verse_text, verse_tag)
if verse_order_list:
self.assertEquals(importer.verseOrderList, verse_order_list, 'verseOrderList for %s should be %s'
% (title, verse_order_list))
mocked_finish.assert_called_with()
def add_file_test(isfile, getdest):
"""
Checks that the add_file() method behaves correctly under various circumstances.
"""
@command()
@argument('src')
@argument('dest')
@option('--force', '-f', is_flag=True)
def click_mock(src, dest, force):
scr.add_file(method, src, dest, scr.cur_notebook, force)
def side_effect1(*args):
if not args[3]:
raise OSError
else:
pass
method = MagicMock()
scr.add_file(method, 'src', 'dest', scr.cur_notebook, True)
method.assert_called_with(scr.cur_notebook, 'src', 'dest', True)
method = MagicMock(side_effect=side_effect1)
runner = CliRunner()
result = runner.invoke(click_mock, ['src', 'dest'], input='y\n')
method.assert_any_call(scr.cur_notebook, 'src', 'dest', False)
method.assert_called_with(scr.cur_notebook, 'src', 'dest', True)
method = MagicMock(side_effect=(OSError('1'), None))
isfile.side_effect = [True, False]
getdest.return_value = 'dest'
result = runner.invoke(click_mock, ['src', 'dest'], input='\n-\n')
assert 'Placing this file in the notebook would' in result.output
assert 'Provide a new filename' in result.output
method.assert_called_with(scr.cur_notebook, 'src', 'dest', False)
assert method.call_count == 1
method = MagicMock(side_effect=(OSError('1'), None))
getdest.return_value = 'dest.txt'
isfile.side_effect = [True, False]
result = runner.invoke(click_mock, ['src', 'dest.txt'], input='\n\n')
method.assert_called_with(scr.cur_notebook, 'src', 'dest-1.txt', False)
method = MagicMock(side_effect=(OSError('1'), None))
getdest.return_value = 'dest.txt'
isfile.side_effect = [True, False, False]
result = runner.invoke(click_mock, ['src', 'dest.txt'],
input='\nthingy.txt\n')
method.assert_called_with(scr.cur_notebook, 'src', 'thingy.txt', False)
method = MagicMock(side_effect=(OSError('1'), None))
getdest.return_value = 'out/dest.txt'
isfile.side_effect = [True, False]
result = runner.invoke(click_mock, ['src', 'out/dest.txt'], input='\n\n')
method.assert_called_with(scr.cur_notebook, 'src', 'out/dest-1.txt', False)
def test_scan(self, connect_mock, tpl_mock):
self.maxDiff = None
now = '2013-09-20 11:48:33'
tpl_mock.return_value = {
'status': 'unknown',
'date': now,
'plugin': 'ssh_cisco_asa',
'messages': [],
}
ip = '10.10.10.10'
asa_ssh_mock = MagicMock()
command_mock = MagicMock()
asa_ssh_mock.asa_command = command_mock
command_mock.side_effect = cisco_asa_ssh_mock
connect_mock.return_value = asa_ssh_mock
correct_ret = {
'status': 'success',
'plugin': 'ssh_cisco_asa',
'messages': [],
'device': {
'model_name': 'Cisco SOME_ASA_MODEL',
'type': 'firewall',
'serial_number': 'SOME-SN',
'mac_addresses': [
u'AB12BC235556',
u'AB12BC235558',
u'DEF113DE4567',
u'DEF113DE4566',
u'DEF113DE5677',
u'DEF113DE5676',
u'DEF113DE6785',
u'DEF113DE6784',
],
'boot_firmware': 'SOME-BOOT-FIRMWARE',
'management_ip_addresses': [ip, ],
'memory': [{
'size': 12288,
}],
'processors': [{
'family': 'AMD Opteron',
'model_name': 'AMD Opteron',
'speed': 2600,
}],
},
}
ret = ssh_cisco_asa.scan_address(ip, snmp_name='Cisco Software:UCOS')
correct_ret['date'] = ret['date'] # assuming datetime is working.
self.assertEqual(ret, correct_ret)
command_mock.assert_any_call(
"show version | grep (^Hardware|Boot microcode|^Serial|address is)",
)
self.assertEqual(command_mock.call_count, 1)
def test_delAttr(self):
"""
You can delete attributes.
"""
ev = MagicMock()
world = World(ev)
obj = world.create('foo')
world.setAttr(obj['id'], 'foo', 'bar')
ev.reset_mock()
world.delAttr(obj['id'], 'foo')
ev.assert_any_call(AttrDel(obj['id'], 'foo'))
self.assertNotIn('foo', world.get(obj['id']))
def test_snapshot(self):
pvc_driver = self._driver
pvc_driver._service.snapshot = MagicMock()
context = MagicMock()
instance = 1
image_id = 1
update_task_state = MagicMock()
pvc_driver.snapshot(context, instance, image_id, update_task_state)
update_task_state.assert_any_call(
task_state=task_states.IMAGE_PENDING_UPLOAD)
update_task_state.assert_any_call(
task_state=task_states.IMAGE_UPLOADING,
expected_state=task_states.IMAGE_PENDING_UPLOAD)
def test_delAttr(self):
"""
You can delete attributes.
"""
ev = MagicMock()
world = World(ev)
obj = world.create('foo')
world.setAttr(obj['id'], 'foo', 'bar')
ev.reset_mock()
world.delAttr(obj['id'], 'foo')
ev.assert_any_call(AttrDel(obj['id'], 'foo'))
self.assertNotIn('foo', world.get(obj['id']))
def test_removeItem(self):
"""
You can remove items from a list
"""
ev = MagicMock()
world = World(ev)
obj = world.create('foo')
world.addItem(obj['id'], 'foo', 'bar')
ev.reset_mock()
world.removeItem(obj['id'], 'foo', 'bar')
ev.assert_any_call(ItemRemoved(obj['id'], 'foo', 'bar'))
self.assertEqual(world.get(obj['id'])['foo'], [])
def test_setAttr(self):
"""
You can set the value of an attribute.
"""
ev = MagicMock()
world = World(ev)
obj = world.create('foo')
ev.reset_mock()
world.setAttr(obj['id'], 'foo', 'bar')
ev.assert_any_call(AttrSet(obj['id'], 'foo', 'bar'))
obj = world.get(obj['id'])
self.assertEqual(obj['foo'], 'bar')
def test_filter_trace(self):
mock_filter = MagicMock()
self.mf.filter = mock_filter
mock_filter.side_effect = cycle([[sentinel.filtered_even] * 2,
[sentinel.filtered_odd] * 2,
[sentinel.filtered_recombined]])
trace_segment = [sentinel.trace_even, sentinel.trace_odd]
filtered_trace = self.mf.filter_trace(trace_segment * 4)
self.assertEqual(filtered_trace, [sentinel.filtered_recombined])
mock_filter.assert_any_call([sentinel.trace_even] * 4)
mock_filter.assert_any_call([sentinel.trace_odd] * 4)
mock_filter.assert_called_with([sentinel.filtered_even, sentinel.filtered_odd] * 2)
def test_log_call_accepts_callable(self, logging):
"""flog.flog.log_sensitive_call: Accepts a callable and calls it as if it were a logger function"""
my_logger = MagicMock()
randoa = random.randint(0, 500)
randob = random.randint(0, 500)
randoc = random.randint(0, 500)
# SUT
flog.log_sensitive_call(my_logger)(my_fun)(randoa, randob, randoc, random_frippery_scale=32)
my_logger.assert_any_call("test_log_call.my_fun: args: *XXXXXX, kwargs: **XXXXXXX")
my_logger.assert_any_call("test_log_call.my_fun: returns: XXXXXXXXXX")
def test_removeItem(self):
"""
You can remove items from a list
"""
ev = MagicMock()
world = World(ev)
obj = world.create('foo')
world.addItem(obj['id'], 'foo', 'bar')
ev.reset_mock()
world.removeItem(obj['id'], 'foo', 'bar')
ev.assert_any_call(ItemRemoved(obj['id'], 'foo', 'bar'))
self.assertEqual(world.get(obj['id'])['foo'], [])
def test_setAttr(self):
"""
You can set the value of an attribute.
"""
ev = MagicMock()
world = World(ev)
obj = world.create('foo')
ev.reset_mock()
world.setAttr(obj['id'], 'foo', 'bar')
ev.assert_any_call(AttrSet(obj['id'], 'foo', 'bar'))
obj = world.get(obj['id'])
self.assertEqual(obj['foo'], 'bar')
def test_snapshot(self):
pvc_driver = self._driver
pvc_driver._service.snapshot = MagicMock()
context = MagicMock()
instance = 1
image_id = 1
update_task_state = MagicMock()
pvc_driver.snapshot(context, instance, image_id,
update_task_state)
update_task_state.assert_any_call(
task_state=task_states.IMAGE_PENDING_UPLOAD)
update_task_state.assert_any_call(
task_state=task_states.IMAGE_UPLOADING,
expected_state=task_states.IMAGE_PENDING_UPLOAD)
def test_handle_request_happy_path_some_failures(
self,
mock_store_validation_results: MagicMock,
mock_fetch_validations: MagicMock,
mock_run_job: MagicMock,
mock_emit_failures: MagicMock,
mock_rematerialize_views: MagicMock,
) -> None:
mock_fetch_validations.return_value = self._TEST_VALIDATIONS
first_failure = DataValidationJobResult(
validation_job=self._TEST_VALIDATIONS[1],
result_details=FakeValidationResultDetails(passed=False),
)
second_failure = DataValidationJobResult(
validation_job=self._TEST_VALIDATIONS[2],
result_details=FakeValidationResultDetails(passed=False),
)
mock_run_job.side_effect = [
DataValidationJobResult(
validation_job=self._TEST_VALIDATIONS[0],
result_details=FakeValidationResultDetails(passed=True),
),
first_failure,
second_failure,
DataValidationJobResult(
validation_job=self._TEST_VALIDATIONS[3],
result_details=FakeValidationResultDetails(passed=True),
),
]
headers = {"X-Appengine-Cron": "test-cron"}
response = self.client.get("/validate", headers=headers)
self.assertEqual(200, response.status_code)
self.assertNotEqual(_API_RESPONSE_IF_NO_FAILURES, response.get_data().decode())
self.assertEqual(4, mock_run_job.call_count)
for job in self._TEST_VALIDATIONS:
mock_run_job.assert_any_call(job)
mock_rematerialize_views.assert_called()
mock_emit_failures.assert_called_with(
[], UnorderedCollection([first_failure, second_failure])
)
mock_store_validation_results.assert_called_once()
self.assertEqual(1, len(mock_store_validation_results.call_args[0]))
((results,), _kwargs) = mock_store_validation_results.call_args
self.assertEqual(4, len(results))
def test_create(self):
"""
You can create objects.
"""
ev = MagicMock()
world = World(ev)
obj = world.create('foo')
self.assertIn('id', obj)
self.assertEqual(obj['kind'], 'foo')
self.assertEqual(obj, world.objects[obj['id']], "Should be in the "
"objects list")
ev.assert_any_call(Created(obj['id']))
ev.assert_any_call(AttrSet(obj['id'], 'kind', 'foo'))
def test_addItem(self):
"""
You can add items to a list
"""
ev = MagicMock()
world = World(ev)
obj = world.create('foo')
ev.reset_mock()
world.addItem(obj['id'], 'foo', 'bar')
ev.assert_any_call(ItemAdded(obj['id'], 'foo', 'bar'))
obj = world.get(obj['id'])
self.assertEqual(obj['foo'], ['bar'])
def test_filter_trace(self):
mock_filter = MagicMock()
self.mf.filter = mock_filter
mock_filter.side_effect = cycle([[sentinel.filtered_even] * 2,
[sentinel.filtered_odd] * 2,
[sentinel.filtered_recombined]])
trace_segment = [sentinel.trace_even, sentinel.trace_odd]
filtered_trace = self.mf.filter_trace(trace_segment * 4)
self.assertEqual(filtered_trace, [sentinel.filtered_recombined])
mock_filter.assert_any_call([sentinel.trace_even] * 4)
mock_filter.assert_any_call([sentinel.trace_odd] * 4)
mock_filter.assert_called_with(
[sentinel.filtered_even, sentinel.filtered_odd] * 2)
def test_create(self):
"""
You can create objects.
"""
ev = MagicMock()
world = World(ev)
obj = world.create('foo')
self.assertIn('id', obj)
self.assertEqual(obj['kind'], 'foo')
self.assertEqual(obj, world.objects[obj['id']], "Should be in the "
"objects list")
ev.assert_any_call(Created(obj['id']))
ev.assert_any_call(AttrSet(obj['id'], 'kind', 'foo'))
def test_addItem(self):
"""
You can add items to a list
"""
ev = MagicMock()
world = World(ev)
obj = world.create('foo')
ev.reset_mock()
world.addItem(obj['id'], 'foo', 'bar')
ev.assert_any_call(ItemAdded(obj['id'], 'foo', 'bar'))
obj = world.get(obj['id'])
self.assertEqual(obj['foo'], ['bar'])
def test_validator_call(self):
validator = MagicMock()
attr_val = {
'attr1': validator,
'attr2': validator,
}
with patch('bundlewrap.items.symlinks.ATTRIBUTE_VALIDATORS', new=attr_val):
symlinks.Symlink.validate_attributes(
MagicMock(),
"symlink:/foo",
{'attr1': 1, 'attr2': 2},
)
validator.assert_any_call("symlink:/foo", 1)
validator.assert_any_call("symlink:/foo", 2)
self.assertEqual(validator.call_count, 2)
def test_load_plugins(self):
dir_name = os.path.realpath(os.path.join(__file__, '../../monitorrent'))
walk_result = [
(dir_name, ['plugins'], ['__init__.py']),
(os.path.join(dir_name, 'plugins'), [], ['__init__.py', 'plugin1.py', 'plugin2.py']),
]
os_walk_mock = MagicMock(return_value=walk_result)
import_mock = MagicMock()
with patch('monitorrent.plugin_managers.os.walk', os_walk_mock), \
patch('monitorrent.plugin_managers.__import__', import_mock, create=True):
load_plugins('plugins')
self.assertTrue(os_walk_mock.call_count, 1)
self.assertTrue(import_mock.call_count, 2)
import_mock.assert_any_call('monitorrent.plugins.plugin1')
import_mock.assert_any_call('monitorrent.plugins.plugin2')
def test_wait(self, waitpid_mock):
exit_cb = MagicMock()
waitpid_mock.side_effect = [('testpid1', 0),
OSError(errno.ESRCH, 'No such pid'),
OSError(99, 'Something else')]
worker1 = MagicMock(queues=None, pid='testpid1')
worker2 = MagicMock(queues=None, pid='testpid2')
worker3 = MagicMock(queues=None, pid='testpid3')
master = WorkerMaster('testapp', exit_callback=exit_cb)
master.workers = [worker1, worker2, worker3]
self.assertRaises(OSError, master.wait)
waitpid_mock.assert_any_call('testpid1', 0)
waitpid_mock.assert_any_call('testpid2', 0)
waitpid_mock.assert_any_call('testpid3', 0)
exit_cb.assert_any_call(None, 'testpid1', 0)
exit_cb.assert_any_call(None, 'testpid2', None)
def test_main():
mock = MagicMock()
with patch('builtins.print', new=mock):
main()
mock.assert_any_call(1)
mock.assert_any_call("Fizz")
mock.assert_any_call("Buzz")
mock.assert_any_call("FizzBuzz")
mock.assert_any_call(16)
def song_import_test(self):
"""
Test that a simulated WorshipCenter Pro recordset is imported correctly
"""
# GIVEN: A mocked out SongImport class, a mocked out pyodbc module with a simulated recordset, a mocked out
# translate method, a mocked "manager", addVerse method & mocked_finish method.
with patch('openlp.plugins.songs.lib.worshipcenterproimport.SongImport'), \
patch('openlp.plugins.songs.lib.worshipcenterproimport.pyodbc') as mocked_pyodbc, \
patch('openlp.plugins.songs.lib.worshipcenterproimport.translate') as mocked_translate:
mocked_manager = MagicMock()
mocked_import_wizard = MagicMock()
mocked_add_verse = MagicMock()
mocked_finish = MagicMock()
mocked_pyodbc.connect().cursor().fetchall.return_value = RECORDSET_TEST_DATA
mocked_translate.return_value = 'Translated Text'
importer = WorshipCenterProImportLogger(mocked_manager)
importer.import_source = 'import_source'
importer.import_wizard = mocked_import_wizard
importer.addVerse = mocked_add_verse
importer.stop_import_flag = False
importer.finish = mocked_finish
# WHEN: Calling the doImport method
return_value = importer.doImport()
# THEN: doImport should return None, and pyodbc, import_wizard, importer.title and addVerse 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_pyodbc.connect().cursor.assert_any_call()
mocked_pyodbc.connect().cursor().execute.assert_called_with('SELECT ID, Field, Value FROM __SONGDATA')
mocked_pyodbc.connect().cursor().fetchall.assert_any_call()
mocked_import_wizard.progress_bar.setMaximum.assert_called_with(2)
add_verse_call_count = 0
for song_data in SONG_TEST_DATA:
title_value = song_data['title']
self.assertIn(title_value, importer._title_assignment_list,
'title should have been set to %s' % title_value)
verse_calls = song_data['verses']
add_verse_call_count += len(verse_calls)
for call in verse_calls:
mocked_add_verse.assert_any_call(call)
self.assertEqual(mocked_add_verse.call_count, add_verse_call_count,
'Incorrect number of calls made to addVerse')
def test_validator_call(self):
validator = MagicMock()
attr_val = {
'attr1': validator,
'attr2': validator,
}
with patch('bundlewrap.items.files.ATTRIBUTE_VALIDATORS', new=attr_val):
files.File.validate_attributes(
MagicMock(),
"item:id",
{
'attr1': 1,
'attr2': 2,
},
)
validator.assert_any_call("item:id", 1)
validator.assert_any_call("item:id", 2)
self.assertEqual(validator.call_count, 2)
def test_destroy(self):
"""
You can destroy an object, and be notified about it.
"""
ev = MagicMock()
world = World(ev)
obj = world.create('foo')
ev.reset_mock()
called = []
world.receiveFor(obj['id'], called.append)
world.destroy(obj['id'])
ev.assert_any_call(Destroyed(obj['id']))
self.assertEqual(called, [Destroyed(obj['id'])], "Should notify things"
" receiving events for the object")
self.assertNotIn(obj['id'], world.objects)
def test_load_plugins(self):
dir_name = os.path.dirname(
os.path.realpath(os.path.join(__file__, '..')))
walk_result = [
(dir_name, ['plugins'], ['__init__.py']),
(os.path.join(dir_name, 'plugins'), [],
['__init__.py', 'plugin1.py', 'plugin2.py']),
]
os_walk_mock = MagicMock(return_value=walk_result)
import_mock = MagicMock()
with patch('monitorrent.plugin_managers.os.walk', os_walk_mock), \
patch('monitorrent.plugin_managers.__import__', import_mock, create=True):
load_plugins('plugins')
self.assertTrue(os_walk_mock.call_count, 1)
self.assertTrue(import_mock.call_count, 2)
import_mock.assert_any_call('monitorrent.plugins.plugin1')
import_mock.assert_any_call('monitorrent.plugins.plugin2')
def test_destroy(self):
"""
You can destroy an object, and be notified about it.
"""
ev = MagicMock()
world = World(ev)
obj = world.create('foo')
ev.reset_mock()
called = []
world.receiveFor(obj['id'], called.append)
world.destroy(obj['id'])
ev.assert_any_call(Destroyed(obj['id']))
self.assertEqual(
called, [Destroyed(obj['id'])], "Should notify things"
" receiving events for the object")
self.assertNotIn(obj['id'], world.objects)
def test_destroy_callbacks_are_called(self):
ODMModel.set_pm(MagicMock())
dic = {"_id" : "2323", "pippo" : "pluto"}
odm = ODMModel(dic)
pippo = MagicMock()
pluto = MagicMock()
sempronio = MagicMock()
ODMModel.listen("before_destroy", pippo)
ODMModel.listen("before_destroy", sempronio)
ODMModel.listen("after_destroy", sempronio)
ODMModel.listen("after_destroy", pluto)
odm.destroy()
MagicMock.assert_called_once_with(pippo, odm)
MagicMock.assert_called_once_with(pluto, odm)
MagicMock.assert_any_call(sempronio, odm)
def test_destroy_callbacks_are_called(self):
ODMModel.set_pm(MagicMock())
dic = {"_id": "2323", "pippo": "pluto"}
odm = ODMModel(dic)
pippo = MagicMock()
pluto = MagicMock()
sempronio = MagicMock()
ODMModel.listen("before_destroy", pippo)
ODMModel.listen("before_destroy", sempronio)
ODMModel.listen("after_destroy", sempronio)
ODMModel.listen("after_destroy", pluto)
odm.destroy()
MagicMock.assert_called_once_with(pippo, odm)
MagicMock.assert_called_once_with(pluto, odm)
MagicMock.assert_any_call(sempronio, odm)
def test_scan(self, connect_mock, network_mock):
cata_ssh_mock = MagicMock()
command_mock = MagicMock()
cata_ssh_mock.cisco_command = command_mock
command_mock.side_effect = ssh_catalyst_mock
connect_mock.return_value = cata_ssh_mock
ip = '11.11.11.11'
network_mock.return_value = 'cata1'
correct_ret = {
'status': 'success',
'plugin': 'ssh_cisco_catalyst',
'messages': [],
'device': {
'hostname': 'cata1',
'model_name': 'Cisco Catalyst SOME_CATA_MODEL',
'type': u'switch',
'serial_number': 'SOME-SN',
'mac_adresses': ['AB12BC235556', ],
'management_ip_addresses': [ip, ],
'parts': [
{
'serial_number': 'eth-sn1',
'name': 'GigabitEthernet0/45',
'label': '1000BaseSX SFP',
},
{
'serial_number': 'eth-sn2',
'name': 'GigabitEthernet0/46',
'label': '1000BaseSX SFP',
},
],
},
}
ret = ssh_cisco_catalyst.scan_address(ip)
correct_ret['date'] = ret['date'] # assuming datetime is working.
self.assertEqual(ret, correct_ret)
network_mock.assertCalledWith(ip)
command_mock.assert_any_call(
"show version | include Base ethernet MAC Address",
)
command_mock.assert_any_call("show inventory")
self.assertEqual(command_mock.call_count, 2)
def test_parallel_execution(self):
# Fixture
func = MagicMock()
args_dict = {
self.URI1: ['cf1-arg1'],
self.URI2: ['cf2-arg1'],
self.URI3: ['cf3-arg1'],
}
cf1 = self.factory.mocks[self.URI1]
cf2 = self.factory.mocks[self.URI2]
cf3 = self.factory.mocks[self.URI3]
# Test
self.sut.parallel(func, args_dict=args_dict)
# Assert
func.assert_any_call(cf1, 'cf1-arg1')
func.assert_any_call(cf2, 'cf2-arg1')
func.assert_any_call(cf3, 'cf3-arg1')
def test_parallel_execution(self):
# Fixture
func = MagicMock()
args_dict = {
self.URI1: ['cf1-arg1'],
self.URI2: ['cf2-arg1'],
self.URI3: ['cf3-arg1'],
}
cf1 = self.factory.mocks[self.URI1]
cf2 = self.factory.mocks[self.URI2]
cf3 = self.factory.mocks[self.URI3]
# Test
self.sut.parallel(func, args_dict=args_dict)
# Assert
func.assert_any_call(cf1, 'cf1-arg1')
func.assert_any_call(cf2, 'cf2-arg1')
func.assert_any_call(cf3, 'cf3-arg1')
def test_ensure_webhook_remove(self):
testee = BridgeProviderBitbucket({
'username': '******',
'password': '******',
'incoming_token': 'glig',
})
dest=MagicMock()
def replacement_api(*args, **kwargs):
if args[1].endswith('hooks/'):
return [
{
'uuid': 1,
'url': 'http://me.com/bla',
'description': 'Greg2',
'skip_cert_verification': False,
'active': True,
'events': [u'pullrequest:comment_created', u'repo:push'],
},
{
'uuid': 2,
'url': 'http://me.com/',
'description': 'Grog2',
'skip_cert_verification': False,
'active': True,
'events': [u'pullrequest:comment_created', u'repo:push'],
}
]
else:
return dest(*args, **kwargs)
testee.api = replacement_api
testee.ensure_webhook('on','aboat','http://me.com')
dest.assert_any_call('2.0','repositories/on/aboat/hooks/1',method='DELETE')
dest.assert_any_call('2.0','repositories/on/aboat/hooks/2',method='DELETE')
dest.assert_any_call('2.0','repositories/on/aboat/hooks',form_data={
'url': 'http://me.com',
'description': 'Greg2',
'skip_cert_verification': False,
'active': True,
'events': [u'pullrequest:comment_created', u'repo:push'],
},method='POST',request_type='json')
self.assertEquals(dest.call_count,3)
def test_scan(self, connect_mock, tpl_mock):
self.maxDiff = None
now = "2013-09-20 11:48:33"
tpl_mock.return_value = {"status": "unknown", "date": now, "plugin": "ssh_cisco_asa", "messages": []}
ip = "10.10.10.10"
asa_ssh_mock = MagicMock()
command_mock = MagicMock()
asa_ssh_mock.asa_command = command_mock
command_mock.side_effect = cisco_asa_ssh_mock
connect_mock.return_value = asa_ssh_mock
correct_ret = {
"status": "success",
"plugin": "ssh_cisco_asa",
"messages": [],
"device": {
"model_name": "Cisco SOME_ASA_MODEL",
"type": "firewall",
"serial_number": "SOME-SN",
"mac_adresses": [
"AB12BC235556",
"AB12BC235558",
"DEF113DE4567",
"DEF113DE4566",
"DEF113DE5677",
"DEF113DE5676",
"DEF113DE6785",
"DEF113DE6784",
],
"boot_firmware": "SOME-BOOT-FIRMWARE",
"management_ip_addresses": [ip],
"memory": [{"size": 12288}],
"processors": [{"model_name": "AMD Opteron", "speed": 2600}],
},
}
ret = ssh_cisco_asa.scan_address(ip)
correct_ret["date"] = ret["date"] # assuming datetime is working.
self.assertEqual(ret, correct_ret)
command_mock.assert_any_call("show version | grep (^Hardware|Boot microcode|^Serial|address is)")
command_mock.assert_any_call("show inventory")
self.assertEqual(command_mock.call_count, 2)
def test_log_call_accepts_callable(self, logging):
"""flog.flog.log_call: Accepts a callable and calls it as if it were a logger function"""
my_logger = MagicMock()
randoa = random.randint(0, 500)
randob = random.randint(0, 500)
randoc = random.randint(0, 500)
flog.log_call(my_logger)(self.instance_method)(randoa, randob, randoc, random_frippery_scale=32) # SUT
my_logger.assert_any_call(
"test_log_call.TestLogCall.instance_method: args: ({}, {}, {}), kwargs: {rfs}".format(
randoa,
randob,
randoc,
rfs="{'random_frippery_scale': 32}"
)
)
my_logger.assert_any_call(
"test_log_call.TestLogCall.instance_method: returns: {}".format(randoa + randob + randoc)
)
def test_serialize_returns_expected(self):
obj_with_ser = MagicMock(spec=object)
mock_serialize = MagicMock(return_value={'a': 'b'})
obj_with_ser.attach_mock(mock_serialize, 'serialize')
obj_without_ser = MagicMock(spec=object)
class ICanSerialize(mixins.SerializableMixin):
def __init__(self):
self.attr1 = obj_with_ser
self.attr2 = obj_without_ser
serialize_me = ICanSerialize()
actual = serialize_me.serialize()
expected = {'attr1': {'a': 'b', },
'attr2': obj_without_ser,
}
self.assertEqual(actual, expected)
mock_serialize.assert_any_call()
def testFailoverToFirstRouteWhenIndexIsLastRoute(self, mockCreateRoute):
mockOnTearDown = MagicMock()
mockOnSetup = MagicMock()
mockOnConnectionFailed = MagicMock()
mockOnConnected = MagicMock()
self.failoverRoute.onTearDown = mockOnTearDown
self.defaultRoute.onSetup = mockOnSetup
self.failoverRoute.onConnectionFailed = mockOnConnectionFailed
self.defaultRoute.onConnected = mockOnConnected
assert 0 == ifacefailover.failoverToNextRoute(self.routes, 1)
mockCreateRoute.assert_called_once_with(self.defaultRoute)
mockOnTearDown.assert_any_call()
mockOnSetup.assert_any_call()
mockOnConnectionFailed.assert_any_call()
mockOnConnected.assert_any_call()
