def test_valid_complete_sample(self):
"""
Create a mock port agent
"""
mock_port_agent = Mock(spec=LoggerClient)
"""
Instantiate the driver class directly (no driver client, no driver
client, no zmq driver process, no driver process; just own the driver)
"""
test_driver = ooicoreInstrumentDriver(self.my_event_callback)
current_state = test_driver.get_resource_state()
self.assertEqual(current_state, DriverConnectionState.UNCONFIGURED)
"""
Now configure the driver with the mock_port_agent, verifying
that the driver transitions to the DISCONNECTED state
"""
config = {'mock_port_agent' : mock_port_agent}
test_driver.configure(config = config)
current_state = test_driver.get_resource_state()
self.assertEqual(current_state, DriverConnectionState.DISCONNECTED)
"""
Invoke the connect method of the driver: should connect to mock
port agent. Verify that the connection FSM transitions to CONNECTED,
(which means that the FSM should now be reporting the ProtocolState).
"""
test_driver.connect()
current_state = test_driver.get_resource_state()
self.assertEqual(current_state, DriverProtocolState.UNKNOWN)
"""
Force the driver into AUTOSAMPLE state so that it will parse and
publish samples
"""
test_driver.set_test_mode(True)
test_driver.test_force_state(state = DriverProtocolState.AUTOSAMPLE)
current_state = test_driver.get_resource_state()
self.assertEqual(current_state, DriverProtocolState.AUTOSAMPLE)
"""
- Reset test verification variables.
- Construct a complete sample
- Pass to got_data()
- Verify that raw and parsed streams have been received
"""
self.reset_test_vars()
packet = PortAgentPacket()
header = "\xa3\x9d\x7a\x02\x00\x1c\x0b\x2e\x00\x00\x00\x01\x80\x00\x00\x00"
packet.unpack_header(header)
packet.attach_data(FULL_SAMPLE)
test_driver._protocol.got_data(packet)
self.assertTrue(self.raw_stream_received)
self.assertTrue(self.parsed_stream_received)
def test_valid_complete_sample(self):
"""
Create a mock port agent
"""
mock_port_agent = Mock(spec=LoggerClient)
"""
Instantiate the driver class directly (no driver client, no driver
client, no zmq driver process, no driver process; just own the driver)
"""
test_driver = ooicoreInstrumentDriver(self.my_event_callback)
current_state = test_driver.get_resource_state()
self.assertEqual(current_state, DriverConnectionState.UNCONFIGURED)
"""
Now configure the driver with the mock_port_agent, verifying
that the driver transitions to the DISCONNECTED state
"""
config = {"mock_port_agent": mock_port_agent}
test_driver.configure(config=config)
current_state = test_driver.get_resource_state()
self.assertEqual(current_state, DriverConnectionState.DISCONNECTED)
"""
Invoke the connect method of the driver: should connect to mock
port agent. Verify that the connection FSM transitions to CONNECTED,
(which means that the FSM should now be reporting the ProtocolState).
"""
test_driver.connect()
current_state = test_driver.get_resource_state()
self.assertEqual(current_state, DriverProtocolState.UNKNOWN)
"""
Force the driver into AUTOSAMPLE state so that it will parse and
publish samples
"""
test_driver.set_test_mode(True)
test_driver.test_force_state(state=DriverProtocolState.AUTOSAMPLE)
current_state = test_driver.get_resource_state()
self.assertEqual(current_state, DriverProtocolState.AUTOSAMPLE)
"""
- Reset test verification variables.
- Construct a complete sample
- Pass to got_data()
- Verify that raw and parsed streams have been received
"""
self.reset_test_vars()
packet = PortAgentPacket()
header = "\xa3\x9d\x7a\x02\x00\x1c\x0b\x2e\x00\x00\x00\x01\x80\x00\x00\x00"
packet.unpack_header(header)
packet.attach_data(FULL_SAMPLE)
test_driver._protocol.got_data(packet)
self.assertTrue(self.raw_stream_received)
self.assertTrue(self.parsed_stream_received)
class TestPortAgentPacket(MiUnitTest):
# time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.localtime(time.time()))
#
@staticmethod
def ntp_to_system_time(date):
"""convert a NTP time to system time"""
return date - NTP_DELTA
@staticmethod
def system_to_ntp_time(date):
"""convert a system time to a NTP time"""
return date + NTP_DELTA
def setUp(self):
self.pap = PortAgentPacket()
#self.test_time = time.time()
#self.ntp_time = self.system_to_ntp_time(self.test_time)
#self.pap.set_timestamp(self.ntp_time)
def test_pack_header(self):
self.pap.attach_data("Only the length of this matters?") # 32 chars
#self.pap.set_timestamp(3564425404.85)
self.pap.pack_header()
header = self.pap.get_header()
self.assertEqual(header, array.array('B', [163, 157, 122, 2, 0, 48, 14, 145, 65, 234, 142, 154, 23, 155, 51, 51]))
pass
def test_unpack_header(self):
self.pap = PortAgentPacket()
data = self.pap.unpack_header(array.array('B', [163, 157, 122, 2, 0, 48, 14, 145, 65, 234, 142, 154, 23, 155, 51, 51]))
self.assertEqual(self.pap.get_header_type(), 2)
self.assertEqual(self.pap.get_header_length(), 32)
self.assertEqual(time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.localtime(self.ntp_to_system_time(self.pap.get_timestamp()))), "Thu, 13 Dec 2012 14:10:04 +0000")
self.assertEqual(self.pap.get_header_recv_checksum(), 3729) #@TODO Probably should wire in one of these checksums.
self.assertEqual(self.pap.get_header_checksum(), None)
pass
def test_get_time_stamp(self):
result = self.pap.get_timestamp()
self.assertEqual(self.ntp_time, result)
pass
def test_pack_unpack_header_timestamp(self):
self.pap.attach_data("sweet polly purebread")
self.pap.pack_header()
header = self.pap.get_header()
self.pap.unpack_header(header)
result = self.pap.get_timestamp()
self.assertEqual(self.ntp_time, result)
pass
def _get_header(buffer):
packet = PortAgentPacket()
if(len(buffer) < HEADER_SIZE): return None
header = buffer[0:HEADER_SIZE]
packet.unpack_header(header)
if(packet.get_data_length() < 0): return None
return packet
def _get_header(buffer):
packet = PortAgentPacket()
if (len(buffer) < HEADER_SIZE): return None
header = buffer[0:HEADER_SIZE]
packet.unpack_header(header)
if (packet.get_data_length() < 0): return None
return packet
def _get_header(buffer):
packet = PortAgentPacket()
if (len(buffer) < HEADER_SIZE): return None
header = buffer[0:HEADER_SIZE]
packet.unpack_header(header)
if (packet.get_data_length() < 0): return None
print "time: %f" % packet.get_timestamp()
return packet
def _get_header(buffer):
packet = PortAgentPacket()
if(len(buffer) < HEADER_SIZE): return None
header = buffer[0:HEADER_SIZE]
packet.unpack_header(header)
if(packet.get_data_length() < 0): return None
print "time: %f" % packet.get_timestamp()
return packet
class PAClientTestPortAgentPacket(MiUnitTest):
@staticmethod
def ntp_to_system_time(date):
"""convert a NTP time to system time"""
return date - NTP_DELTA
@staticmethod
def system_to_ntp_time(date):
"""convert a system time to a NTP time"""
return date + NTP_DELTA
def setUp(self):
self.pap = PortAgentPacket()
# self.test_time = time.time()
# self.ntp_time = self.system_to_ntp_time(self.test_time)
# self.pap.set_timestamp(self.ntp_time)
def test_pack_header(self):
test_data = "Only the length of this matters?"
test_data_length = len(test_data)
self.pap.attach_data(test_data)
self.pap.pack_header()
self.assertEqual(self.pap.get_data_length(), test_data_length)
def test_get_length(self):
test_length = 100
self.pap.set_data_length(test_length)
got_length = self.pap.get_data_length()
self.assertEqual(got_length, test_length)
def test_checksum(self):
"""
This tests the checksum algorithm; if somebody changes the algorithm
this test should catch it. Had to jump through some hoops to do this;
needed to add set_data_length and set_header because we're building our
own header here (the one in PortAgentPacket includes the timestamp
so the checksum is not consistent).
"""
test_data = "This tests the checksum algorithm."
test_length = len(test_data)
self.pap.attach_data(test_data)
# Now build a header
variable_tuple = (0xa3, 0x9d, 0x7a, self.pap.DATA_FROM_DRIVER,
test_length + HEADER_SIZE, 0x0000,
0)
self.pap.set_data_length(test_length)
header_format = '>BBBBHHd'
size = struct.calcsize(header_format)
temp_header = ctypes.create_string_buffer(size)
struct.pack_into(header_format, temp_header, 0, *variable_tuple)
# Now set the header member in PortAgentPacket to the header
# we built
self.pap.set_header(temp_header.raw)
# Now get the checksum and verify it is what we expect it to be.
checksum = self.pap.calculate_checksum()
self.assertEqual(checksum, 2)
def test_unpack_header(self):
self.pap = PortAgentPacket()
data_length = 32
data = self.pap.unpack_header(array.array('B',
[163, 157, 122, 2, 0, data_length + HEADER_SIZE, 14, 145, 65, 234,
142, 154, 23, 155, 51, 51]))
got_timestamp = self.pap.get_timestamp()
self.assertEqual(self.pap.get_header_type(), self.pap.DATA_FROM_DRIVER)
self.assertEqual(self.pap.get_data_length(), data_length)
self.assertEqual(got_timestamp, 1105890970.092212)
self.assertEqual(self.pap.get_header_recv_checksum(), 3729)
class PAClientTestPortAgentPacket(MiUnitTest):
@staticmethod
def ntp_to_system_time(date):
"""convert a NTP time to system time"""
return date - NTP_DELTA
@staticmethod
def system_to_ntp_time(date):
"""convert a system time to a NTP time"""
return date + NTP_DELTA
def setUp(self):
self.pap = PortAgentPacket()
# self.test_time = time.time()
# self.ntp_time = self.system_to_ntp_time(self.test_time)
# self.pap.set_timestamp(self.ntp_time)
def test_pack_header(self):
test_data = "Only the length of this matters?"
test_data_length = len(test_data)
self.pap.attach_data(test_data)
self.pap.pack_header()
self.assertEqual(self.pap.get_data_length(), test_data_length)
def test_get_length(self):
test_length = 100
self.pap.set_data_length(test_length)
got_length = self.pap.get_data_length()
self.assertEqual(got_length, test_length)
def test_checksum(self):
"""
This tests the checksum algorithm; if somebody changes the algorithm
this test should catch it. Had to jump through some hoops to do this;
needed to add set_data_length and set_header because we're building our
own header here (the one in PortAgentPacket includes the timestamp
so the checksum is not consistent).
"""
test_data = "This tests the checksum algorithm."
test_length = len(test_data)
self.pap.attach_data(test_data)
# Now build a header
variable_tuple = (0xa3, 0x9d, 0x7a, self.pap.DATA_FROM_DRIVER,
test_length + HEADER_SIZE, 0x0000, 0)
self.pap.set_data_length(test_length)
header_format = '>BBBBHHd'
size = struct.calcsize(header_format)
temp_header = ctypes.create_string_buffer(size)
struct.pack_into(header_format, temp_header, 0, *variable_tuple)
# Now set the header member in PortAgentPacket to the header
# we built
self.pap.set_header(temp_header.raw)
# Now get the checksum and verify it is what we expect it to be.
checksum = self.pap.calculate_checksum()
self.assertEqual(checksum, 2)
def test_unpack_header(self):
self.pap = PortAgentPacket()
data_length = 32
data = self.pap.unpack_header(
array.array('B', [
163, 157, 122, 2, 0, data_length + HEADER_SIZE, 14, 145, 65,
234, 142, 154, 23, 155, 51, 51
]))
got_timestamp = self.pap.get_timestamp()
self.assertEqual(self.pap.get_header_type(), self.pap.DATA_FROM_DRIVER)
self.assertEqual(self.pap.get_data_length(), data_length)
self.assertEqual(got_timestamp, 1105890970.092212)
self.assertEqual(self.pap.get_header_recv_checksum(), 3729)
def test_concatenated_fragmented_sample(self):
"""
Simulate a complete sample that arrives in with a fragment concatenated. The concatenated fragment
should have have a terminator. A separate invocations of got_data() will have the remainder;
result should be a complete sample published
"""
"""
Create a mock port agent
"""
mock_port_agent = Mock(spec=LoggerClient)
"""
Instantiate the driver class directly (no driver client, no driver
client, no zmq driver process, no driver process; just own the driver)
"""
test_driver = ooicoreInstrumentDriver(self.my_event_callback)
current_state = test_driver.get_resource_state()
self.assertEqual(current_state, DriverConnectionState.UNCONFIGURED)
"""
Now configure the driver with the mock_port_agent, verifying
that the driver transitions to that state
"""
config = {'mock_port_agent' : mock_port_agent}
test_driver.configure(config = config)
current_state = test_driver.get_resource_state()
self.assertEqual(current_state, DriverConnectionState.DISCONNECTED)
"""
Invoke the connect method of the driver: should connect to mock
port agent. Verify that the connection FSM transitions to CONNECTED,
(which means that the FSM should now be reporting the ProtocolState).
"""
test_driver.connect()
current_state = test_driver.get_resource_state()
self.assertEqual(current_state, DriverProtocolState.UNKNOWN)
"""
Force the driver into AUTOSAMPLE state so that it will parse and
publish samples
"""
test_driver.set_test_mode(True)
test_driver.test_force_state(state = DriverProtocolState.AUTOSAMPLE)
current_state = test_driver.get_resource_state()
self.assertEqual(current_state, DriverProtocolState.AUTOSAMPLE)
"""
- Reset test verification variables.
- Construct a sample stream with a concatenated fragment
- Pass to got_data()
- Verify that raw and parsed streams have been received
- Later, when the final fragment has been send, verify that raw and
parsed streams have been received.
"""
self.reset_test_vars()
"""
- Add the beginning of another sample stream
- Pass to got_data()
"""
packet = PortAgentPacket()
header = "\xa3\x9d\x7a\x02\x00\x1c\x0b\x2e\x00\x00\x00\x01\x80\x00\x00\x00"
packet.unpack_header(header)
packet.attach_data(FULL_SAMPLE+SAMPLE_FRAGMENT_1)
test_driver._protocol.got_data(packet)
self.assertTrue(self.raw_stream_received)
self.assertTrue(self.parsed_stream_received)
"""
- Reset test verification variables
- Construct the final fragment of a sample stream
- Pass to got_data()
- Verify that raw and parsed streams have been received
"""
self.reset_test_vars()
packet = PortAgentPacket()
header = "\xa3\x9d\x7a\x02\x00\x1c\x0b\x2e\x00\x00\x00\x01\x80\x00\x00\x00"
packet.unpack_header(header)
packet.attach_data(SAMPLE_FRAGMENT_2)
test_driver._protocol.got_data(packet)
self.assertTrue(self.raw_stream_received)
self.assertTrue(self.parsed_stream_received)
def test_concatenated_fragmented_sample(self):
"""
Simulate a complete sample that arrives in with a fragment concatenated. The concatenated fragment
should have have a terminator. A separate invocations of got_data() will have the remainder;
result should be a complete sample published
"""
"""
Create a mock port agent
"""
mock_port_agent = Mock(spec=LoggerClient)
"""
Instantiate the driver class directly (no driver client, no driver
client, no zmq driver process, no driver process; just own the driver)
"""
test_driver = ooicoreInstrumentDriver(self.my_event_callback)
current_state = test_driver.get_resource_state()
self.assertEqual(current_state, DriverConnectionState.UNCONFIGURED)
"""
Now configure the driver with the mock_port_agent, verifying
that the driver transitions to that state
"""
config = {"mock_port_agent": mock_port_agent}
test_driver.configure(config=config)
current_state = test_driver.get_resource_state()
self.assertEqual(current_state, DriverConnectionState.DISCONNECTED)
"""
Invoke the connect method of the driver: should connect to mock
port agent. Verify that the connection FSM transitions to CONNECTED,
(which means that the FSM should now be reporting the ProtocolState).
"""
test_driver.connect()
current_state = test_driver.get_resource_state()
self.assertEqual(current_state, DriverProtocolState.UNKNOWN)
"""
Force the driver into AUTOSAMPLE state so that it will parse and
publish samples
"""
test_driver.set_test_mode(True)
test_driver.test_force_state(state=DriverProtocolState.AUTOSAMPLE)
current_state = test_driver.get_resource_state()
self.assertEqual(current_state, DriverProtocolState.AUTOSAMPLE)
"""
- Reset test verification variables.
- Construct a sample stream with a concatenated fragment
- Pass to got_data()
- Verify that raw and parsed streams have been received
- Later, when the final fragment has been send, verify that raw and
parsed streams have been received.
"""
self.reset_test_vars()
"""
- Add the beginning of another sample stream
- Pass to got_data()
"""
packet = PortAgentPacket()
header = "\xa3\x9d\x7a\x02\x00\x1c\x0b\x2e\x00\x00\x00\x01\x80\x00\x00\x00"
packet.unpack_header(header)
packet.attach_data(FULL_SAMPLE + SAMPLE_FRAGMENT_1)
test_driver._protocol.got_data(packet)
self.assertTrue(self.raw_stream_received)
self.assertTrue(self.parsed_stream_received)
"""
- Reset test verification variables
- Construct the final fragment of a sample stream
- Pass to got_data()
- Verify that raw and parsed streams have been received
"""
self.reset_test_vars()
packet = PortAgentPacket()
header = "\xa3\x9d\x7a\x02\x00\x1c\x0b\x2e\x00\x00\x00\x01\x80\x00\x00\x00"
packet.unpack_header(header)
packet.attach_data(SAMPLE_FRAGMENT_2)
test_driver._protocol.got_data(packet)
self.assertTrue(self.raw_stream_received)
self.assertTrue(self.parsed_stream_received)
def test_sample(self):
"""
Create a mock port agent
"""
mock_port_agent = Mock(spec=PortAgentClient)
"""
Instantiate the driver class directly (no driver client, no driver
client, no zmq driver process, no driver process; just own the driver)
"""
test_driver = InstrumentDriver(self.my_event_callback)
current_state = test_driver.get_resource_state()
print "DHE: DriverConnectionState: " + str(current_state)
self.assertEqual(current_state, DriverConnectionState.UNCONFIGURED)
"""
Now configure the driver with the mock_port_agent, verifying
that the driver transitions to that state
"""
config = {'mock_port_agent' : mock_port_agent}
# commented below out; trying real port agent
test_driver.configure(config = config)
"""
DHE: trying this; want to invoke the driver methods themselves, but
with the driver talking to the port_agent (through the client).
Will it work? Answer: It does, but I can't step through it. Let
me try just running this.
"""
#test_driver.configure(config = self.port_agent_comm_config())
current_state = test_driver.get_resource_state()
print "DHE: DriverConnectionState: " + str(current_state)
self.assertEqual(current_state, DriverConnectionState.DISCONNECTED)
"""
Invoke the connect method of the driver: should connect to mock
port agent. Verify that the connection FSM transitions to CONNECTED,
(which means that the FSM should now be reporting the ProtocolState).
"""
"""
TODO: DHE: Shouldn't have to put a sleep here; it's like the
port_agent isn't up yet; I get a connection refused without this.
"""
gevent.sleep(2)
test_driver.connect()
current_state = test_driver.get_resource_state()
print "DHE: DriverConnectionState: " + str(current_state)
self.assertEqual(current_state, DriverProtocolState.UNKNOWN)
"""
Invoke the discover_state method of the driver
"""
# commenting out because it will try wakeup
#test_driver.discover_state()
#current_state = test_driver.get_resource_state()
#print "DHE: DriverConnectionState: " + str(current_state)
"""
Force state to command state.
"""
"""
This won't work right now because the SBE16 does an _update_params upon
entry to the command_handler; since this is a unit test there is nothing
to respond to the ds and dc commands. Setting up mock to do it would
be really handy.
"""
test_driver.execute_force_state(state = DriverProtocolState.AUTOSAMPLE)
current_state = test_driver.get_resource_state()
print "DHE: DriverConnectionState: " + str(current_state)
self.assertEqual(current_state, DriverProtocolState.AUTOSAMPLE)
self.reset_test_vars()
test_sample = "# 24.0088, 0.00001, -0.000, 0.0117, 03 Oct 2012 20:59:04\r\n"
"""
use for test particle
test_sample = "# 24.0088, 0.00001, -0.000, 0.0117, 03 Oct 2012 20:59:04\r\n"
test_sample = "# 24. 24.0088, 0.00001, 0.000, 0.0117, 03 Oct 2012 20:58:54\r\n"
"""
paPacket = PortAgentPacket()
paHeader = "\xa3\x9d\x7a\x02\x00\x50\x0b\x2e\x00\x00\x00\x01\x80\x00\x00\x00"
paPacket.unpack_header(paHeader)
paPacket.attach_data(test_sample)
test_driver._protocol.got_data(paPacket)
"""
