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)