def test_discover_general_error(self):
"""
Test discover available master on the network (erroneous found)
:return:
"""
_socket = MagicMock()
error = "Admins on strike due to broken coffee machine"
signature = ssdp.SSDPBase.DEFAULTS[ssdp.SSDPBase.SIGNATURE]
fake_resource = SSDPClientTestCase.Resource()
fake_resource.pool = [
("{}:E:{}".format(signature, error), "10.10.10.10"),
(None, None),
]
with patch("salt.utils.ssdp.socket", _socket):
clnt = ssdp.SSDPDiscoveryClient()
clnt._socket.recvfrom = fake_resource.read
clnt._query = MagicMock()
clnt.log = MagicMock()
clnt.discover()
assert len(clnt.log.error.mock_calls) == 1
assert ("Error response from the service publisher"
in clnt.log.error.call_args[0][0])
assert "10.10.10.10" == clnt.log.error.call_args[0][1]
assert clnt.log.error.call_args[1] == {}
assert clnt.log.error.call_args[0][2] == error
def test_discover_timestamp_error(self):
"""
Test discover available master on the network (outdated timestamp)
:return:
"""
_socket = MagicMock()
error = "We only support a 1200 bps connection. Routing timestamp problems on neural net."
signature = ssdp.SSDPBase.DEFAULTS[ssdp.SSDPBase.SIGNATURE]
fake_resource = SSDPClientTestCase.Resource()
fake_resource.pool = [
("{}:E:{}".format(signature, error), "10.10.10.10"),
(None, None),
]
with patch("salt.utils.ssdp.socket", _socket):
clnt = ssdp.SSDPDiscoveryClient()
clnt._socket.recvfrom = fake_resource.read
clnt._query = MagicMock()
clnt.log = MagicMock()
clnt.discover()
assert len(clnt.log.error.mock_calls) == 2
assert ("Error response from the service publisher"
in clnt.log.error.mock_calls[0][1][0])
assert clnt.log.error.mock_calls[0][1][2] == error
assert clnt.log.error.mock_calls[0][2] == {}
assert ("Publisher sent shifted timestamp"
in clnt.log.error.mock_calls[1][1][0])
assert (clnt.log.error.mock_calls[1][1][1] ==
clnt.log.error.mock_calls[0][1][1] == "10.10.10.10")
def get_ssdp_discovery_client(self,
expected_ip=None,
expected_hostname=None,
**config):
if expected_ip is None:
expected_ip = "127.0.0.1"
if expected_hostname is None:
expected_hostname = "localhost"
sock_mock = self.get_socket_mock(expected_ip, expected_hostname)
with patch("salt.utils.ssdp.socket", sock_mock):
factory = ssdp.SSDPDiscoveryClient(**config)
return factory
def test_config_detached(self):
'''
Test if the passed configuration is not a reference.
:return:
'''
config = {
ssdp.SSDPBase.SIGNATURE: 'SUSE Enterprise Server',
}
clnt = ssdp.SSDPDiscoveryClient(**config)
clnt._config['foo'] = 'bar'
assert 'foo' in clnt._config
assert 'foo' not in config
def test_discover_no_masters(self):
'''
Test discover available master on the network (none found).
:return:
'''
clnt = ssdp.SSDPDiscoveryClient()
clnt._query = MagicMock()
clnt._collect_masters_map = MagicMock()
clnt.log = MagicMock()
clnt.discover()
assert clnt.log.info.called
assert clnt.log.info.call_args[0][
0] == 'No master has been discovered.'
def test_get_masters_map(self):
"""
Test getting map of the available masters on the network
:return:
"""
_socket = MagicMock()
response = {}
with patch("salt.utils.ssdp.socket", _socket):
clnt = ssdp.SSDPDiscoveryClient()
clnt._socket.recvfrom = SSDPClientTestCase.Resource().read
clnt.log = MagicMock()
clnt._collect_masters_map(response=response)
assert "10.10.10.10" in response
assert "20.20.20.20" in response
assert response["10.10.10.10"] == ["some", "data"]
assert response["20.20.20.20"] == ["data"]
def test_get_masters_map(self):
'''
Test getting map of the available masters on the network
:return:
'''
_socket = MagicMock()
response = {}
with patch('salt.utils.ssdp.socket', _socket):
clnt = ssdp.SSDPDiscoveryClient()
clnt._socket.recvfrom = SSDPClientTestCase.Resource().read
clnt.log = MagicMock()
clnt._collect_masters_map(response=response)
assert '10.10.10.10' in response
assert '20.20.20.20' in response
assert response['10.10.10.10'] == ['some', 'data']
assert response['20.20.20.20'] == ['data']
def test_config_passed(self):
'''
Test if the configuration is passed.
:return:
'''
config = {
ssdp.SSDPBase.SIGNATURE: 'SUSE Enterprise Server',
ssdp.SSDPBase.TIMEOUT: 5,
ssdp.SSDPBase.PORT: 12345
}
clnt = ssdp.SSDPDiscoveryClient(**config)
assert clnt._config[ssdp.SSDPBase.SIGNATURE] == config[
ssdp.SSDPBase.SIGNATURE]
assert clnt._config[ssdp.SSDPBase.PORT] == config[ssdp.SSDPBase.PORT]
assert clnt._config[ssdp.SSDPBase.TIMEOUT] == config[
ssdp.SSDPBase.TIMEOUT]
def test_get_masters_map_error_handling(self):
"""
Test getting map handles timeout network exception
:return:
"""
_socket = MagicMock()
response = {}
error_msg = "fake testing timeout just had happened"
with patch("salt.utils.ssdp.socket", _socket):
clnt = ssdp.SSDPDiscoveryClient()
clnt._socket.recvfrom = MagicMock(side_effect=Exception(error_msg))
clnt.log = MagicMock()
clnt._collect_masters_map(response=response)
assert clnt.log.error.called
assert ("Discovery master collection failure"
in clnt.log.error.call_args[0][0])
assert error_msg == six.text_type(clnt.log.error.call_args[0][1])
assert not response
def test_query(self):
'''
Test if client queries the broadcast
:return:
'''
config = {
ssdp.SSDPBase.SIGNATURE: 'SUSE Enterprise Server',
ssdp.SSDPBase.PORT: 4000
}
f_time = 1111
_socket = MagicMock()
with patch('salt.utils.ssdp.socket', _socket),\
patch('salt.utils.ssdp.time.time', MagicMock(return_value=f_time)):
clnt = ssdp.SSDPDiscoveryClient(**config)
clnt._query()
assert clnt._socket.sendto.called
message, target = clnt._socket.sendto.call_args[0]
assert message == salt.utils.stringutils.to_bytes('{}{}'.format(
config[ssdp.SSDPBase.SIGNATURE], f_time))
assert target[0] == '<broadcast>'
assert target[1] == config[ssdp.SSDPBase.PORT]
def test_query(self):
"""
Test if client queries the broadcast
:return:
"""
config = {
ssdp.SSDPBase.SIGNATURE: "SUSE Enterprise Server",
ssdp.SSDPBase.PORT: 4000,
}
f_time = 1111
_socket = MagicMock()
with patch("salt.utils.ssdp.socket",
_socket), patch("salt.utils.ssdp.time.time",
MagicMock(return_value=f_time)):
clnt = ssdp.SSDPDiscoveryClient(**config)
clnt._query()
assert clnt._socket.sendto.called
message, target = clnt._socket.sendto.call_args[0]
assert message == salt.utils.stringutils.to_bytes("{}{}".format(
config[ssdp.SSDPBase.SIGNATURE], f_time))
assert target[0] == "<broadcast>"
assert target[1] == config[ssdp.SSDPBase.PORT]
