def _mock_rachio_return_value(get=None, getInfo=None): rachio_mock = MagicMock() person_mock = MagicMock() type(person_mock).get = MagicMock(return_value=get) type(person_mock).getInfo = MagicMock(return_value=getInfo) type(rachio_mock).person = person_mock return rachio_mock
def setUp(self): super().setUp() self.args = self.args._replace(field='url', nick='megotsthis', message=Message('a query'), param='http://localhost/') patcher = patch('bot.config', autospec=True) self.addCleanup(patcher.stop) self.mock_config = patcher.start() self.mock_config.customMessageUrlTimeout = 1 self.mock_response = MagicMock(spec=aiohttp.ClientResponse) self.mock_response.__aenter__.return_value = self.mock_response self.mock_response.__aexit__.return_value = False self.mock_response.status = 200 self.mock_response.text.return_value = 'Kappa' self.mock_session = MagicMock(spec=aiohttp.ClientSession) self.mock_session.__aenter__.return_value = self.mock_session self.mock_session.__aexit__.return_value = False self.mock_session.get.return_value = self.mock_response patcher = patch('aiohttp.ClientSession') self.addCleanup(patcher.stop) self.mock_clientsession = patcher.start() self.mock_clientsession.return_value = self.mock_session
def setUp(self): self.now = datetime(2000, 1, 1) self.channel = Mock(spec=Channel) self.channel.channel = 'botgotsthis' self.channel.sessionData = {} self.data = Mock(spec=CacheStore) self.database = MagicMock(spec=DatabaseMain) self.database.__aenter__.return_value = self.database self.database.__aexit__.return_value = False self.permissionSet = { 'owner': False, 'manager': False, 'staff': False, 'admin': False, 'globalMod': False, } self.permissions = MagicMock(spec=WhisperPermissionSet) self.permissions.__getitem__.side_effect = \ lambda k: self.permissionSet[k] self.args = WhisperCommandArgs(self.data, 'botgotsthis', Message(''), self.permissions, self.now) patcher = patch.object(DatabaseMain, 'acquire') self.addCleanup(patcher.stop) self.mock_database = patcher.start() self.mock_database.return_value = self.database
def setUp(self): self.now = datetime(2000, 1, 1) self.send = Mock(spec=send) self.data = Mock(spec=CacheStore) self.database = MagicMock(spec=DatabaseMain) self.database.__aenter__.return_value = self.database self.database.__aexit__.return_value = False self.permissionSet = { 'owner': False, 'manager': False, 'inOwnerChannel': False, 'staff': False, 'admin': False, 'globalMod': False, 'broadcaster': False, 'moderator': False, 'subscriber': False, 'permitted': False, 'chatModerator': False, 'bannable': True, } self.permissions = MagicMock(spec=ChatPermissionSet) self.permissions.__getitem__.side_effect = \ lambda k: self.permissionSet[k] self.args = ManageBotArgs(self.data, self.permissions, self.send, 'botgotsthis', Message('')) patcher = patch.object(DatabaseMain, 'acquire') self.addCleanup(patcher.stop) self.mock_database = patcher.start() self.mock_database.return_value = self.database
async def test_assignment_change(subscriber, assigner, subscriber_factory): assign_queues = wire_queues(assigner.get_assignment) async with subscriber: await assign_queues.called.get() sub1 = mock_async_context_manager( MagicMock(spec=AsyncSingleSubscriber)) sub2 = mock_async_context_manager( MagicMock(spec=AsyncSingleSubscriber)) sub3 = mock_async_context_manager( MagicMock(spec=AsyncSingleSubscriber)) subscriber_factory.side_effect = ( lambda partition: sub1 if partition == Partition(1) else sub2 if partition == Partition(2) else sub3) await assign_queues.results.put({Partition(1), Partition(2)}) await assign_queues.called.get() subscriber_factory.assert_has_calls( [call(Partition(1)), call(Partition(2))], any_order=True) sub1.__aenter__.assert_called_once() sub2.__aenter__.assert_called_once() await assign_queues.results.put({Partition(1), Partition(3)}) await assign_queues.called.get() subscriber_factory.assert_has_calls( [call(Partition(1)), call(Partition(2)), call(Partition(3))], any_order=True) sub3.__aenter__.assert_called_once() sub2.__aexit__.assert_called_once() sub1.__aexit__.assert_called_once() sub2.__aexit__.assert_called_once() sub3.__aexit__.assert_called_once()
def setUp(self): patcher1 = patch('charlesbot_pagerduty_escalations.pagerdutyescalations.PagerdutyEscalations.load_config') # NOQA self.addCleanup(patcher1.stop) self.mock_load_config = patcher1.start() patcher2 = patch('charlesbot_pagerduty_escalations.pagerdutyescalations.SlackUser') # NOQA self.addCleanup(patcher2.stop) self.mock_slack_user = patcher2.start() patcher3 = patch('charlesbot_pagerduty_escalations.pagerdutyescalations.http_post_request') # NOQA self.addCleanup(patcher3.stop) self.mock_http_post_request = patcher3.start() patcher4 = patch('charlesbot_pagerduty_escalations.pagerdutyescalations.PagerdutyEscalations.get_trigger_payload') # NOQA self.addCleanup(patcher4.stop) self.mock_get_trigger_payload = patcher4.start() self.slack_message = SlackMessage(type="message", user="******", channel="C2147483705", text="This is a dummy message") from charlesbot_pagerduty_escalations.pagerdutyescalations import PagerdutyEscalations # NOQA self.pd = PagerdutyEscalations() self.pd.slack = MagicMock() self.pd.slack.send_channel_message = MagicMock() self.pd.pd_service_mappings = { "service1": "pd_key_1" }
def setUp(self): self.now = datetime(2000, 1, 1) self.tags = IrcMessageTags() self.channel = Mock(spec=Channel) self.channel.channel = 'botgotsthis' self.data = Mock(spec=CacheStore) self.database = MagicMock(spec=DatabaseMain) self.database.__aenter__.return_value = self.database self.database.__aexit__.return_value = False self.permissionSet = { 'owner': False, 'inOwnerChannel': False, 'staff': False, 'admin': False, 'globalMod': False, 'broadcaster': False, 'moderator': False, 'subscriber': False, 'chatModerator': False, } self.permissions = MagicMock(spec=ChatPermissionSet) self.permissions.inOwnerChannel = False self.permissions.__getitem__.side_effect = \ lambda k: self.permissionSet[k] self.messages = ['Kappa'] self.args = CustomProcessArgs(self.data, self.channel, self.tags, 'botgotsthis', self.permissions, 'botgotsthis', '', 'kappa', self.messages) patcher = patch.object(DatabaseMain, 'acquire') self.addCleanup(patcher.stop) self.mock_database = patcher.start() self.mock_database.return_value = self.database
def setUp(self): super().setUp() self.patch('stig.objects', srvapi=self.srvapi) self.mock_display_details = MagicMock() self.patch('stig.commands.cli.TorrentDetailsCmd', select_torrents=mock_select_torrents, display_details=self.mock_display_details)
def test_exit_cleanly_multiple_plugins(self): plugin1 = MagicMock() plugin2 = MagicMock() self.robot.plugin_list = [plugin1, plugin2] self.robot.exit_cleanly() self.assertEqual(self.robot.is_running(), False) self.assertFalse(plugin1.is_running) self.assertFalse(plugin2.is_running)
def mock_google_config_store(agent_user_ids=None): """Fake a storage for google assistant.""" store = MagicMock(spec=helpers.GoogleConfigStore) if agent_user_ids is not None: store.agent_user_ids = agent_user_ids else: store.agent_user_ids = {} return store
def _generate_mock_feed_entry(external_id, title, distance_to_home, coordinates): """Construct a mock feed entry for testing purposes.""" feed_entry = MagicMock() feed_entry.external_id = external_id feed_entry.title = title feed_entry.distance_to_home = distance_to_home feed_entry.coordinates = coordinates return feed_entry
async def test_process_log(self, mockopen): file_mock = MagicMock() file_mock.__aenter__ = CoroutineMock() file_mock.__aenter__.return_value = file_mock file_mock.__aexit__ = CoroutineMock() file_mock.__aexit__.return_value = True mockopen.return_value = file_mock bot.coroutine.logging._queue = deque([('log', 'Kappa')]) await bot.coroutine.logging._process_log() self.assertTrue(mockopen.called) self.assertTrue(file_mock.write.called)
def setUp(self): super().setUp() self.mock_get_relative_path_from_focused = MagicMock() self.mock_select_torrents = MagicMock() self.mock_srvapi = MagicMock() self.mock_srvapi.torrent.torrents = CoroutineMock() self.mock_srvapi.torrent.rename = CoroutineMock() self.patch('stig.objects', srvapi=self.mock_srvapi) self.patch('stig.commands.cli.RenameCmd', select_torrents=self.mock_select_torrents, get_relative_path_from_focused=self.mock_get_relative_path_from_focused)
async def setUp(self): # mock out responses self.mock_response = MagicMock() self.mock_response.text = CoroutineMock() @asynccontextmanager async def get(*args, **kwargs): yield self.mock_response self.mock_session = MagicMock() self.mock_session.get = get
async def test_form(hass): """Test we get the form.""" await setup.async_setup_component(hass, "persistent_notification", {}) result = await hass.config_entries.flow.async_init( DOMAIN, context={"source": config_entries.SOURCE_USER} ) assert result["type"] == "form" assert result["errors"] == {} with patch( "homeassistant.components.nexia.config_flow.NexiaHome.get_name", return_value="myhouse", ), patch( "homeassistant.components.nexia.config_flow.NexiaHome.login", side_effect=MagicMock(), ), patch( "homeassistant.components.nexia.async_setup", return_value=True ) as mock_setup, patch( "homeassistant.components.nexia.async_setup_entry", return_value=True, ) as mock_setup_entry: result2 = await hass.config_entries.flow.async_configure( result["flow_id"], {CONF_USERNAME: "******", CONF_PASSWORD: "******"}, ) assert result2["type"] == "create_entry" assert result2["title"] == "myhouse" assert result2["data"] == { CONF_USERNAME: "******", CONF_PASSWORD: "******", } await hass.async_block_till_done() assert len(mock_setup.mock_calls) == 1 assert len(mock_setup_entry.mock_calls) == 1
async def _mock_setup_august_with_api_side_effects(hass, api_call_side_effects): api_instance = MagicMock(name="Api") if api_call_side_effects["get_lock_detail"]: type(api_instance).async_get_lock_detail = CoroutineMock( side_effect=api_call_side_effects["get_lock_detail"]) if api_call_side_effects["get_operable_locks"]: type(api_instance).async_get_operable_locks = CoroutineMock( side_effect=api_call_side_effects["get_operable_locks"]) if api_call_side_effects["get_doorbells"]: type(api_instance).async_get_doorbells = CoroutineMock( side_effect=api_call_side_effects["get_doorbells"]) if api_call_side_effects["get_doorbell_detail"]: type(api_instance).async_get_doorbell_detail = CoroutineMock( side_effect=api_call_side_effects["get_doorbell_detail"]) if api_call_side_effects["get_house_activities"]: type(api_instance).async_get_house_activities = CoroutineMock( side_effect=api_call_side_effects["get_house_activities"]) if api_call_side_effects["lock_return_activities"]: type(api_instance).async_lock_return_activities = CoroutineMock( side_effect=api_call_side_effects["lock_return_activities"]) if api_call_side_effects["unlock_return_activities"]: type(api_instance).async_unlock_return_activities = CoroutineMock( side_effect=api_call_side_effects["unlock_return_activities"]) return await _mock_setup_august(hass, api_instance)
async def test_discovering_fails(self): from stig.commands.cli import RenameCmd self.mock_get_relative_path_from_focused.return_value = None self.mock_select_torrents.side_effect = ValueError('No torrent given') info_cb, err_cb = MagicMock(), MagicMock() process = RenameCmd(['New Name'], info_handler=info_cb, error_handler=err_cb, loop=self.loop) await process.wait_async() self.assertEqual(process.success, False) info_cb.assert_not_called() err_cb.assert_called_once_with('rename: No torrent given') self.mock_get_relative_path_from_focused.assert_called_once_with(unique=False) self.mock_select_torrents.assert_called_once_with(None, allow_no_filter=False, discover_torrent=True) self.mock_srvapi.torrent.torrents.assert_not_called() self.mock_srvapi.torrent.rename.assert_not_called()
def make_call(status_pb: Status) -> grpc.Call: status = rpc_status.to_status(status_pb) mock_call = MagicMock(spec=grpc.Call) mock_call.details.return_value = status.details mock_call.code.return_value = status.code mock_call.trailing_metadata.return_value = status.trailing_metadata return mock_call
async def test_chatCommand(self, mock_commands, mock_data, mock_log): command1 = CoroutineMock(spec=lambda args: False, return_value=False) command2 = CoroutineMock(spec=lambda args: False, return_value=True) command3 = CoroutineMock(spec=lambda args: False, return_value=False) mock_commands.return_value = [command1, command2, command3] data = MagicMock(spec=CacheStore) data.__aenter__.return_value = data data.__aexit__.return_value = True data.isPermittedUser.return_value = False data.isBotManager.return_value = False mock_data.return_value = data message = Mock(spec=Message) type(message).command = PropertyMock(return_value='Kappa') await channel.chatCommand(self.channel, self.tags, 'botgotsthis', message, self.now) data.twitch_save_id.assert_has_calls( [call('2', 'megotsthis'), call('1', 'botgotsthis')]) self.assertEqual(data.isPermittedUser.call_count, 1) self.assertEqual(data.isBotManager.call_count, 1) self.assertEqual(mock_commands.call_count, 1) self.assertEqual(command1.call_count, 1) self.assertEqual(command2.call_count, 1) self.assertEqual(command3.call_count, 0) self.assertEqual(mock_log.call_count, 0)
async def test_added_to_hass(player, state): """Test addition to hass.""" from homeassistant.components.arcam_fmj.const import ( SIGNAL_CLIENT_DATA, SIGNAL_CLIENT_STARTED, SIGNAL_CLIENT_STOPPED, ) connectors = {} def _connect(signal, fun): connectors[signal] = fun player.hass = MagicMock() player.hass.helpers.dispatcher.async_dispatcher_connect.side_effects = _connect await player.async_added_to_hass() state.start.assert_called_with() player.hass.helpers.dispatcher.async_dispatcher_connect.assert_any_call( SIGNAL_CLIENT_DATA, ANY ) player.hass.helpers.dispatcher.async_dispatcher_connect.assert_any_call( SIGNAL_CLIENT_STARTED, ANY ) player.hass.helpers.dispatcher.async_dispatcher_connect.assert_any_call( SIGNAL_CLIENT_STOPPED, ANY )
def setUp(self): self.now = datetime(2000, 1, 1) self.tags = IrcMessageTags() self.channel = Mock(spec=Channel) self.channel.channel = 'botgotsthis' self.data = Mock(spec=CacheStore) self.data.hasFeature.return_value = False self.database = Mock(spec=DatabaseMain) self.database.hasFeature.return_value = False self.permissions = MagicMock(spec=ChatPermissionSet) self.command = CustomCommand('Kappa KappaRoss KappaPride', '#global', '') self.args = ChatCommandArgs(self.data, self.channel, self.tags, 'botgotsthis', Message('Kappa'), self.permissions, self.now) patcher = patch(library.__name__ + '.split_message', autospec=True) self.addCleanup(patcher.stop) self.mock_split = patcher.start() patcher = patch(library.__name__ + '.convert_field') self.addCleanup(patcher.stop) self.mock_convert = patcher.start() self.mock_convert.side_effect = lambda args: args.default patcher = patch(library.__name__ + '.format', autospec=True) self.addCleanup(patcher.stop) self.mock_format = patcher.start() self.mock_format.side_effect = lambda string, format, has: string patcher = patch('lib.items.custom', autospec=True) self.addCleanup(patcher.stop) self.mock_list = patcher.start() self.mock_list.postProcess.return_value = []
def setUp(self): self.mock_response = MagicMock(spec=aiohttp.ClientResponse) self.mock_response.__aenter__.return_value = self.mock_response self.mock_response.__aexit__.return_value = False self.mock_response.status = 200 self.mock_response.json.return_value = {} self.mock_session = MagicMock(spec=aiohttp.ClientSession) self.mock_session.__aenter__.return_value = self.mock_session self.mock_session.__aexit__.return_value = False self.mock_session.get.return_value = self.mock_response patcher = patch('aiohttp.ClientSession') self.addCleanup(patcher.stop) self.mock_clientsession = patcher.start() self.mock_clientsession.return_value = self.mock_session
def setUp(self): patcher = patch('os.path.isfile') self.addCleanup(patcher.stop) self.mock_isfile = patcher.start() self.mock_isfile.return_value = True patcher = patch('os.path.isdir') self.addCleanup(patcher.stop) self.mock_isdir = patcher.start() self.mock_isdir.return_value = False patcher = patch('os.mkdir') self.addCleanup(patcher.stop) self.mock_mkdir = patcher.start() patcher = patch('aiofiles.open') self.addCleanup(patcher.stop) self.mock_open = patcher.start() self.file_mock = MagicMock() self.file_mock.__aenter__ = CoroutineMock() self.file_mock.__aenter__.return_value = self.file_mock self.file_mock.__aexit__ = CoroutineMock() self.file_mock.__aexit__.return_value = False self.file_mock.read = CoroutineMock() self.file_mock.read.return_value = config_data self.mock_open.return_value = self.file_mock
def _mock_august_authentication(token_text, token_timestamp): authentication = MagicMock(name="august.authentication") type(authentication).state = PropertyMock( return_value=AuthenticationState.AUTHENTICATED) type(authentication).access_token = PropertyMock(return_value=token_text) type(authentication).access_token_expires = PropertyMock( return_value=token_timestamp) return authentication
def test_bot_message_wrong_object_type(self): self.assertEqual(self.dc.call_counter, 0) self.dc.is_running = MagicMock() self.dc.is_running.side_effect = [True, False] yield from self.dc.queue_message("one") yield from self.dc.consume() self.assertEqual(self.dc._q.qsize(), 0) self.assertEqual(self.dc.call_counter, 1)
async def _mock_setup_august(hass, api_instance, authenticate_mock, api_mock): """Set up august integration.""" authenticate_mock.side_effect = MagicMock( return_value=_mock_august_authentication("original_token", 1234)) api_mock.return_value = api_instance assert await async_setup_component(hass, DOMAIN, _mock_get_config()) await hass.async_block_till_done() return True
def setUp(self): self.channel = Mock(spec=Channel) self.channel.channel = 'botgotsthis' self.channel.ircChannel = '#botgotsthis' self.now = datetime(2000, 1, 1) self.data = MagicMock(spec=CacheStore) self.data.__aenter__.return_value = self.data self.data.__aexit__.return_value = False patcher = patch('lib.cache.get_cache') self.addCleanup(patcher.stop) self.mock_cache = patcher.start() self.mock_cache.return_value = self.data patcher = patch('bot.utils.logIrcMessage', autospec=True) self.addCleanup(patcher.stop) self.mock_log = patcher.start() patcher = patch('bot.utils.logException', autospec=True) self.addCleanup(patcher.stop) self.mock_except = patcher.start() patcher = patch(block_url.__name__ + '.compare_domains', autospec=True) self.addCleanup(patcher.stop) self.mock_compare = patcher.start() self.mock_compare.return_value = False patcher = patch(block_url.__name__ + '.handle_different_domains') self.addCleanup(patcher.stop) self.mock_handle = patcher.start() self.mock_response = MagicMock(spec=aiohttp.ClientResponse) self.mock_response.__aenter__.return_value = self.mock_response self.mock_response.__aexit__.return_value = False self.mock_response.status = 200 self.mock_session = MagicMock(spec=aiohttp.ClientSession) self.mock_session.__aenter__.return_value = self.mock_session self.mock_session.__aexit__.return_value = False self.mock_session.get.return_value = self.mock_response patcher = patch('aiohttp.ClientSession') self.addCleanup(patcher.stop) self.mock_clientsession = patcher.start() self.mock_clientsession.return_value = self.mock_session
def AsyncMock(*args, **kwargs): mock = MagicMock(*args, **kwargs) async def mock_coroutine(*args, **kwargs): return mock(*args, **kwargs) mock_coroutine.mock = mock return mock_coroutine
def QuestionAnsweringResponseMock(*args, **kwargs): mock = MagicMock(*args, **kwargs) async def mock_coroutine(*args, **kwargs): return mock(*args, **kwargs) mock_coroutine.mock = mock return mock_coroutine
def setUp(self): self.now = datetime(2000, 1, 1) self.tags = IrcMessageTags() self.data = Mock(spec=CacheStore) self.database = Mock(spec=DatabaseMain) self.permissions = MagicMock(spec=WhisperPermissionSet) self.args = WhisperCommandArgs(self.data, 'botgotsthis', Message(''), self.permissions, self.now)
def test_bot_message(self): self.assertEqual(self.dc.call_counter, 0) self.dc.is_running = MagicMock() self.dc.is_running.side_effect = [True, False] msg = SlackMessage(type="message", text="hello", subtype="bot_message") yield from self.dc.queue_message(msg) yield from self.dc.consume() self.assertEqual(self.dc._q.qsize(), 0) self.assertEqual(self.dc.call_counter, 0)
def _generate_mock_feed_entry(external_id, title, distance_to_home, coordinates, category=None, location=None, attribution=None, publication_date=None, council_area=None, status=None, entry_type=None, fire=True, size=None, responsible_agency=None): """Construct a mock feed entry for testing purposes.""" feed_entry = MagicMock() feed_entry.external_id = external_id feed_entry.title = title feed_entry.distance_to_home = distance_to_home feed_entry.coordinates = coordinates feed_entry.category = category feed_entry.location = location feed_entry.attribution = attribution feed_entry.publication_date = publication_date feed_entry.council_area = council_area feed_entry.status = status feed_entry.type = entry_type feed_entry.fire = fire feed_entry.size = size feed_entry.responsible_agency = responsible_agency return feed_entry