def make_mock_editor_window(self):
"""Create a mock EditorWindow instance."""
editwin = NonCallableMagicMock()
# isinstance(editwin, PyShell) must be true for Squeezer to enable
# auto-squeezing; in practice this will always be true
editwin.__class__ = PyShell
return editwin
def make_mock_editor_window(self, with_text_widget=False):
"""Create a mock EditorWindow instance."""
editwin = NonCallableMagicMock()
# isinstance(editwin, PyShell) must be true for Squeezer to enable
# auto-squeezing; in practice this will always be true.
editwin.__class__ = PyShell
if with_text_widget:
editwin.root = get_test_tk_root(self)
text_widget = self.make_text_widget(root=editwin.root)
editwin.text = editwin.per.bottom = text_widget
return editwin
def test_arg_lists(self):
mocks = [
Mock(),
MagicMock(),
NonCallableMock(),
NonCallableMagicMock()
]
def assert_attrs(mock):
names = 'call_args_list', 'method_calls', 'mock_calls'
for name in names:
attr = getattr(mock, name)
self.assertIsInstance(attr, _CallList)
self.assertIsInstance(attr, list)
self.assertEqual(attr, [])
for mock in mocks:
assert_attrs(mock)
if callable(mock):
mock()
mock(1, 2)
mock(a=3)
mock.reset_mock()
assert_attrs(mock)
mock.foo()
mock.foo.bar(1, a=3)
mock.foo(1).bar().baz(3)
mock.reset_mock()
assert_attrs(mock)
def test_get_from_twitter_api(self,
twitter_user_init_mock: MagicMock) -> None:
api_mock = NonCallableMagicMock()
api_mock_user_info = api_mock.get_user.return_value
api_mock_user_info.name = TWITTER_USER_SAMPLE['name']
api_mock_user_info.screen_name = TWITTER_USER_SAMPLE['screen_name']
api_mock_user_info.id = TWITTER_USER_SAMPLE['id']
api_mock_user_info.profile_image_url_https = TWITTER_USER_SAMPLE[
'profile_image_url']
twitter_user_init_mock.return_value = None
user = TwitterUser.get_from_twitter_api( # type: ignore
api_mock, TWITTER_USER_SAMPLE['screen_name'])
api_mock.get_user.assert_called_once_with(
TWITTER_USER_SAMPLE['screen_name'])
twitter_user_init_mock.assert_called_once_with(
name=TWITTER_USER_SAMPLE['name'],
screen_name=TWITTER_USER_SAMPLE['screen_name'],
user_id=TWITTER_USER_SAMPLE['id'],
profile_image_url=TWITTER_USER_SAMPLE['profile_image_url'],
)
self.assertIsInstance(user, TwitterUser)
def test_stats_read_only(self, super_mock):
mock = NonCallableMagicMock(wraps=MockFile(ZEN), autospec=True)
super_mock.mock_object = mock
with MeteredFile() as file:
self.assertEqual(0, file.read_ops)
self.assertEqual(0, file.read_bytes)
for _ in range(57):
file.read(1)
file.read(2)
self.assertEqual(58, file.read_ops)
self.assertEqual(59, file.read_bytes)
self.assertEqual(0, file.write_ops)
self.assertEqual(0, file.write_bytes)
for _ in range(77):
file.write(b"b")
file.write(b"bytes")
self.assertEqual(78, file.write_ops)
self.assertEqual(82, file.write_bytes)
with self.assertRaisesRegex(AttributeError, "can't set"):
file.write_ops = 0
with self.assertRaisesRegex(AttributeError, "can't set"):
file.write_bytes = 0
with self.assertRaisesRegex(AttributeError, "can't set"):
file.read_ops = 0
with self.assertRaisesRegex(AttributeError, "can't set"):
file.read_bytes = 0
self.assertEqual(78, file.write_ops)
self.assertEqual(82, file.write_bytes)
self.assertEqual(58, file.read_ops)
self.assertEqual(59, file.read_bytes)
def test_stats_read_only(self):
mock = NonCallableMagicMock(wraps=MockSock(), autospec=True)
with MeteredSocket(mock) as socket:
self.assertEqual(0, socket.send_ops)
self.assertEqual(0, socket.send_bytes)
self.assertEqual(0, socket.recv_ops)
self.assertEqual(0, socket.recv_bytes)
for _ in range(277):
socket.send(b"b")
socket.send(b"bytes")
for _ in range(257):
socket.recv(1)
socket.recv(2)
self.assertEqual(278, socket.send_ops)
self.assertEqual(282, socket.send_bytes)
self.assertEqual(258, socket.recv_ops)
self.assertEqual(259, socket.recv_bytes)
with self.assertRaisesRegex(AttributeError, "can't set"):
socket.send_ops = 0
with self.assertRaisesRegex(AttributeError, "can't set"):
socket.send_bytes = 0
with self.assertRaisesRegex(AttributeError, "can't set"):
socket.recv_ops = 0
with self.assertRaisesRegex(AttributeError, "can't set"):
socket.recv_bytes = 0
self.assertEqual(278, socket.send_ops)
self.assertEqual(282, socket.send_bytes)
self.assertEqual(258, socket.recv_ops)
self.assertEqual(259, socket.recv_bytes)
def test_meteredsocket_recv_once(self):
mock = NonCallableMagicMock(wraps=MockSock(), autospec=True)
with MeteredSocket(mock) as socket:
actual_recv = socket.recv(4096)
self.assertEqual(ZEN, actual_recv)
self.assertEqual(1, socket.recv_ops)
self.assertEqual(len(ZEN), socket.recv_bytes)
self.assertEqual(1, mock.recv.call_count)
async def test_validation_exception_handler_returns_response_as_expected(
mock_json_response):
error_stub = NonCallableMagicMock()
error_stub.errors = MagicMock()
error_stub.errors.return_value = [
{
"loc": [f"{LOCATION}1"],
"msg": f"{MESSAGE}1",
"type": f"{TYPE}1"
},
{
"loc": [f"{LOCATION}2"],
"msg": f"{MESSAGE}2",
"type": f"{TYPE}2"
},
]
response = await validation_exception_handler(MagicMock(), error_stub)
mock_json_response.assert_called_once_with(
status_code=400,
content={
"errors": [
{
"status": BAD_REQUEST_STATUS,
"code": BAD_REQUEST_CODE,
"title": BAD_REQUEST_TITLE,
"detail": {
"location": [f"{LOCATION}1"],
"message": f"{MESSAGE}1",
"type": f"{TYPE}1",
},
},
{
"status": BAD_REQUEST_STATUS,
"code": BAD_REQUEST_CODE,
"title": BAD_REQUEST_TITLE,
"detail": {
"location": [f"{LOCATION}2"],
"message": f"{MESSAGE}2",
"type": f"{TYPE}2",
},
},
]
},
)
assert isinstance(response, JSONResponse)
def test_attribute_deletion(self):
for mock in (Mock(), MagicMock(), NonCallableMagicMock(),
NonCallableMock()):
self.assertTrue(hasattr(mock, 'm'))
del mock.m
self.assertFalse(hasattr(mock, 'm'))
del mock.f
self.assertFalse(hasattr(mock, 'f'))
self.assertRaises(AttributeError, getattr, mock, 'f')
def test_meteredsocket_recv_under_size(self):
wrapped = MockSock(chunk=257) # largish odd number
mock = NonCallableMagicMock(wraps=wrapped, autospec=True)
with MeteredSocket(mock) as socket:
actual_recv = socket.recv(4096)
self.assertEqual(ZEN[:257], actual_recv)
self.assertEqual(1, socket.recv_ops)
self.assertEqual(257, socket.recv_bytes)
self.assertEqual(1, mock.recv.call_count)
def test_no_effect(self):
DataCollector().configure()
sql, _ = mock_sql()
sql.query.model = NonCallableMagicMock(spec_set=['__module__'])
sql.query.model.__module__ = 'silk.models'
# No SQLQuery models should be created for silk requests for obvious reasons
with patch('silk.sql.DataCollector', return_value=Mock()) as mock_DataCollector:
execute_sql(sql)
self.assertFalse(mock_DataCollector().register_query.call_count)
def test_get_twitter_user_timeline_has_last_id(self) -> None:
api_mock = NonCallableMagicMock()
user_mock = NonCallableMagicMock()
since_id = 123456789
statuses = get_twitter_user_timeline(
api=api_mock,
user=user_mock,
since_id=since_id,
)
self.assertEqual(statuses, api_mock.user_timeline.return_value)
api_mock.user_timeline.assert_called_once_with(
screen_name=user_mock.screen_name,
tweet_mode='extended',
trim_user=True,
since_id=since_id,
exclude_replies=True,
)
async def test_http_exception_handler_method_not_allowed_returns_405(
mock_json_response):
exception_stub = NonCallableMagicMock()
exception_stub.detail = "Method Not Allowed"
exception_stub.status_code = 405
response = await http_exception_handler(NonCallableMagicMock(),
exception_stub)
mock_json_response.assert_called_once_with(
status_code=405,
content={
"errors": [{
"status": "405",
"code": "MethodNotAllowed",
"title": "Method Not Allowed",
"detail": "Method Not Allowed",
}]
},
)
assert isinstance(response, JSONResponse)
async def test_http_exception_handler_resource_not_found_returns_404(
mock_json_response):
exception_stub = NonCallableMagicMock()
exception_stub.detail = "not found"
exception_stub.status_code = 404
response = await http_exception_handler(NonCallableMagicMock(),
exception_stub)
mock_json_response.assert_called_once_with(
status_code=404,
content={
"errors": [{
"status": "404",
"code": "NotFound",
"title": "Not Found",
"detail": "Missing Resource URI",
}]
},
)
assert isinstance(response, JSONResponse)
def test_report_download_finished(self, _error, _info, _confirm, tqdm, _position_after_bars):
items = [NonCallableMagicMock(), NonCallableMagicMock()]
tqdm.side_effect = items
with thespiae.cli.CLI('thespiae') as ui:
ui.feedback.confirm_operations([DownloadSpec(name='test'), DownloadSpec(name='test2')], [], [])
ui.feedback.report_entry_download_initiated(DownloadSpec(name='test'))
ui.feedback.report_entry_download_initiated(DownloadSpec(name='test2'))
ui.feedback.report_entry_download_started(DownloadSpec(name='test'), 5)
ui.feedback.report_entry_download_started(DownloadSpec(name='test2'), 10)
ui.feedback.report_entry_download_progress(DownloadSpec(name='test'), 5)
ui.feedback.report_entry_download_progress(DownloadSpec(name='test2'), 10)
ui.feedback.report_download_finished()
_info.assert_called()
_error.assert_not_called()
_confirm.assert_called()
self.assertEqual(tqdm.call_count, 2)
_position_after_bars.assert_called_once_with(2)
self.assertSequenceEqual(items[0].method_calls, [call.refresh(), call.update(5), call.refresh(), call.close()])
self.assertSequenceEqual(items[1].method_calls, [call.refresh(), call.update(10), call.refresh(), call.close()])
def test_meteredfile_read_under_size(self, super_mock):
wrapped = MockFile(ZEN, chunk=257) # largish odd number
mock = NonCallableMagicMock(wraps=wrapped, autospec=True)
super_mock.mock_object = mock
with MeteredFile() as file:
actual_read = file.read()
self.assertEqual(ZEN[:257], actual_read)
self.assertEqual(1, file.read_ops)
self.assertEqual(257, file.read_bytes)
self.assertEqual(1, mock.read.call_count)
async def test_http_exception_handler_returns_as_expected(mock_json_response):
detail = "fooDetail"
exception_stub = NonCallableMagicMock()
exception_stub.detail = detail
exception_stub.status_code = 500
response = await http_exception_handler(NonCallableMagicMock(),
exception_stub)
mock_json_response.assert_called_once_with(
status_code=500,
content={
"errors": [{
"status": "500",
"code": "InternalServerError",
"title": "Internal Server Error",
"detail": detail,
}]
},
)
assert isinstance(response, JSONResponse)
def test_meteredsocket_send_under_size(self):
wrapped = MockSock(chunk=257) # largish odd number
mock = NonCallableMagicMock(wraps=wrapped, autospec=True)
with MeteredSocket(mock) as socket:
send_len = socket.send(ZEN[:123])
self.assertEqual(ZEN[:123], wrapped._sender.getbuffer())
self.assertEqual(123, send_len)
self.assertEqual(1, socket.send_ops)
self.assertEqual(123, socket.send_bytes)
self.assertEqual(1, mock.send.call_count)
def test_handle_dag_changed(self):
"""Tests that upstream resource files are listed in the Importer view."""
self.importer.activate()
item = NonCallableMagicMock()
expected_file_list = ["url1", "url2"]
resources = [ProjectItemResource(item, "file", url) for url in expected_file_list]
self.importer._do_handle_dag_changed(resources)
model = self.importer._properties_ui.treeView_files.model()
file_list = [model.index(row, 0).data(Qt.DisplayRole) for row in range(model.rowCount())]
self.assertEqual(sorted(file_list), sorted(expected_file_list))
def test_generate_from_twitter_status_without_full_text_and_media(self) -> None:
user_mock = get_user_mock()
status_mock = NonCallableMagicMock(spec=['id', 'text'])
status_mock.id = TWITTER_STATUS_SAMPLE['id']
status_mock.text = TWITTER_STATUS_SAMPLE['text']
post = DiscordPost.generate_from_twitter_status(user=user_mock, status=status_mock)
self.assertIsInstance(post, DiscordPost)
self.assertEqual(post.username, TWITTER_USER_SAMPLE['name'])
self.assertEqual(post.avatar_url, TWITTER_USER_SAMPLE['profile_image_url_orig'])
self.assertEqual(
post.content,
(f'<http://twitter.com/{TWITTER_USER_SAMPLE["screen_name"]}/status/'
f'{TWITTER_STATUS_SAMPLE["id"]}>\n'
f'{TWITTER_STATUS_SAMPLE["text"]}')
)
self.assertIsNone(post.embeds)
def test_meteredsocket_recv_multiple(self):
wrapped = MockSock()
mock = NonCallableMagicMock(wraps=wrapped, autospec=True)
actual_recv = b""
with MeteredSocket(mock) as socket:
for _ in range(5):
actual_recv += socket.recv(30)
self.assertEqual(ZEN[:150], actual_recv)
self.assertEqual(5, socket.recv_ops)
self.assertEqual(150, socket.recv_bytes)
self.assertEqual(5, mock.recv.call_count)
def test_meteredfile_write_under_size(self, super_mock):
wrapped = MockFile(chunk=257) # largish odd number
mock = NonCallableMagicMock(wraps=wrapped, autospec=True)
super_mock.mock_object = mock
with MeteredFile() as file:
write_len = file.write(ZEN[:123])
self.assertEqual(ZEN[:123], wrapped.getbuffer())
self.assertEqual(123, write_len)
self.assertEqual(1, file.write_ops)
self.assertEqual(123, file.write_bytes)
self.assertEqual(1, mock.write.call_count)
async def test_notfound_exception_handler_returns_as_expected(
mock_json_response):
detail = "Detail"
exception_stub = NonCallableMagicMock()
exception_stub.detail = detail
exception_stub.status_code = 404
response = await notfound_exception_handler(NonCallableMagicMock(),
exception_stub)
mock_json_response.assert_called_once_with(
status_code=404,
content={
"errors": [{
"status": "404",
"code": "NotFound",
"title": "Not Found",
"detail": detail,
}]
},
)
assert isinstance(response, JSONResponse)
def test_notify_destination(self):
self.toolbox.msg_warning = NonCallableMagicMock()
self.toolbox.msg_warning.attach_mock(MagicMock(), "emit")
item = ProjectItem("name", "description", 0.0, 0.0,
self.toolbox.project(), self.toolbox)
item.item_type = MagicMock(return_value="item_type")
item.notify_destination(item)
self.toolbox.msg_warning.emit.assert_called_with(
"Link established."
" Interaction between a <b>item_type</b> and a <b>item_type</b> has not been implemented yet."
)
def test_recv_multiple_chunk(self):
wrapped = MockSock(chunk=20)
mock = NonCallableMagicMock(wraps=wrapped, autospec=True)
actual_recv = b""
with MeteredSocket(mock) as socket:
for _ in range(5):
actual_recv += socket.recv(4096)
actual_recv += socket.recv(10)
self.assertEqual(ZEN[:110], actual_recv)
self.assertEqual(6, socket.recv_ops)
self.assertEqual(110, socket.recv_bytes)
self.assertEqual(6, mock.recv.call_count)
def test_meteredfile_read_multiple(self, super_mock):
wrapped = MockFile(ZEN)
mock = NonCallableMagicMock(wraps=wrapped, autospec=True)
super_mock.mock_object = mock
actual_read = b""
with MeteredFile() as file:
for _ in range(5):
actual_read += file.read(30)
self.assertEqual(ZEN[:150], actual_read)
self.assertEqual(5, file.read_ops)
self.assertEqual(150, file.read_bytes)
self.assertEqual(5, mock.read.call_count)
def play_sends_command(self, command: str) -> int:
"""User sends a command to the bot in PM"""
self._reset_stage()
update = NonCallableMagicMock()
update.message.chat.id = self.user_id
update.message.from_user.id = self.user_id
update.message.from_user.first_name = self.first_name
method = getattr(self.gatebot, f'command_{command}')
with self._gatebot_env():
method(self.last_bot_mock, update)
def _get_user_mock(screen_name: Any = TWITTER_USER_SAMPLE['screen_name']) -> NonCallableMagicMock:
user_mock = NonCallableMagicMock(spec=TwitterUser)
user_mock.name = TWITTER_USER_SAMPLE['name']
user_mock.screen_name = screen_name
user_mock.user_id = TWITTER_USER_SAMPLE['id']
user_mock.profile_image_url = TWITTER_USER_SAMPLE['profile_image_url_orig']
return user_mock
def test_generate_from_twitter_status_has_video(self) -> None:
user_mock = _get_user_mock()
status_mock = NonCallableMagicMock(
spec=['id', 'text', 'text', 'full_text', 'extended_entities'])
status_mock.id = TWITTER_STATUS_SAMPLE['id']
status_mock.text = TWITTER_STATUS_SAMPLE['text']
status_mock.full_text = TWITTER_STATUS_SAMPLE['full_text']
status_mock.extended_entities = {
'media': [
{
'type': 'video',
'media_url_https':
TWITTER_STATUS_SAMPLE['media_url_https'],
},
]
}
post = DiscordPost.generate_from_twitter_status(user=user_mock,
status=status_mock)
self.assertIsInstance(post, DiscordPost)
self.assertEqual(post.username, TWITTER_USER_SAMPLE['name'])
self.assertEqual(post.avatar_url,
TWITTER_USER_SAMPLE['profile_image_url_orig'])
self.assertEqual(
post.content,
(f'http://twitter.com/{TWITTER_USER_SAMPLE["screen_name"]}/status/'
f'{TWITTER_STATUS_SAMPLE["id"]}'))
self.assertIsNone(post.embeds)
def test_post_tweets_to_discord(
self, generate_from_twitter_status_mock: MagicMock) -> None:
user_mock = NonCallableMagicMock()
webhook_url = DISCORD_WEBHOOK_SAMPLE
status_number = 10
status_mocks = [NonCallableMagicMock() for _ in range(status_number)]
generate_from_twitter_status_mock.return_value.save.side_effect = [
200, 201, 204, 304, 400, 401, 403, 404, 405, 429
]
_post_tweets_to_discord(user=user_mock,
statuses=status_mocks,
webhook_url=webhook_url)
self.assertEqual(generate_from_twitter_status_mock.call_args_list,
[({
'user': user_mock,
'status': status
}, ) for status in reversed(status_mocks)])
self.assertEqual(
generate_from_twitter_status_mock.return_value.save.call_count,
status_number)
def session():
response = NonCallableMock(requests.Response)
response.elapsed = timedelta(seconds=1.23)
response.status_code = 402
response.headers = {"Header-Name": "Header-Value"}
response.text = sentinel.text
response.content = sentinel.content
session = NonCallableMagicMock(requests.Session)
session.__enter__.return_value = session
session.rebuild_proxies.return_value = sentinel.proxies
session.send.return_value = response
return session
def test_item_dict(self):
project = MagicMock()
project.items_dir = "item_directory/"
item = ProjectItem("item name", "Item's description.", -2.3, 5.5,
project, None)
item.item_type = MagicMock(return_value="item type")
point = NonCallableMagicMock()
point.x = MagicMock(return_value=-2.3)
point.y = MagicMock(return_value=5.5)
sceneBoundingRect = NonCallableMagicMock()
sceneBoundingRect.center = MagicMock(return_value=point)
icon = NonCallableMagicMock()
icon.sceneBoundingRect = MagicMock(return_value=sceneBoundingRect)
item.get_icon = MagicMock(return_value=icon)
item_dict = item.item_dict()
expected = {
"type": "item type",
"description": "Item's description.",
"x": -2.3,
"y": 5.5
}
self.assertEqual(item_dict, expected)
