async def test_startup_initializes_and_starts_one_consumer_per_route(
self, Consumer):
app = asynctest.MagicMock(
url="https://www.sieve.com.br/cultura/",
routes_registry=self.routes_registry,
loop=Mock(create_task=CoroutineMock()),
prefetch_count=1,
)
await self.signal_handler.startup(app)
Consumer.assert_has_calls(
[
call(
route_info=self.routes_registry.sse_routes[0],
url="https://www.sieve.com.br/cultura/Xablau",
username=app.user,
password=app.password,
),
call(
route_info=self.routes_registry.sse_routes[1],
url="https://www.sieve.com.br/cultura/Xena",
username=app.user,
password=app.password,
),
call(
route_info=self.routes_registry.sse_routes[1],
url="https://www.sieve.com.br/cultura/sse",
username=app.user,
password=app.password,
),
],
any_order=True,
)
Consumer.return_value.start.assert_has_calls([call(), call()])
app[RouteTypes.SSE].__getitem__.return_value.append.assert_has_calls(
[call(Consumer.return_value),
call(Consumer.return_value)])
def test_matrix_list_context_node():
from jenkins_yml import Job
from jenkins_epo.jenkins import MatrixJob
api_instance = Mock(spec=['_get_config_element_tree', 'get_params'])
api_instance.name = 'matrix'
api_instance._data = dict(activeConfigurations=[
{
'name': 'NODE=slave-legacy,P=a'
},
{
'name': 'NODE=slave-ng,P=a'
},
{
'name': 'NODE=slave-legacy,P=b'
},
{
'name': 'NODE=slave-ng,P=b'
},
])
xml = api_instance._get_config_element_tree.return_value
xml.findall.return_value = []
xml.find.return_value = None
job = MatrixJob(api_instance)
job._node_axis = 'NODE'
spec = Job('matrix', dict(
node='slave-ng',
axis={'P': ['a', 'b', 4.3]},
))
contexts = [c for c in job.list_contexts(spec)]
assert 2 == len(contexts)
assert 'NODE=slave-legacy' not in ''.join(contexts)
assert 'NODE=slave-ng' in ''.join(contexts)
async def test_unsubscribe_agent(test_client, loop):
agent = make_connected_agent()
agent.aiothread.client.enqueue = Mock()
agent.start(auto_register=False)
agent.web.setup_routes()
client = await test_client(agent.web.app)
jid = "friend@server"
jid_ = JID.fromstr(jid)
item = Item(jid=jid_)
agent.presence.roster._update_entry(item)
response = await client.get(f"/spade/agent/{jid}/unsubscribe/")
assert str(response.url.relative()) == f"/spade/agent/{jid}/"
assert agent.aiothread.client.enqueue.mock_calls
arg = agent.aiothread.client.enqueue.call_args[0][0]
assert arg.to == jid_.bare()
assert arg.type_ == PresenceType.UNSUBSCRIBE
agent.stop()
async def test_scenes_unauthorized_loads_platforms(
hass, config_entry, app, installed_app,
device, smartthings_mock, subscription_factory):
"""Test if scenes are unauthorized we continue to load platforms."""
setattr(hass.config_entries, '_entries', [config_entry])
smartthings_mock.app.return_value = app
smartthings_mock.installed_app.return_value = installed_app
smartthings_mock.devices.return_value = [device]
smartthings_mock.scenes.side_effect = \
ClientResponseError(None, None, status=403)
mock_token = Mock()
mock_token.access_token.return_value = str(uuid4())
mock_token.refresh_token.return_value = str(uuid4())
smartthings_mock.generate_tokens.return_value = mock_token
subscriptions = [subscription_factory(capability)
for capability in device.capabilities]
smartthings_mock.subscriptions.return_value = subscriptions
with patch.object(hass.config_entries,
'async_forward_entry_setup') as forward_mock:
assert await smartthings.async_setup_entry(hass, config_entry)
# Assert platforms loaded
await hass.async_block_till_done()
assert forward_mock.call_count == len(SUPPORTED_PLATFORMS)
async def test_api_error_shows_error(hass, smartthings_mock):
"""Test an error is shown when other API errors occur."""
token = str(uuid4())
data = {"error": {}}
request_info = Mock(real_url="http://example.com")
error = APIResponseError(request_info=request_info,
history=None,
data=data,
status=400)
smartthings_mock.apps.side_effect = error
# Webhook confirmation shown
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": "user"})
assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
assert result["step_id"] == "user"
assert result["description_placeholders"][
"webhook_url"] == smartapp.get_webhook_url(hass)
# Advance to PAT screen
result = await hass.config_entries.flow.async_configure(
result["flow_id"], {})
assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
assert result["step_id"] == "pat"
assert "token_url" in result["description_placeholders"]
assert "component_url" in result["description_placeholders"]
# Enter token
result = await hass.config_entries.flow.async_configure(
result["flow_id"], {CONF_ACCESS_TOKEN: token})
assert result["type"] == data_entry_flow.RESULT_TYPE_FORM
assert result["step_id"] == "pat"
assert result["data_schema"]({}) == {CONF_ACCESS_TOKEN: token}
assert result["errors"] == {"base": "app_setup_error"}
assert "token_url" in result["description_placeholders"]
assert "component_url" in result["description_placeholders"]
def test_task_factory():
from jenkins_epo.procedures import process_task_factory, process_url
head = Mock()
head.sort_key.return_value = (1,)
task = process_task_factory(head)
assert task.callable_ is process_url
def test_should_work_with_no_dict(self):
test_message = "value"
rbmq_message = Mock(RabbitMQMessage)
rbmq_message.body = test_message
message = Message(rbmq_message)
self.assertEqual(message.body, test_message)
def event_manager() -> EventManager:
"""Returns mocked event manager."""
signal = Mock()
return EventManager(signal)
def test_setitem_changes_state(self):
self.barterdude["foo"] = foo = Mock()
self.assertEqual(foo, self.barterdude["foo"])
async def test_get_controller(hass):
"""Successful call."""
with patch("aiounifi.Controller.login", return_value=Mock()):
assert await unifi.controller.get_controller(hass, **CONTROLLER_DATA)
async def async_main():
mocked_cache = Mock(spec=BaseCache)
mocked_cache.get.return_value = "World"
print(await mocked_cache.get("hello"))
def setUp(self):
self.agent = Mock()
self.behaviour = ReceiveNewData()
self.behaviour.receive = CoroutineMock()
self.behaviour.set_agent(self.agent)
def setUp(self):
nyuki = Mock()
nyuki.HTTP_RESOURCES = []
nyuki.loop = None
self._api = Api(nyuki)
def setUp(self):
self.agent = Mock()
self.behaviour = WaitMonitorSubscriptions()
self.behaviour.set_agent(self.agent)
async def test_should_react_on_subscribe(self):
self.behaviour.presence.approve = Mock()
self.behaviour.presence.subscribe = Mock()
self.behaviour.on_subscribe("my jid")
self.behaviour.presence.approve.assert_called_with("my jid")
self.behaviour.presence.subscribe.assert_called_with("my jid")
def basic_device_info() -> BasicDeviceInfo:
"""Returns the basic_device_info mock object."""
mock_request = Mock()
mock_request.return_value = ""
return BasicDeviceInfo(mock_request)
def test_setup():
agent = make_connected_agent()
agent.setup = Mock()
agent.start(auto_register=False)
agent.setup.assert_called_once()
agent.stop()
def setUp(self):
self.agent = Mock()
self.behaviour = SendNewData()
self.behaviour.set_agent(self.agent)
self.behaviour.set_template(Template(body='[1, 2, 3]'))
self.agent.sink.drain = CoroutineMock()
async def test_get_controller_verify_ssl_false(hass):
"""Successful call with verify ssl set to false."""
controller_data = dict(CONTROLLER_DATA)
controller_data[CONF_VERIFY_SSL] = False
with patch("aiounifi.Controller.login", return_value=Mock()):
assert await unifi.controller.get_controller(hass, **controller_data)
async def setUp(self):
self.owner = Mock(freeze=CoroutineMock())
self.signal = Signal(self.owner)
async def test_get_gateway(hass):
"""Successful call."""
with patch("pydeconz.DeconzSession.async_load_parameters",
return_value=True):
assert await deconz.gateway.get_gateway(hass, ENTRY_CONFIG, Mock(),
Mock())
def simple_mock_auth_fixture() -> AsyncAuth:
"""Return a simple AsyncAuth Mock."""
return Mock(spec=AsyncAuth, pin=HAPPIN, create=True)
async def setUp(self):
super(AMQPConnectionTests, self).setUp()
self.connection = AMQPConnection(**self.conn_params, on_error=Mock())
def logger():
return Mock(spec_set=logging.Logger).return_value
def mock_coro(return_value=None, **kwargs):
"""Create mock coroutine function."""
async def wrapped(*args, **kwargs):
return return_value
return Mock(wraps=wrapped, **kwargs)
def client():
return Mock(spec_set=aiohttp.ClientSession)
def setUp(self):
self.schema = load_fixture("schema.json")
self.rbmq_message = Mock(RabbitMQMessage)
def valid_response():
response = Mock(spec_set=aiohttp.ClientResponse)
response.status = 200
response.text = CoroutineMock(return_value="foobar")
response.json = CoroutineMock(return_value=123)
return response
def test_task_priority():
from jenkins_epo.tasks import ProcessTask, QueuerTask, PrinterTask
protected_branch = Mock()
protected_branch.sort_key.return_value = (50, )
pr = Mock()
pr.sort_key.return_value = (80, )
urgent_pr = Mock()
urgent_pr.sort_key.return_value = (20, )
assert ProcessTask(protected_branch, Mock()) < ProcessTask(pr, Mock())
assert ProcessTask(urgent_pr, Mock()) < ProcessTask(pr, Mock())
assert ProcessTask(pr, Mock(), '20-webhook') < ProcessTask(pr, Mock())
assert ProcessTask(pr, Mock()) < QueuerTask(Mock(), Mock())
assert PrinterTask(pr) < QueuerTask(Mock(), Mock())
def bad_http_response(spec_set=aiohttp.ClientResponse):
response = Mock(spec_set=aiohttp.ClientResponse)
response.status = 401
return response
