def test_install(self, remote_cls, installation_cls, transaction_cls):
"""Test flatpak installation is working."""
progress = Mock()
flatpak = FlatpakManager(sysroot="remote/path", callback=progress)
self._setup_flatpak_objects(remote_cls, installation_cls,
transaction_cls)
flatpak.initialize_with_system_path()
self._installation.list_remote_refs_sync.return_value = [
RefMock("app/org.space.coolapp/x86_64/stable"),
RefMock("app/com.prop.notcoolapp/i386/f36"),
RefMock("runtime/org.space.coolruntime/x86_64/stable"),
RefMock("runtime/com.prop.notcoolruntime/i386/f36"),
]
flatpak.install_all()
assert self._transaction.mock_calls == [
call.connect("new_operation", flatpak._operation_started_callback),
call.connect("operation_done",
flatpak._operation_stopped_callback),
call.connect("operation_error", flatpak._operation_error_callback),
call.add_install(FlatpakManager.LOCAL_REMOTE_NAME,
"app/org.space.coolapp/x86_64/stable", None),
call.add_install(FlatpakManager.LOCAL_REMOTE_NAME,
"app/com.prop.notcoolapp/i386/f36", None),
call.add_install(FlatpakManager.LOCAL_REMOTE_NAME,
"runtime/org.space.coolruntime/x86_64/stable",
None),
call.add_install(FlatpakManager.LOCAL_REMOTE_NAME,
"runtime/com.prop.notcoolruntime/i386/f36", None),
call.run()
]
assert progress.mock_calls == []
async def test_notify(hass, client):
"""Test sending a message."""
await setup_webostv(hass)
assert hass.services.has_service(NOTIFY_DOMAIN, TV_NAME)
await hass.services.async_call(
NOTIFY_DOMAIN,
TV_NAME,
{
ATTR_MESSAGE: MESSAGE,
CONF_SERVICE_DATA: {
CONF_ICON: ICON_PATH,
},
},
blocking=True,
)
assert client.mock_calls[0] == call.connect()
assert client.connect.call_count == 1
client.send_message.assert_called_with(MESSAGE, icon_path=ICON_PATH)
await hass.services.async_call(
NOTIFY_DOMAIN,
TV_NAME,
{
ATTR_MESSAGE: MESSAGE,
CONF_SERVICE_DATA: {
"OTHER_DATA": "not_used",
},
},
blocking=True,
)
assert client.mock_calls[0] == call.connect()
assert client.connect.call_count == 1
client.send_message.assert_called_with(MESSAGE, icon_path=None)
def test_post_load_auxiliary_data(self):
with cast(BinaryIO, (DATA_DIR / 'saml_response.xml').open('rb')) as f:
saml_request_xml = f.read()
self.cache_mock.get_and_remove.return_value = "{}"
response = self.client.post(self.url, {'SAMLResponse': b64encode(saml_request_xml).decode('ascii'),
'RelayState': 'relay123'})
self.assertEqual(response.status_code, 200)
self.maxDiff = None
self.assertSequenceEqual(self.client_mock.mock_calls[:4], [
call.connect('test.example.net', 1234),
call.get_cache('aux-cache'),
call.get_cache().get_and_remove('aux-test-saml-request-id'),
call.connect('test.example.net', 1234)])
def test_install(self, remote_cls, installation_cls, transaction_cls):
"""Test flatpak installation is working."""
flatpak = FlatpakManager("remote/path")
self._setup_flatpak_objects(remote_cls, installation_cls,
transaction_cls)
flatpak.initialize_with_system_path()
mock_ref_list = [
RefMock(name="org.space.coolapp",
kind=RefKind.APP,
arch="x86_64",
branch="stable"),
RefMock(name="com.prop.notcoolapp",
kind=RefKind.APP,
arch="i386",
branch="f36"),
RefMock(name="org.space.coolruntime",
kind=RefKind.RUNTIME,
arch="x86_64",
branch="stable"),
RefMock(name="com.prop.notcoolruntime",
kind=RefKind.RUNTIME,
arch="i386",
branch="f36")
]
self._installation.list_remote_refs_sync.return_value = mock_ref_list
flatpak.install_all()
expected_calls = [
call.connect("new_operation", flatpak._operation_started_callback),
call.connect("operation_done",
flatpak._operation_stopped_callback),
call.connect("operation_error", flatpak._operation_error_callback),
call.add_install(FlatpakManager.LOCAL_REMOTE_NAME,
mock_ref_list[0].format_ref(), None),
call.add_install(FlatpakManager.LOCAL_REMOTE_NAME,
mock_ref_list[1].format_ref(), None),
call.add_install(FlatpakManager.LOCAL_REMOTE_NAME,
mock_ref_list[2].format_ref(), None),
call.add_install(FlatpakManager.LOCAL_REMOTE_NAME,
mock_ref_list[3].format_ref(), None),
call.run()
]
assert self._transaction.mock_calls == expected_calls
def test_split_on_semicolon(self, oracle: MagicMock):
self.adapter.acquire_connection('test_semicolon')
query1 = "SELECT * FROM DUAL"
query2 = "SELECT 'TEST' FROM DUAL"
multi_query = f'{query1};\n{query2}'
oracle.connect.assert_not_called()
self.adapter.execute(multi_query)
oracle.assert_has_calls(
[
call.connect().cursor().execute(query1),
call.connect().cursor().execute(query2)
],
any_order=True
)
def test_pop_light_response_not_found(self):
self.cache_mock.get_and_remove.return_value = None
self.assertIsNone(self.storage.pop_light_response('abc'))
self.assertEqual(self.client_class_mock.mock_calls, [call(timeout=33)])
self.assertEqual(self.client_mock.mock_calls, [
call.connect(self.HOST, self.PORT),
call.get_cache(self.RESPONSE_CACHE_NAME),
call.get_cache().get_and_remove('abc')
])
def test_put_without_prefix(self):
storage = AuxiliaryIgniteStorage(self.HOST, self.PORT, self.CACHE_NAME,
33)
storage.put('abc', {"foo": True})
self.assertEqual(self.client_class_mock.mock_calls, [call(timeout=33)])
self.assertEqual(self.client_mock.mock_calls, [
call.connect(self.HOST, self.PORT),
call.get_cache(self.CACHE_NAME),
call.get_cache().put('abc', '{"foo": true}')
])
def test_get_cache_single_client_created(self):
storage = AuxiliaryIgniteStorage(self.HOST, self.PORT, self.CACHE_NAME,
33, self.PREFIX)
self.assertIs(storage.get_cache("cache1"), self.cache_mock)
self.assertIs(storage.get_cache("cache2"), self.cache_mock)
self.assertEqual(self.client_class_mock.mock_calls, [call(timeout=33)])
self.assertEqual(self.client_mock.mock_calls, [
call.connect(self.HOST, self.PORT),
call.get_cache("cache1"),
call.get_cache("cache2")
])
def test_get_cache_single_client_created(self):
self.assertIs(self.storage.get_cache(self.REQUEST_CACHE_NAME),
self.cache_mock)
self.assertIs(self.storage.get_cache(self.RESPONSE_CACHE_NAME),
self.cache_mock)
self.assertEqual(self.client_class_mock.mock_calls, [call(timeout=33)])
self.assertEqual(self.client_mock.mock_calls, [
call.connect(self.HOST, self.PORT),
call.get_cache(self.REQUEST_CACHE_NAME),
call.get_cache(self.RESPONSE_CACHE_NAME)
])
def test_pop_without_prefix(self):
self.cache_mock.get_and_remove.return_value = '{"foo": true}'
storage = AuxiliaryIgniteStorage(self.HOST, self.PORT, self.CACHE_NAME,
33)
self.assertEqual(storage.pop('abc'), {"foo": True})
self.assertEqual(self.client_class_mock.mock_calls, [call(timeout=33)])
self.assertEqual(self.client_mock.mock_calls, [
call.connect(self.HOST, self.PORT),
call.get_cache(self.CACHE_NAME),
call.get_cache().get_and_remove('abc')
])
def test_pop_not_found(self):
self.cache_mock.get_and_remove.return_value = None
storage = AuxiliaryIgniteStorage(self.HOST, self.PORT, self.CACHE_NAME,
33, self.PREFIX)
self.assertIsNone(storage.pop('abc'))
self.assertEqual(self.client_class_mock.mock_calls, [call(timeout=33)])
self.assertEqual(self.client_mock.mock_calls, [
call.connect(self.HOST, self.PORT),
call.get_cache(self.CACHE_NAME),
call.get_cache().get_and_remove('test-prefix-abc')
])
def test_connect(self):
self.assertEqual([
call.getaddrinfo('hal', 6600, self._socket_api.AF_UNSPEC,
self._socket_api.SOCK_STREAM),
call.socket(sentinel.family, sentinel.socket_type, sentinel.proto),
], self._socket_api.method_calls)
self.assertEqual([
call.connect(sentinel.socket_address),
call.makefile(mode='r', encoding='utf-8'),
call.makefile(mode='w', encoding='utf-8'),
], self._socket_object.method_calls)
def test_post_remember_country_codes(self):
request = LightRequest(**LIGHT_REQUEST_DICT)
self.cache_mock.get_and_remove.return_value = dump_xml(request.export_xml()).decode('utf-8')
token, encoded = self.get_token()
response = self.client.post(self.url, {'test_token': encoded})
self.assertEqual(response.status_code, 200)
self.assertEqual(
self.client_mock.mock_calls,
[
call.connect('test.example.net', 1234),
call.get_cache('test-proxy-service-request-cache'),
call.get_cache().get_and_remove('request-token-id'),
call.connect('test.example.net', 1234),
call.get_cache('aux-cache'),
call.get_cache().put(
'aux-test-light-request-id',
'{"citizen_country": "CA", "origin_country": "CA"}'
),
]
)
def test_complex_semicolon_split(self, oracle: MagicMock):
self.adapter.acquire_connection('test_semicolon')
query1 = "--SELECT * FROM DUAL;SELECT 'A' FROM DUAL WHERE 1 = 0;;;"
query2 = "SELECT 'TEST' FROM DUAL"
query3 = "SELECT 'A' FROM DUAL"
query4 = "UNION ALL SELECT 'B' FROM DUAL"
first_query = f'{query1};\n{query2}'
second_query = f'{query3} {query4}'
multi_query = f'{first_query};\n{second_query}'
oracle.connect.assert_not_called()
self.adapter.execute(multi_query)
oracle.assert_has_calls(
[
call.connect().cursor().execute(first_query),
call.connect().cursor().execute(second_query)
],
any_order=True
)
def test_post_remember_name_id_format(self):
request = LightRequest(**LIGHT_REQUEST_DICT)
self.cache_mock.get_and_remove.return_value = dump_xml(request.export_xml()).decode('utf-8')
token, encoded = self.get_token()
response = self.client.post(self.url, {'test_token': encoded})
self.assertEqual(response.status_code, 200)
self.assertEqual(
self.client_mock.mock_calls,
[
call.connect('test.example.net', 1234),
call.get_cache('test-proxy-service-request-cache'),
call.get_cache().get_and_remove('request-token-id'),
call.connect('test.example.net', 1234),
call.get_cache('aux-cache'),
call.get_cache().put(
'aux-test-light-request-id',
'{"name_id_format": "urn:oasis:names:tc:SAML:1.1:nameid-format:unspecified"}'
),
]
)
def test_put_light_response(self):
with cast(TextIO, (DATA_DIR / 'light_response.xml').open('r')) as f:
data = f.read()
response = LightResponse.load_xml(parse_xml(data))
self.storage.put_light_response('abc', response)
self.assertEqual(self.client_class_mock.mock_calls, [call(timeout=33)])
self.assertEqual(self.client_mock.mock_calls, [
call.connect(self.HOST, self.PORT),
call.get_cache(self.RESPONSE_CACHE_NAME),
call.get_cache().put('abc', data)
])
def test_pop_light_response_found(self):
with cast(BinaryIO, (DATA_DIR / 'light_response.xml').open('rb')) as f:
data = f.read()
self.cache_mock.get_and_remove.return_value = data.decode('utf-8')
self.assertEqual(LightResponse.load_xml(parse_xml(data)),
self.storage.pop_light_response('abc'))
self.assertEqual(self.client_class_mock.mock_calls, [call(timeout=33)])
self.assertEqual(self.client_mock.mock_calls, [
call.connect(self.HOST, self.PORT),
call.get_cache(self.RESPONSE_CACHE_NAME),
call.get_cache().get_and_remove('abc')
])
def test_add_cbs_code(self, mock_datastore):
mock_datastore.return_value.query.return_value = [
pd.Series(["1234", "BU03630001", "Centrum"])
]
enricher = GebiedenEnricher("app", "gebieden", "buurten")
enricher._add_cbs_code(self.entities[0], CBS_CODES_BUURT, 'buurt')
mock_datastore.has_calls(
[call.connect(), call.query(''),
call.disconnect()])
# Expect cbs codes buurt
self.assertEqual('BU03630001', self.entities[0]['cbs_code'])
def test_connect_fail(self):
psycopg2_mock = Mock()
psycopg2_mock.OperationalError = psycopg2.OperationalError
psycopg2_mock.connect.side_effect = psycopg2.OperationalError()
with patch.multiple('pgsqldoc.pgsqldoc',
psycopg2=psycopg2_mock,
output=DEFAULT) as mock:
with self.assertRaises(psycopg2.OperationalError):
Preprocessor._connect(self.preprocessor, self.options)
psycopg2_mock.assert_has_calls([call.connect(self.connect_string)])
self.assertTrue(mock['output'].called)
self.assertIsNone(self.preprocessor._con)
# logger was called 2 times: first 'Trying to connect'
# second 'Failed to connect'
self.assertEqual(self.preprocessor.logger.debug.call_count, 2)
def test_post_load_auxiliary_data(self):
self.maxDiff = None
light_response = self.get_light_response()
self.cache_mock.get_and_remove.side_effect = [
dump_xml(light_response.export_xml()).decode('utf-8'),
"{}",
]
token, encoded = self.get_token()
response = self.client.post(self.url, {'test_response_token': encoded})
self.assertEqual(response.status_code, 200)
self.maxDiff = None
self.assertSequenceEqual(self.client_mock.mock_calls[-3:], [
call.connect('test.example.net', 1234),
call.get_cache('aux-cache'),
call.get_cache().get_and_remove('aux-test-saml-request-id')
])
def test_get_light_request_success(self):
orig_light_request = LightRequest(**LIGHT_REQUEST_DICT)
self.cache_mock.get_and_remove.return_value = dump_xml(orig_light_request.export_xml()).decode('utf-8')
token, encoded = self.get_token()
view = ProxyServiceRequestView()
view.request = self.factory.post(self.url, {'test_token': encoded})
view.light_token = token
view.storage = IgniteStorage('test.example.net', 1234, 'test-proxy-service-request-cache', '')
light_request = view.get_light_request()
self.assertEqual(light_request, orig_light_request)
self.maxDiff = None
self.assertEqual(self.client_mock.mock_calls,
[call.connect('test.example.net', 1234),
call.get_cache('test-proxy-service-request-cache'),
call.get_cache().get_and_remove('request-token-id')])
async def test_notify_not_connected(hass, client, monkeypatch):
"""Test sending a message when client is not connected."""
await setup_webostv(hass)
assert hass.services.has_service(NOTIFY_DOMAIN, TV_NAME)
monkeypatch.setattr(client, "is_connected", Mock(return_value=False))
await hass.services.async_call(
NOTIFY_DOMAIN,
TV_NAME,
{
ATTR_MESSAGE: MESSAGE,
CONF_SERVICE_DATA: {
CONF_ICON: ICON_PATH,
},
},
blocking=True,
)
assert client.mock_calls[0] == call.connect()
assert client.connect.call_count == 2
client.send_message.assert_called_with(MESSAGE, icon_path=ICON_PATH)
def test_get_light_response_success(self):
orig_light_response = self.get_light_response()
self.cache_mock.get_and_remove.return_value = dump_xml(
orig_light_response.export_xml()).decode('utf-8')
token, encoded = self.get_token()
view = ConnectorResponseView()
view.request = self.factory.post(self.url, {'test_token': encoded})
view.light_token = token
view.storage = IgniteStorage('test.example.net', 1234, '',
'test-connector-response-cache')
light_response = view.get_light_response()
self.assertEqual(light_response, orig_light_response)
self.maxDiff = None
self.assertEqual(self.client_mock.mock_calls, [
call.connect('test.example.net', 1234),
call.get_cache('test-connector-response-cache'),
call.get_cache().get_and_remove('response-token-id')
])
def test_post_success(self, uuid_mock: MagicMock):
with cast(BinaryIO, (DATA_DIR / 'saml_response.xml').open('rb')) as f:
saml_request_xml = f.read()
response = self.client.post(self.url, {'SAMLResponse': b64encode(saml_request_xml).decode('ascii'),
'RelayState': 'relay123'})
# Context
self.assertIn('token', response.context)
self.assertEqual(response.context['token_parameter'], 'test_token')
self.assertEqual(response.context['eidas_url'], 'https://test.example.net/SpecificProxyServiceResponse')
self.assertEqual(response.context['error'], None)
# Token
encoded_token = response.context['token']
token = LightToken.decode(encoded_token, 'sha256', 'response-token-secret')
self.assertEqual(token.id, 'T0uuid4')
self.assertEqual(token.issuer, 'response-token-issuer')
self.assertEqual(token.created, datetime(2017, 12, 11, 14, 12, 5))
# Storing light response
light_response_data = LIGHT_RESPONSE_DICT.copy()
light_response_data.update({
'status': Status(**light_response_data['status']),
'id': 'test-saml-response-id', # Preserved
'in_response_to_id': 'test-saml-request-id', # Preserved
'issuer': 'https://test.example.net/node-proxy-service-response', # Replaced
})
light_response = LightResponse(**light_response_data)
self.assertEqual(self.client_class_mock.mock_calls, [call(timeout=66)])
self.assertEqual(self.client_mock.mock_calls,
[call.connect('test.example.net', 1234),
call.get_cache('test-proxy-service-response-cache'),
call.get_cache().put('T0uuid4', dump_xml(light_response.export_xml()).decode('utf-8'))])
# Rendering
self.assertContains(response, 'Redirect to eIDAS Node is in progress')
self.assertContains(response,
'<form class="auto-submit" action="https://test.example.net/SpecificProxyServiceResponse"')
self.assertContains(response, '<input type="hidden" name="test_token" value="{}"'.format(encoded_token))
self.assertNotIn(b'An error occurred', response.content)
def test_amqp_failure(srv, caplog):
module = load_module_by_name("mqttwarn.services.amqp")
exchange, routing_key = ["name_of_exchange", "my_routing_key"]
item = Item(
config={"uri": "amqp://*****:*****@localhost:5672/"},
target="test",
addrs=[exchange, routing_key],
message="⚽ Notification message ⚽",
)
with caplog.at_level(logging.DEBUG):
mock_connection = mock.MagicMock()
# Make the call to `basic_publish` raise an exception.
def error(*args, **kwargs):
raise Exception("something failed")
mock_connection.basic_publish = error
with mock.patch("puka.Client",
side_effect=[mock_connection],
create=True) as mock_client:
outcome = module.plugin(srv, item)
assert mock_client.mock_calls == [
mock.call("amqp://*****:*****@localhost:5672/"),
]
assert mock_connection.mock_calls == [
call.connect(),
call.wait(mock.ANY),
]
assert outcome is False
assert ("AMQP publish to test [name_of_exchange/my_routing_key]"
in caplog.text)
assert (
"Error on AMQP publish to test [name_of_exchange/my_routing_key]: something failed"
in caplog.text)
async def test_icon_not_found(hass, caplog, client, monkeypatch):
"""Test notify icon not found error."""
await setup_webostv(hass)
assert hass.services.has_service(NOTIFY_DOMAIN, TV_NAME)
monkeypatch.setattr(client, "send_message",
Mock(side_effect=FileNotFoundError))
await hass.services.async_call(
NOTIFY_DOMAIN,
TV_NAME,
{
ATTR_MESSAGE: MESSAGE,
CONF_SERVICE_DATA: {
CONF_ICON: ICON_PATH,
},
},
blocking=True,
)
assert client.mock_calls[0] == call.connect()
assert client.connect.call_count == 1
client.send_message.assert_called_with(MESSAGE, icon_path=ICON_PATH)
assert f"Icon {ICON_PATH} not found" in caplog.text
async def test_connection_errors(hass, caplog, client, monkeypatch,
side_effect, error):
"""Test connection errors scenarios."""
await setup_webostv(hass)
assert hass.services.has_service("notify", TV_NAME)
monkeypatch.setattr(client, "is_connected", Mock(return_value=False))
monkeypatch.setattr(client, "connect", Mock(side_effect=side_effect))
await hass.services.async_call(
NOTIFY_DOMAIN,
TV_NAME,
{
ATTR_MESSAGE: MESSAGE,
CONF_SERVICE_DATA: {
CONF_ICON: ICON_PATH,
},
},
blocking=True,
)
assert client.mock_calls[0] == call.connect()
assert client.connect.call_count == 1
client.send_message.assert_not_called()
assert error in caplog.text
def test_post_remember_country_codes(self, uuid_mock):
self.maxDiff = None
saml_request_xml, saml_request_encoded = self.load_saml_request(
signed=True)
light_request = LightRequest(**LIGHT_REQUEST_DICT)
light_request.issuer = 'https://example.net/EidasNode/ConnectorMetadata'
self.cache_mock.get_and_remove.return_value = dump_xml(
light_request.export_xml()).decode('utf-8')
response = self.client.post(
self.url, {
'SAMLRequest': saml_request_encoded,
'RelayState': 'relay123',
'country_param': 'ca'
})
self.assertEqual(response.status_code, 200)
self.assertSequenceEqual(self.client_mock.mock_calls[-3:], [
call.connect('test.example.net', 1234),
call.get_cache('aux-cache'),
call.get_cache().put(
'aux-test-saml-request-id',
'{"citizen_country": "CA", "origin_country": "CA"}'),
])
def test_active_ssh_session(self):
ssh = MagicMock()
credentials = {
'username': '******',
'hostname': 'host',
'port': 1234,
'pkey': 'key',
}
self.assertEqual(
first=ssh,
second=active_ssh_session(ssh=ssh, credentials=credentials),
msg='Returns the ssh object passed'
)
self.assertIn(
member=call.connect(
username=credentials['username'],
hostname=credentials['hostname'],
port=credentials['port'],
pkey=credentials['pkey']
),
container=ssh.mock_calls,
msg='Connects the ssh object using the ssh credentials passed'
)
def test_connect_success(self):
with patch('pgsqldoc.pgsqldoc.psycopg2') as mock:
Preprocessor._connect(self.preprocessor, self.options)
mock.assert_has_calls([call.connect(self.connect_string)])
self.assertIsNotNone(self.preprocessor._con)
