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