def test_do_command_passthrough(self):
        """ Test for the do_command with passthrough data. """
        action = master_api.basic_action()
        in_fields = {"action_type": 1, "action_number": 2}
        out_fields = {"resp": "OK"}

        serial_mock = SerialMock([
            sin(action.create_input(1, in_fields)),
            sout("hello" + action.create_output(1, out_fields)),
            sin(action.create_input(2, in_fields)),
            sout(action.create_output(2, out_fields) + "world"),
            sin(action.create_input(3, in_fields)),
            sout("hello" + action.create_output(3, out_fields) + " world"),
            sin(action.create_input(4, in_fields)),
            sout("hello"),
            sout(action.create_output(4, out_fields))
        ])

        comm = MasterCommunicator(serial_mock, init_master=False)
        comm.enable_passthrough()
        comm.start()

        self.assertEquals("OK", comm.do_command(action, in_fields)["resp"])
        self.assertEquals("hello", comm.get_passthrough_data())

        self.assertEquals("OK", comm.do_command(action, in_fields)["resp"])
        self.assertEquals("world", comm.get_passthrough_data())

        self.assertEquals("OK", comm.do_command(action, in_fields)["resp"])
        self.assertEquals("hello world", comm.get_passthrough_data())

        self.assertEquals("OK", comm.do_command(action, in_fields)["resp"])
        self.assertEquals("hello", comm.get_passthrough_data())
    def test_do_command_passthrough(self):
        """ Test for the do_command with passthrough data. """
        action = master_api.basic_action()
        in_fields = {"action_type": 1, "action_number": 2}
        out_fields = {"resp": "OK"}

        serial_mock = SerialMock(
                        [sin(action.create_input(1, in_fields)),
                         sout("hello" + action.create_output(1, out_fields)),
                         sin(action.create_input(2, in_fields)),
                         sout(action.create_output(2, out_fields) + "world"),
                         sin(action.create_input(3, in_fields)),
                         sout("hello" + action.create_output(3, out_fields) + " world"),
                         sin(action.create_input(4, in_fields)),
                         sout("hello"), sout(action.create_output(4, out_fields))])

        comm = MasterCommunicator(serial_mock, init_master=False)
        comm.enable_passthrough()
        comm.start()

        self.assertEquals("OK", comm.do_command(action, in_fields)["resp"])
        self.assertEquals("hello", comm.get_passthrough_data())

        self.assertEquals("OK", comm.do_command(action, in_fields)["resp"])
        self.assertEquals("world", comm.get_passthrough_data())

        self.assertEquals("OK", comm.do_command(action, in_fields)["resp"])
        self.assertEquals("hello world", comm.get_passthrough_data())

        self.assertEquals("OK", comm.do_command(action, in_fields)["resp"])
        self.assertEquals("hello", comm.get_passthrough_data())
    def test_background_consumer(self):
        """ Test the background consumer mechanism. """
        action = master_api.basic_action()
        in_fields = {"action_type": 1, "action_number": 2}
        out_fields = {"resp": "OK"}

        serial_mock = SerialMock([
                        sout("OL\x00\x01\x03\x0c\r\n"), sin(action.create_input(1, in_fields)),
                        sout("junkOL\x00\x02\x03\x0c\x05\x06\r\n here"),
                        sout(action.create_output(1, out_fields))])

        comm = MasterCommunicator(serial_mock, init_master=False)
        comm.enable_passthrough()

        got_output = {"phase": 1}

        def callback(output):
            """ Callback that check if the correct result was returned for OL. """
            if got_output["phase"] == 1:
                self.assertEquals([(3, int(12 * 10.0 / 6.0))], output["outputs"])
                got_output["phase"] = 2
            elif got_output["phase"] == 2:
                self.assertEquals([(3, int(12 * 10.0 / 6.0)), (5, int(6 * 10.0 / 6.0))],
                                  output["outputs"])
                got_output["phase"] = 3

        comm.register_consumer(BackgroundConsumer(master_api.output_list(), 0, callback))
        comm.start()

        self.assertEquals("OK", comm.do_command(action, in_fields)["resp"])
        self.assertEquals(3, got_output["phase"])
        self.assertEquals("junk here", comm.get_passthrough_data())
    def test_maintenance_passthrough(self):
        """ Test the behavior of passthrough in maintenance mode. """
        serial_mock = SerialMock([
            sout("For passthrough"),
            sin(master_api.to_cli_mode().create_input(0)),
            sout("OK"),
            sin("error list\r\n"),
            sout("the list\n"),
            sin("exit\r\n"),
            sout("Passthrough again")
        ])

        comm = MasterCommunicator(serial_mock, init_master=False)
        comm.enable_passthrough()
        comm.start()

        def passthrough_thread():
            """ Background thread that reads the passthrough data. """
            self.assertEquals("For passthrough", comm.get_passthrough_data())
            self.assertEquals("Passthrough again", comm.get_passthrough_data())

        thread = threading.Thread(target=passthrough_thread)
        thread.start()

        comm.start_maintenance_mode()
        self.assertEquals("OK", comm.get_maintenance_data())
        comm.send_maintenance_data("error list\r\n")
        self.assertEquals("the list\n", comm.get_maintenance_data())
        comm.stop_maintenance_mode()

        thread.join()
    def test_maintenance_passthrough(self):
        """ Test the behavior of passthrough in maintenance mode. """
        serial_mock = SerialMock([
                        sout("For passthrough"), sin(master_api.to_cli_mode().create_input(0)),
                        sout("OK"), sin("error list\r\n"), sout("the list\n"),
                        sin("exit\r\n"), sout("Passthrough again")])

        comm = MasterCommunicator(serial_mock, init_master=False)
        comm.enable_passthrough()
        comm.start()

        def passthrough_thread():
            """ Background thread that reads the passthrough data. """
            self.assertEquals("For passthrough", comm.get_passthrough_data())
            self.assertEquals("Passthrough again", comm.get_passthrough_data())

        thread = threading.Thread(target=passthrough_thread)
        thread.start()

        comm.start_maintenance_mode()
        self.assertEquals("OK", comm.get_maintenance_data())
        comm.send_maintenance_data("error list\r\n")
        self.assertEquals("the list\n", comm.get_maintenance_data())
        comm.stop_maintenance_mode()

        thread.join()
示例#6
0
    def test_passthrough(self):
        """ Test the passthrough. """
        master_mock = SerialMock([
                        sout("data for the passthrough"), sin("response"),
                        sout("more data"), sin("more response")])

        passthrough_mock = SerialMock([
                        sin("data for the passthrough"), sout("response"),
                        sin("more data"), sout("more response")])

        master_communicator = MasterCommunicator(master_mock, init_master=False)
        master_communicator.enable_passthrough()
        master_communicator.start()

        passthrough = PassthroughService(master_communicator, passthrough_mock)
        passthrough.start()

        time.sleep(1)

        self.assertEquals(33, master_communicator.get_bytes_read())
        self.assertEquals(21, master_communicator.get_bytes_written())

        self.assertEquals(33, master_mock.bytes_read)
        self.assertEquals(21, master_mock.bytes_written)

        self.assertEquals(21, passthrough_mock.bytes_read)
        self.assertEquals(33, passthrough_mock.bytes_written)

        passthrough.stop()
    def test_passthrough_output(self):
        """ Test the passthrough output if no other communications are going on. """
        serial_mock = SerialMock([sout("passthrough"), sout(" my "), sout("data")])

        comm = MasterCommunicator(serial_mock, init_master=False)
        comm.enable_passthrough()
        comm.start()

        self.assertEquals("passthrough", comm.get_passthrough_data())
        self.assertEquals(" my ", comm.get_passthrough_data())
        self.assertEquals("data", comm.get_passthrough_data())
    def test_send_passthrough_data(self):
        """ Test the passthrough if no other communications are going on. """
        pt_input = "data from passthrough"
        pt_output = "got it !"
        serial_mock = SerialMock([sin(pt_input), sout(pt_output)])

        comm = MasterCommunicator(serial_mock, init_master=False)
        comm.enable_passthrough()
        comm.start()

        comm.send_passthrough_data(pt_input)
        self.assertEquals(pt_output, comm.get_passthrough_data())
    def test_send_passthrough_data(self):
        """ Test the passthrough if no other communications are going on. """
        pt_input = "data from passthrough"
        pt_output = "got it !"
        serial_mock = SerialMock([sin(pt_input), sout(pt_output)])

        comm = MasterCommunicator(serial_mock, init_master=False)
        comm.enable_passthrough()
        comm.start()

        comm.send_passthrough_data(pt_input)
        self.assertEquals(pt_output, comm.get_passthrough_data())
    def test_passthrough_output(self):
        """ Test the passthrough output if no other communications are going on. """
        serial_mock = SerialMock(
            [sout("passthrough"),
             sout(" my "), sout("data")])

        comm = MasterCommunicator(serial_mock, init_master=False)
        comm.enable_passthrough()
        comm.start()

        self.assertEquals("passthrough", comm.get_passthrough_data())
        self.assertEquals(" my ", comm.get_passthrough_data())
        self.assertEquals("data", comm.get_passthrough_data())
示例#11
0
    def test_passthrough(self):
        """ Test the passthrough. """
        master_mock = SerialMock([
            sout("data for the passthrough"),
            sin("response"),
            sout("more data"),
            sin("more response")
        ])
        passthrough_mock = SerialMock([
            sin("data for the passthrough"),
            sout("response"),
            sin("more data"),
            sout("more response")
        ])
        SetUpTestInjections(controller_serial=master_mock,
                            passthrough_serial=passthrough_mock)

        master_communicator = MasterCommunicator(init_master=False)
        master_communicator.enable_passthrough()
        master_communicator.start()

        SetUpTestInjections(master_communicator=master_communicator)

        passthrough = PassthroughService()
        passthrough.start()

        time.sleep(1)

        self.assertEquals(
            33,
            master_communicator.get_communication_statistics()['bytes_read'])
        self.assertEquals(
            21,
            master_communicator.get_communication_statistics()
            ['bytes_written'])

        self.assertEquals(33, master_mock.bytes_read)
        self.assertEquals(21, master_mock.bytes_written)

        self.assertEquals(21, passthrough_mock.bytes_read)
        self.assertEquals(33, passthrough_mock.bytes_written)

        passthrough.stop()
    def test_background_consumer_passthrough(self):
        """ Test the background consumer with passing the data to the passthrough. """
        serial_mock = SerialMock([sout("OL\x00\x01"), sout("\x03\x0c\r\n")])
        comm = MasterCommunicator(serial_mock, init_master=False)
        comm.enable_passthrough()

        got_output = {"passed": False}

        def callback(output):
            """ Callback that check if the correct result was returned for OL. """
            self.assertEquals([(3, int(12 * 10.0 / 6.0))], output["outputs"])
            got_output["passed"] = True

        comm.register_consumer(BackgroundConsumer(master_api.output_list(), 0, callback, True))
        comm.start()

        MasterCommunicatorTest._wait_for_callback(True, got_output, 3)
        self.assertEquals(True, got_output["passed"])
        self.assertEquals("OL\x00\x01\x03\x0c\r\n", comm.get_passthrough_data())
    def test_bytes_counter(self):
        """ Test the number of bytes written and read from the serial port. """
        action = master_api.basic_action()
        in_fields = {"action_type": 1, "action_number": 2}
        out_fields = {"resp": "OK"}

        serial_mock = SerialMock(
                        [sin(action.create_input(1, in_fields)),
                         sout("hello"),
                         sout(action.create_output(1, out_fields))])

        comm = MasterCommunicator(serial_mock, init_master=False)
        comm.enable_passthrough()
        comm.start()

        self.assertEquals("OK", comm.do_command(action, in_fields)["resp"])
        self.assertEquals("hello", comm.get_passthrough_data())

        self.assertEquals(21, comm.get_bytes_written())
        self.assertEquals(5 + 18, comm.get_bytes_read())
    def test_background_consumer_passthrough(self):
        """ Test the background consumer with passing the data to the passthrough. """
        serial_mock = SerialMock([sout("OL\x00\x01"), sout("\x03\x0c\r\n")])
        comm = MasterCommunicator(serial_mock, init_master=False)
        comm.enable_passthrough()

        got_output = {"passed": False}

        def callback(output):
            """ Callback that check if the correct result was returned for OL. """
            self.assertEquals([(3, int(12 * 10.0 / 6.0))], output["outputs"])
            got_output["passed"] = True

        comm.register_consumer(
            BackgroundConsumer(master_api.output_list(), 0, callback, True))
        comm.start()

        self.assertEquals(True, got_output["passed"])
        self.assertEquals("OL\x00\x01\x03\x0c\r\n",
                          comm.get_passthrough_data())
    def test_bytes_counter(self):
        """ Test the number of bytes written and read from the serial port. """
        action = master_api.basic_action()
        in_fields = {"action_type": 1, "action_number": 2}
        out_fields = {"resp": "OK"}

        serial_mock = SerialMock([
            sin(action.create_input(1, in_fields)),
            sout("hello"),
            sout(action.create_output(1, out_fields))
        ])

        comm = MasterCommunicator(serial_mock, init_master=False)
        comm.enable_passthrough()
        comm.start()

        self.assertEquals("OK", comm.do_command(action, in_fields)["resp"])
        self.assertEquals("hello", comm.get_passthrough_data())

        self.assertEquals(21, comm.get_bytes_written())
        self.assertEquals(5 + 18, comm.get_bytes_read())
    def test_background_consumer(self):
        """ Test the background consumer mechanism. """
        action = master_api.basic_action()
        in_fields = {"action_type": 1, "action_number": 2}
        out_fields = {"resp": "OK"}

        serial_mock = SerialMock([
            sout("OL\x00\x01\x03\x0c\r\n"),
            sin(action.create_input(1, in_fields)),
            sout("junkOL\x00\x02\x03\x0c\x05\x06\r\n here"),
            sout(action.create_output(1, out_fields))
        ])
        SetUpTestInjections(controller_serial=serial_mock)

        comm = MasterCommunicator(init_master=False)
        comm.enable_passthrough()

        got_output = {"phase": 1}

        def callback(output):
            """ Callback that check if the correct result was returned for OL. """
            if got_output["phase"] == 1:
                self.assertEquals([(3, int(12 * 10.0 / 6.0))],
                                  output["outputs"])
                got_output["phase"] = 2
            elif got_output["phase"] == 2:
                self.assertEquals([(3, int(12 * 10.0 / 6.0)),
                                   (5, int(6 * 10.0 / 6.0))],
                                  output["outputs"])
                got_output["phase"] = 3

        comm.register_consumer(
            BackgroundConsumer(master_api.output_list(), 0, callback))
        comm.start()

        self.assertEquals("OK", comm.do_command(action, in_fields)["resp"])
        self.assertEquals(3, got_output["phase"])
        self.assertEquals("junk here", comm.get_passthrough_data())
示例#17
0
    def test_passthrough(self):
        """ Test the passthrough. """
        master_mock = SerialMock([
            sout("data for the passthrough"),
            sin("response"),
            sout("more data"),
            sin("more response")
        ])

        passthrough_mock = SerialMock([
            sin("data for the passthrough"),
            sout("response"),
            sin("more data"),
            sout("more response")
        ])

        master_communicator = MasterCommunicator(master_mock,
                                                 init_master=False)
        master_communicator.enable_passthrough()
        master_communicator.start()

        passthrough = PassthroughService(master_communicator, passthrough_mock)
        passthrough.start()

        time.sleep(1)

        self.assertEquals(33, master_communicator.get_bytes_read())
        self.assertEquals(21, master_communicator.get_bytes_written())

        self.assertEquals(33, master_mock.bytes_read)
        self.assertEquals(21, master_mock.bytes_written)

        self.assertEquals(21, passthrough_mock.bytes_read)
        self.assertEquals(33, passthrough_mock.bytes_written)

        passthrough.stop()