def test_add_multiples_of_slave_connection(self):
self.assertIsNotNone(self.mock_master.slave_connections)
self.mock_master.add_slave_connection(SlaveConnection(None))
slavc = SlaveConnection(None)
slavc.full_address = "192.168.100.1"
self.mock_master.add_slave_connection(slavc)
self.assertGreaterEqual(len(self.mock_master.slave_connections.keys()), 2)
def test_update_connection_works2(self):
with patch.object(self.layout, 'notify', return_value=None) as mock_method:
connection_mock = Mock(RemuTCP)
slave_connection_mock = SlaveConnection(self.mock_master)
slave_connection_mock.set_connection(connection_mock)
self.mock_master.add_slave_connection(slave_connection_mock)
self.mock_master.notify(Notification.CONNECTION_ESTABLISHED, "localhost:8000")
mock_method.assert_called_once_with(Notification.CONNECTION_ESTABLISHED, slave_connection_mock)
def test_update_presentation_status_to_layout_works(self):
with patch.object(self.layout, 'notify', return_value=None) as mock_method:
connection_mock = Mock(RemuTCP)
slave_connection_mock = SlaveConnection(self.mock_master)
slave_connection_mock.set_connection(connection_mock)
self.mock_master.add_slave_connection(slave_connection_mock)
self.mock_master.notify(Notification.PRESENTATION_UPDATE, "localhost:8000")
mock_method.assert_called_once_with(Notification.PRESENTATION_UPDATE, "localhost:8000")
def test_close_connections(self):
with patch.object(RemuTCP, 'end_connection', return_value=None) as mock_method:
connection_mock = RemuTCP(self.mock_master, True, "")
slave_connection_mock = SlaveConnection(self.mock_master)
slave_connection_mock.set_connection(connection_mock)
self.mock_master.add_slave_connection(slave_connection_mock)
self.mock_master.close_TCP_connections()
mock_method.assert_called_once_with()
def add_slave(self, slave_address, slave_name=None):
"""
Adds a slave connection by creating a new RemuTCP object
and adding it to the dictionary self.slave_connections
address: an ip-string formatted as "ipa.ddr.es.s:port"
"""
slave_to_connect = SlaveConnection(self, slave_name)
slave_to_connect.connect_to_IP(slave_address)
self.slave_connections[slave_name] = slave_to_connect
#self.layout.notify(Notification.PRESENTATION_UPDATE, slave_to_connect)
Logger.debug("Master: Slave length: %s",
str(len(self.slave_connections)))
Logger.debug("Master: Presentation length: %s",
str(len(self.presentations)))
def test_request_next_calls_slave_connections_show_next(self):
with patch.object(SlaveConnection, 'show_next', return_value=None) as mock_method:
slave_connection_mock = SlaveConnection(self.mock_master)
self.mock_master.add_slave_connection(slave_connection_mock)
self.mock_master.request_next()
mock_method.assert_called_once_with()
def test_binding_slave(self):
with patch.object(MasterGUILayout, "notify", return_value=None) as notifier:
self.mock_master.add_slave_connection(SlaveConnection(None))
presentation = Presentation()
presentation.presentation_filenames = ["aaaa"]
self.mock_master.bind_slave_to_presentation(presentation, "localhost:8000")
self.assertEqual(self.mock_master.slave_connections["localhost:8000"].presentation.presentation_filenames, ["aaaa"])
self.layout.notify.assert_called_once_with(Notification.PRESENTING_DISABLED, False)
class ProjectOverviewTest(unittest.TestCase):
def setUp(self):
self.slave_overview = ProjectOverview()
self.slave_connection_mock = SlaveConnection(Mock(Master))
presentation = Presentation()
presentation.set_files(["a.jpg", "b.jpg", "g.mp4", "test_text.txt", "test_text2.txt"])
self.slave_connection_mock.set_presentation(presentation)
def test_update_slave_to_overview(self):
self.slave_overview.update_slave_to_overview(self.slave_connection_mock)
self.assertIsNotNone(self.slave_overview.slave_buttons[self.slave_connection_mock.full_address])
self.assertIsNotNone(self.slave_overview.slave_presentations[self.slave_connection_mock.full_address])
def test_remove_slave_from_overview(self):
self.slave_overview.update_slave_to_overview(self.slave_connection_mock)
self.slave_overview.remove_slave_from_overview(self.slave_connection_mock.full_address)
self.assertNotIn(self.slave_connection_mock.full_address, self.slave_overview.slave_buttons)
self.assertNotIn(self.slave_connection_mock.full_address, self.slave_overview.slave_presentations)
def test_request_next_calls_multiple_slave_connections_show_next(self):
self.assertIsNotNone(self.mock_master.slave_connections)
slavc = SlaveConnection(None)
slavc.show_next = MagicMock(return_value=0)
self.mock_master.add_slave_connection(slavc)
slavc = SlaveConnection(None)
slavc.full_address = "192.168.100.1"
slavc.show_next = MagicMock(return_value=0)
self.mock_master.add_slave_connection(slavc)
self.mock_master.request_next()
for slaveconnection in self.mock_master.slave_connections.values():
slaveconnection.show_next.assert_called_once_with()
def setUp(self):
self.slave_overview = ProjectOverview()
self.slave_connection_mock = SlaveConnection(Mock(Master))
presentation = Presentation()
presentation.set_files(["a.jpg", "b.jpg", "g.mp4", "test_text.txt", "test_text2.txt"])
self.slave_connection_mock.set_presentation(presentation)
def test_connection_established_notifies_master(self):
slavecon = SlaveConnection(Mock(Master))
slavecon.connection_established("123.123.123.123:123123")
slavecon.master.notify.called_once_with(Notification.CONNECTION_ESTABLISHED, "123.123.123.123:123123")
def test_connection_established_sets_connected_true(self):
slavecon = SlaveConnection(Mock(Master))
self.assertFalse(slavecon.connected)
slavecon.connection_established("123.123.123.123:123123")
self.assertTrue(slavecon.connected)
def test_init_without_params(self):
empty_slavecon = SlaveConnection(None)
self.assertIsNone(empty_slavecon.connection)
def setUp(self):
self.connection_mock = Mock(RemuTCP)
self.sc = SlaveConnection(None, None, self.connection_mock)
class SlaveConnectionTest(unittest.TestCase):
def setUp(self):
self.connection_mock = Mock(RemuTCP)
self.sc = SlaveConnection(None, None, self.connection_mock)
def test_init_with_connection(self):
self.assertEqual(self.connection_mock, self.sc.connection)
def test_init_without_params(self):
empty_slavecon = SlaveConnection(None)
self.assertIsNone(empty_slavecon.connection)
def test_invalid_ip_address1(self):
self.sc.connect_to_IP("192.168.asd.1")
self.assertIsNone(self.sc.connection)
def test_invalid_ip_address2(self):
self.sc.connect_to_IP("192.168:7000")
self.assertIsNone(self.sc.connection)
def test_invalid_ip_address3(self):
self.sc.connect_to_IP("192.168.1234.1")
self.assertIsNone(self.sc.connection)
def test_invalid_port1(self):
self.sc.connect_to_IP("192.168.1.2:1111asd")
self.assertIsNone(self.sc.connection)
def test_invalid_port2(self):
self.sc.connect_to_IP("192.168.1.2:")
self.assertIsNone(self.sc.connection)
"""
def test_show_next(self):
presentation = Presentation()
presentation.set_files(["first", "second"])
presentation.load()
self.sc.presentation = presentation
self.assertEqual(self.sc.currently_showing, -1)
self.sc.response_next()
self.assertEqual(self.sc.currently_showing, -1)
self.sc.response_next()
self.assertEqual(self.sc.currently_showing, "second")
"""
def test_show_next_calls_send_message(self):
self.sc.show_next()
calls = self.connection_mock.method_calls
name = calls[0][0]
self.assertEqual(name, "send_message")
def test_handle_invalid_command(self):
msg = Message()
msg.set_field(MessageKeys.response_key, "LET ME OUT LET ME OUT LET ME OUT")
self.sc.handle_message(msg)
def test_terminate_connection_sends_commands_and_closes_connections(self):
self.sc.master = Mock(Master)
self.sc.terminate_connection()
self.sc.connection.end_connection.assert_called_once_with()
self.sc.master.notify.assert_called_once_with(Notification.CONNECTION_TERMINATED, self.sc)
def test_end_presentation_sends_command(self):
self.sc.end_presentation()
command_value = self.sc.connection.mock_calls[0][1][0].fields["command"]
self.assertEqual(command_value, Command.END_PRESENTATION.value)
"""
def test_presentation_resets_when_next_item_is_none(self):
self.sc.master = Mock(Master)
self.sc.presentation = Mock(Presentation)
self.sc.presentation.get_next = Mock(return_value=None)
self.sc.handle_show_next_response()
self.sc.presentation.get_next.assert_called_once_with()
self.sc.presentation.reset.assert_called_once_with()
"""
def test_connection_established_sets_connected_true(self):
slavecon = SlaveConnection(Mock(Master))
self.assertFalse(slavecon.connected)
slavecon.connection_established("123.123.123.123:123123")
self.assertTrue(slavecon.connected)
def test_connection_established_notifies_master(self):
slavecon = SlaveConnection(Mock(Master))
slavecon.connection_established("123.123.123.123:123123")
slavecon.master.notify.called_once_with(Notification.CONNECTION_ESTABLISHED, "123.123.123.123:123123")
def test_on_connection_lost_sets_connected_false(self):
self.sc.master = Mock(Master)
self.assertTrue(self.sc.connected)
self.sc.on_connection_lost()
self.assertFalse(self.sc.connected)
def test_on_connection_lost_notifies_master(self):
slavecon = SlaveConnection(Mock(Master))
slavecon.connection_established("123.123.123.123:123123")
slavecon.on_connection_lost()
slavecon.master.notify.called_once_with(Notification.CONNECTION_FAILED, "123.123.123.123:123123")
def test_send_presentation(self):
with patch.object(SlaveConnection, 'send_command', return_value=None) as mock_method:
self.sc.send_presentation(["a.jpg", "b.jpg"])
mock_method.assert_called_once_with(Command.SEND_PRESENTATION.value, {'presentation_content': ['a.jpg', 'b.jpg']})
def test_handle_show_next_response(self):
self.sc.master = MagicMock(Master)
self.sc.presentation = Presentation()
self.sc.handle_show_next_response({MessageKeys.index_key: 1})
self.sc.master.notify.assert_called_once_with(Notification.PRESENTATION_STATUS_CHANGE, 1)
def test_add_slave_connection_works(self):
self.assertIsNotNone(self.mock_master.slave_connections)
self.mock_master.add_slave_connection(SlaveConnection(None))
self.assertGreaterEqual(len(self.mock_master.slave_connections.keys()), 1)
