def test_notify_destination(self):
self.toolbox.msg = mock.NonCallableMagicMock()
self.toolbox.msg.attach_mock(mock.MagicMock(), "emit")
self.toolbox.msg_warning = mock.NonCallableMagicMock()
self.toolbox.msg_warning.attach_mock(mock.MagicMock(), "emit")
source_item = mock.MagicMock()
source_item.name = "source name"
source_item.item_type = mock.MagicMock(return_value="Data Connection")
self.ds.notify_destination(source_item)
self.toolbox.msg.emit.assert_called_with("Link established.")
source_item.item_type = mock.MagicMock(return_value="Importer")
self.ds.notify_destination(source_item)
self.toolbox.msg.emit.assert_called_with(
"Link established. Mapped data generated by <b>source name</b> will be imported in <b>DS</b> when executing."
)
source_item.item_type = mock.MagicMock(return_value="Exporter")
self.ds.notify_destination(source_item)
self.toolbox.msg_warning.emit.assert_called_with(
"Link established. Interaction between a "
"<b>Exporter</b> and a <b>Data Store</b> has not been implemented yet."
)
source_item.item_type = mock.MagicMock(return_value="Tool")
self.ds.notify_destination(source_item)
self.toolbox.msg.emit.assert_called_with("Link established.")
source_item.item_type = mock.MagicMock(return_value="View")
self.ds.notify_destination(source_item)
self.toolbox.msg_warning.emit.assert_called_with(
"Link established. Interaction between a "
"<b>View</b> and a <b>Data Store</b> has not been implemented yet."
)
def setUp(self):
super().setUp()
self.mock_repo = mock.NonCallableMagicMock(
spec=['remotes', 'branches'])
self.mock_remote = mock.NonCallableMagicMock(spec=['fetch'])
self.mock_repo.remotes = [self.mock_remote]
self.mock_repo.branches = [self.NAME, 'someOtherBranchWeWillNotUse']
def setUp(self):
super().setUp()
self.mock_repo = mock.NonCallableMagicMock(
spec=['remotes', 'tags'])
self.mock_remote = mock.NonCallableMagicMock(spec=['fetch'])
self.mock_remote.name = 'mock_origin'
self.mock_repo.remotes = [self.mock_remote]
self.mock_repo.tags = [self.NAME, 'someOtherTagWeWillNotUse']
def create_session_mocks_using_service_method(method, method_responses):
session = mock.NonCallableMagicMock()
service = mock.NonCallableMagicMock()
setattr(service, method, mock.Mock(side_effect=method_responses))
session.client = mock.Mock(return_value=service)
return SessionMocksUsingServiceMethod(
session,
service,
getattr(service, method)
)
def create_session_mocks_using_paginator(search_response_iterator):
session = mock.NonCallableMagicMock()
paginator = mock.NonCallableMagicMock()
service = mock.NonCallableMagicMock()
paginate_response_iterator = mock.NonCallableMagicMock()
paginate_response_iterator.search = mock.Mock(return_value=search_response_iterator)
paginator.paginate = mock.Mock(return_value=paginate_response_iterator)
service.get_paginator = mock.Mock(return_value=paginator)
session.client = mock.Mock(return_value=service)
return SessionMocksUsingPaginator(session, service, paginator, paginate_response_iterator)
def setUp(self):
super(TC_00_API_Misc, self).setUp()
self.tpl = mock.NonCallableMagicMock(name='template')
del self.tpl.template
self.src = mock.NonCallableMagicMock(name='appvm', template=self.tpl)
self.app = mock.NonCallableMock()
self.dest = mock.NonCallableMock()
self.dest.name = 'dom0'
self.app.configure_mock(domains={
'dom0': self.dest,
'test-vm': self.src,
})
def test_tied(self):
param = Parameter(name='test', default=[1, 2, 3, 4])
assert param.tied is False
assert param._tied is False
# Set error
with pytest.raises(TypeError) as err:
param.tied = mk.NonCallableMagicMock()
assert str(
err.value) == "Tied must be a callable or set to False or None"
# Set None
param.tied = None
assert param.tied is None
assert param._tied is None
# Set False
param.tied = False
assert param.tied is False
assert param._tied is False
# Set other
tied = mk.MagicMock()
param.tied = tied
assert param.tied == tied == param._tied
def test_write(self):
for f_type in ("a", "b"):
with self.subTest(ftype=f_type):
for i in (3, 4):
with self.subTest(i=i):
socket_instance_mock = mock.NonCallableMagicMock(
spec=_socket.socket)
a = self.prepare_no_res(f_type, i,
socket_instance_mock)
a.target.network = 1
a.target.node = 0x01
a.target.m_drop = 1
a.target.dst_proc = 1
with self.assertRaises(AssertionError):
a.memory_write(0x2680, [b"\x00\x20", b"\x00\x00"],
timeout=6)
a.target.network = 0
with self.assertRaises(AssertionError):
a.memory_write(0x2680, [b"\x00\x20", b"\x00\x00"],
timeout=6)
a.target.network = 1
a.target.node = 0xFF
with self.assertRaises(AssertionError):
a.memory_write(0x2680, [b"\x00\x20", b"\x00\x00"],
timeout=6)
a.target.network = 0
with a:
a.memory_write(0x2680, [b"\x00\x20", b"\x00\x00"],
timeout=6)
data_body = (
b"1613000000002680000220000000" if f_type == "a"
else b"\x13\x16\x00\x00\x80\x26\x00\x00\x02\x00"
b"\x00\x20\x00\x00")
self.check_send_data(f_type, i, data_body,
socket_instance_mock)
def test_write_random_bit(self):
for f_type in ("a", "b"):
with self.subTest(ftype=f_type):
for i in (3, 4):
with self.subTest(i=i):
socket_instance_mock = mock.NonCallableMagicMock(
spec=_socket.socket)
a = self.prepare_no_res(f_type, i,
socket_instance_mock)
a.target = self.target
with a:
a.write_random_bit_devices(
[
(DeviceCode.M, 50, False),
(DeviceCode.Y, 0x2F, True),
],
timeout=6,
)
if f_type == "a":
data_body = b"1402000102M*00005000Y*00002F01"
else:
data_body = (b"\x02\x14\x01\x00\x02\x32\x00\x00"
b"\x90\x00\x2F\x00\x00\x9D\x01")
self.check_send_data(f_type, i, data_body,
socket_instance_mock)
def test_write_word_devices_2(self):
for f_type in ("a", "b"):
with self.subTest(ftype=f_type):
for i in (3, 4):
with self.subTest(i=i):
socket_instance_mock = mock.NonCallableMagicMock(
spec=_socket.socket)
a = self.prepare_no_res(f_type, i,
socket_instance_mock)
a.target = self.target
with a:
a.write_word_devices(
DeviceCode.D,
start_num=100,
data=[0x1995, 0x1202, 0x1130],
timeout=6,
)
if f_type == "a":
data_body = b"14010000D*0001000003199512021130"
else:
data_body = (
b"\x01\x14\x00\x00\x64\x00\x00\xA8\x03"
b"\x00\x95\x19\x02\x12\x30\x11")
self.check_send_data(f_type, i, data_body,
socket_instance_mock)
def create_test_fits(input_workspaces,
function_name,
parameters,
output_workspace_names=None,
global_parameters=None):
"""
Create a list of fits
:param input_workspaces: The input workspaces
:param function_name: The name of the function
:param parameters: The parameters list
:param output_workspace_names: A list of workspace names
:param global_parameters: An optional list of tied parameters
:return: A list of Fits
"""
output_workspace_names = output_workspace_names if output_workspace_names is not None else [
'test-output-ws'
]
# Convert parameters to fit table-like structure
fit_table = [{
'Name': name,
'Value': value,
'Error': error
} for name, (value, error) in parameters.items()]
fits = []
for name in input_workspaces:
parameter_workspace = mock.NonCallableMagicMock()
parameter_workspace.workspace.__iter__.return_value = fit_table
parameter_workspace.workspace_name = name + '_Parameters'
fits.append(
FitInformation(parameter_workspace, function_name, name,
output_workspace_names, global_parameters))
return fits
def test_read_word_devices_2(self):
for f_type in ("a", "b"):
with self.subTest(ftype=f_type):
for i in (3, 4):
with self.subTest(i=i):
socket_instance_mock = mock.NonCallableMagicMock(
spec=_socket.socket)
if f_type == "a":
data_body = b"123400021DEF"
else:
data_body = b"\x34\x12\x02\x00\xEF\x1D"
a = self.prepare(i, f_type, data_body,
socket_instance_mock)
a.target = self.target
with a:
b = a.read_word_devices(
DeviceCode.TN,
start_num=100,
count=3,
timeout=6,
)
self.assertSequenceEqual(
b, array("H", [0x1234, 0x0002, 0x1DEF]), array)
if f_type == "a":
data_body = b"04010000TN0001000003"
else:
data_body = (
b"\x01\x04\x00\x00\x64\x00\x00\xC2\x03\x00")
self.check_send_data(f_type, i, data_body,
socket_instance_mock)
def test_creates_timer_with_fixed_interval(self):
"""Test that _timer_refresh creates a timer with fixed interval if it isn't callable if it
is not stopped"""
self.treatment_log._interval = mock.NonCallableMagicMock()
self.treatment_log._timer_refresh()
self.timer_mock.assert_called_once_with(
self.treatment_log._interval, self.treatment_log._timer_refresh)
def test_read_random(self):
for f_type in ("a", "b"):
with self.subTest(ftype=f_type):
for i in (3, 4):
with self.subTest(i=i):
socket_instance_mock = mock.NonCallableMagicMock(
spec=_socket.socket)
if f_type == "a":
data_body = (
b"19951202203048494C544F4EC3DEB9AFBADDBCB7")
else:
data_body = (b"\x95\x19\x02\x12\x30\x20\x49\x48"
b"\x4e\x4f\x54\x4c\xaf\xB9\xde\xc3"
b"\xb7\xbc\xdd\xba")
a = self.prepare(i, f_type, data_body,
socket_instance_mock)
a.target = self.target
with a:
b = a.read_random_devices(
[
(DeviceCode.D, 0),
(DeviceCode.TN, 0),
(DeviceCode.M, 100),
(DeviceCode.X, 0x20),
],
[
(DeviceCode.D, 1500),
(DeviceCode.Y, 0x160),
(DeviceCode.M, 1111),
],
timeout=6,
)
self.assertTupleEqual(
b,
(
[
b"\x95\x19",
b"\x02\x12",
b"\x30\x20",
b"\x49\x48",
],
[
b"\x4E\x4F\x54\x4C",
b"\xAF\xB9\xDE\xC3",
b"\xB7\xBC\xDD\xBA",
],
),
)
if f_type == "a":
data_body = (
b"040300000403D*000000TN000000M*000100"
b"X*000020D*001500Y*000160M*001111")
else:
data_body = (
b"\x03\x04\x00\x00\x04\x03\x00\x00\x00\xa8"
b"\x00\x00\x00\xc2\x64\x00\x00\x90\x20\x00"
b"\x00\x9c\xdc\x05\x00\xa8\x60\x01\x00\x9d"
b"\x57\x04\x00\x90")
self.check_send_data(f_type, i, data_body,
socket_instance_mock)
def test_from_responsecaplarge(self):
response = mock.NonCallableMagicMock(spec=requests.Response)
response.headers = {
'content-type': 'Multipart/Related; boundary="samp1"'
}
cnt = io.BytesIO()
cnt.write(b'\r\n--samp1\r\n')
cnt.write(b'Header-1: Header-Value-1\r\n')
cnt.write(b'Header-2: Header-Value-2\r\n')
cnt.write(b'\r\n')
cnt.write(b'Body 1, Line 1\r\n')
cnt.write(b'Body 1, Line 2\r\n')
cnt.write(b'--samp1\r\n')
cnt.write(b'\r\n')
cnt.write(b'Body 2, Line 1\r\n')
cnt.write(b'--samp1--\r\n')
response.content = cnt.getvalue()
decoder_2 = MultipartDecoder.from_response(response)
assert decoder_2.content_type == response.headers['content-type']
assert (
decoder_2.parts[0].content == b'Body 1, Line 1\r\nBody 1, Line 2'
)
assert decoder_2.parts[0].headers[b'Header-1'] == b'Header-Value-1'
assert len(decoder_2.parts[1].headers) == 0
assert decoder_2.parts[1].content == b'Body 2, Line 1'
def setUp(self):
super().setUp()
self.mock_repo = mock.NonCallableMagicMock(
spec=['remotes', 'branches', 'tags'])
self.mock_repo.remotes = []
self.mock_repo.branches = []
self.mock_repo.tags = []
self.sut = Unknown(self.mock_repo, self.COMMIT_ISH_NAME)
def test_command_on_cooldown(self, clean_prefix):
error = mock.NonCallableMagicMock(spec=commands.CommandOnCooldown)
loop.run_until_complete(bot.on_command_error(self.ctx, error))
clean_prefix.assert_not_called()
error_msg = error.__str__.return_value
self.ctx.send.assert_called_once_with(error_msg)
self.assertIn(error_msg, self.output)
def get_member(joueur):
member = mock.NonCallableMagicMock(discord.Member)
member.configure_mock(
guild=config.guild,
id=joueur.discord_id,
display_name=joueur.nom,
)
return member
def setUp(self):
self.HEADERS = (Header('test_name',
'Test Label',
'column_name',
is_sortable=True), )
self.form = mock.NonCallableMagicMock(forms.Form)
self.form.prefix = None
self.form.HEADERS = self.HEADERS
def mock_config():
config.bot = mock.MagicMock(LGBot(), command_prefix="!")
config.session = mock.Mock(sqlalchemy.orm.session.Session)
config.engine = mock.Mock(sqlalchemy.engine.Engine)
config.guild = mock.NonCallableMagicMock(discord.Guild)
config.loop = mock.NonCallableMock()
_prepare_attributes(config.Role, discord.Role)
_prepare_attributes(config.Channel, discord.TextChannel)
_prepare_attributes(config.Emoji, discord.Emoji)
def test_split_sdk_machine_ip_included_if_set_as_literal(self):
"""Tests that the optional header SplitSDKMachineIP is included if set as a literal"""
some_split_sdk_machine_ip = mock.NonCallableMagicMock()
self.api._split_sdk_machine_ip = some_split_sdk_machine_ip
headers = self.api._build_headers()
self.assertNotIn(some_split_sdk_machine_ip,
headers.get('SplitSDKMachineIP'))
def test_bot_missing_permissions(self, clean_prefix):
error = mock.NonCallableMagicMock(spec=commands.BotMissingPermissions)
loop.run_until_complete(bot.on_command_error(self.ctx, error))
clean_prefix.assert_not_called()
error_msg = 'This command cannot be used in this context.\n{}'\
.format(error.__str__.return_value)
self.ctx.send.assert_called_once_with(error_msg)
self.assertIn(error_msg, self.output)
def test_check_failure(self, clean_prefix):
error = mock.NonCallableMagicMock(spec=commands.CheckFailure)
loop.run_until_complete(bot.on_command_error(self.ctx, error))
clean_prefix.assert_not_called()
error_msg = 'This command cannot be used in this context.\n' \
'{}'.format(error.__str__.return_value)
self.ctx.send.assert_called_once_with(error_msg)
self.assertIn(error_msg, self.output)
def makeSut(self, exists_locally, exists_remotely):
existing_commit = mock.NonCallableMagicMock()
# Hex SHAs in git.Repo objects are always lower case:
existing_commit.hexsha = self.HEXSHA.lower()
other_commit = mock.NonCallableMagicMock()
other_commit.hexsha = '01' * 20
if exists_remotely:
def side_effect(*args, **kwargs):
self.mock_repo.commit = mock.MagicMock(
return_value=existing_commit)
return []
self.mock_remote.fetch = mock.MagicMock(side_effect=side_effect)
self.mock_repo.commit = (
mock.MagicMock(return_value=existing_commit)
if exists_locally
else mock.MagicMock(side_effect=git.BadName('fake')))
self.sut = Hexsha(self.mock_repo, self.HEXSHA)
return self.sut
def test_closeEvent_saves_window_state(self):
self.toolbox._qsettings = mock.NonCallableMagicMock()
self.toolbox._perform_pre_exit_tasks = mock.MagicMock(
return_value=True)
self.toolbox.julia_repl = mock.NonCallableMagicMock()
self.toolbox.python_console = mock.NonCallableMagicMock()
self.toolbox.closeEvent(mock.MagicMock())
qsettings_save_calls = self.toolbox._qsettings.setValue.call_args_list
self.assertEqual(len(qsettings_save_calls), 6)
saved_dict = {
saved[0][0]: saved[0][1]
for saved in qsettings_save_calls
}
self.assertIn("appSettings/previousProject", saved_dict)
self.assertIn("mainWindow/windowSize", saved_dict)
self.assertIn("mainWindow/windowPosition", saved_dict)
self.assertIn("mainWindow/windowState", saved_dict)
self.assertIn("mainWindow/windowMaximized", saved_dict)
self.assertIn("mainWindow/n_screens", saved_dict)
def get_chan(joueur):
chan = mock.NonCallableMagicMock(discord.TextChannel)
chan.configure_mock(
guild=config.guild,
id=joueur.chan_id_,
name=(config.private_chan_prefix
+ joueur.nom.lower().replace(" ", "-")),
send=mock.AsyncMock(discord.TextChannel.send),
)
return chan
def test_fetch_tenor(self):
"""Unit tests for IA.fetch_tenor function."""
# def fetch_tenor(trigger)
fetch_tenor = IA.fetch_tenor
# request failed
payload = mock.NonCallableMagicMock(__bool__=lambda self: False)
with mock.patch("requests.get", return_value=payload):
gif = fetch_tenor("bzzt")
self.assertIs(None, gif)
# no results
payload = mock.NonCallableMagicMock(__bool__=lambda self: True,
json=lambda: {"results": []})
with mock.patch("requests.get", return_value=payload):
gif = fetch_tenor("bzzt")
self.assertIs(None, gif)
# one result
payload = mock.NonCallableMagicMock(
__bool__=lambda self: True,
json=lambda: {"results": [{
"itemurl": "bzoot"
}]})
with mock.patch("requests.get", return_value=payload):
gif = fetch_tenor("bzzt")
self.assertEqual("bzoot", gif)
# more results
payload = mock.NonCallableMagicMock(
__bool__=lambda self: True,
json=lambda: {
"results": [{
"itemurl": "bzoot"
}, {
"itemurl": "notyou"
}, {
"itemurl": "uneither"
}]
})
with mock.patch("requests.get", return_value=payload):
gif = fetch_tenor("bzzt")
self.assertEqual("bzoot", gif)
def setUp(self):
super(TC_00_API_Misc, self).setUp()
self.src = mock.NonCallableMagicMock()
self.app = mock.NonCallableMock()
self.dest = mock.NonCallableMock()
self.dest.name = 'dom0'
self.app.configure_mock(domains={
'dom0': self.dest,
'test-vm': self.src,
})
def test_write_random_word(self):
for f_type in ("a", "b"):
with self.subTest(ftype=f_type):
for i in (3, 4):
with self.subTest(i=i):
socket_instance_mock = mock.NonCallableMagicMock(
spec=_socket.socket)
a = self.prepare_no_res(f_type, i,
socket_instance_mock)
a.target = self.target
with a:
a.write_random_word_devices(
[
(DeviceCode.D, 0, b"\x50\x05"),
(DeviceCode.D, 1, b"\x75\x05"),
(DeviceCode.M, 100, b"\x40\x05"),
(DeviceCode.X, 0x20, b"\x83\x05"),
],
[
(
DeviceCode.D,
1500,
b"\x02\x12\x39\x04",
),
(
DeviceCode.Y,
0x160,
b"\x07\x26\x75\x23",
),
(
DeviceCode.M,
1111,
b"\x75\x04\x25\x04",
),
],
timeout=6,
)
if f_type == "a":
data_body = (b"140200000403D*0000000550"
b"D*0000010575M*0001000540"
b"X*0000200583"
b"D*00150004391202"
b"Y*00016023752607"
b"M*00111104250475")
else:
data_body = (b"\x02\x14\x00\x00\x04\x03"
b"\x00\x00\x00\xA8\x50\x05"
b"\x01\x00\x00\xA8\x75\x05"
b"\x64\x00\x00\x90\x40\x05"
b"\x20\x00\x00\x9C\x83\x05"
b"\xDC\x05\x00\xA8\x02\x12\x39\x04"
b"\x60\x01\x00\x9D\x07\x26\x75\x23"
b"\x57\x04\x00\x90\x75\x04\x25\x04")
self.check_send_data(f_type, i, data_body,
socket_instance_mock)
def test_command_invoke_error(self, clean_prefix):
error = mock.NonCallableMock(spec=commands.CommandInvokeError)
error.original = mock.NonCallableMagicMock()
with self.assertLogs('cardinal.bot', logging.ERROR):
loop.run_until_complete(bot.on_command_error(self.ctx, error))
clean_prefix.assert_not_called()
error_msg = 'An error occurred while executing the command.'
self.ctx.send.assert_called_once_with(error_msg)
self.assertIn(error_msg, self.output)
