def testParse(self):
"""Tests the Parse function."""
# TODO: only tested against MacOS Cups IPP (Version 2.0)
parser = cups_ipp.CupsIppParser()
storage_writer = self._ParseFile(['mac_cups_ipp'], parser)
self.assertEqual(storage_writer.number_of_events, 3)
events = list(storage_writer.GetSortedEvents())
event = events[0]
expected_timestamp = timelib.Timestamp.CopyFromString(
'2013-11-03 18:07:21')
self.assertEqual(event.timestamp, expected_timestamp)
self.assertEqual(event.timestamp_desc,
definitions.TIME_DESCRIPTION_CREATION)
self.assertEqual(event.application, 'LibreOffice')
self.assertEqual(event.job_name, 'Assignament 1')
self.assertEqual(event.computer_name, 'localhost')
self.assertEqual(event.copies, 1)
self.assertEqual(event.doc_type, 'application/pdf')
expected_job = 'urn:uuid:d51116d9-143c-3863-62aa-6ef0202de49a'
self.assertEqual(event.job_id, expected_job)
self.assertEqual(event.owner, 'Joaquin Moreno Garijo')
self.assertEqual(event.user, 'moxilo')
self.assertEqual(event.printer_id, 'RHULBW')
expected_uri = 'ipp://localhost:631/printers/RHULBW'
self.assertEqual(event.uri, expected_uri)
expected_message = ('User: moxilo '
'Owner: Joaquin Moreno Garijo '
'Job Name: Assignament 1 '
'Application: LibreOffice '
'Printer: RHULBW')
expected_short_message = 'Job Name: Assignament 1'
self._TestGetMessageStrings(event, expected_message,
expected_short_message)
event = events[1]
expected_timestamp = timelib.Timestamp.CopyFromString(
'2013-11-03 18:07:21')
self.assertEqual(event.timestamp, expected_timestamp)
self.assertEqual(event.timestamp_desc,
definitions.TIME_DESCRIPTION_START)
event = events[2]
expected_timestamp = timelib.Timestamp.CopyFromString(
'2013-11-03 18:07:32')
self.assertEqual(event.timestamp, expected_timestamp)
self.assertEqual(event.timestamp_desc,
definitions.TIME_DESCRIPTION_END)
def testGetStringValue(self):
"""Tests the _GetStringValue function."""
parser = cups_ipp.CupsIppParser()
string_value = parser._GetStringValue({}, 'test')
self.assertIsNone(string_value)
string_value = parser._GetStringValue({'test': ['1', '2,3', '4']}, 'test')
self.assertEqual(string_value, '1, "2,3", 4')
def testParseIntegerValue(self):
"""Tests the _ParseIntegerValue function."""
parser = cups_ipp.CupsIppParser()
integer_value = parser._ParseIntegerValue(b'\x00\x00\x00\x01', 0)
self.assertEqual(integer_value, 1)
# Test with data too small.
with self.assertRaises(errors.ParseError):
parser._ParseIntegerValue(b'\x01\x00\x00', 0)
def testParseFileObject(self):
"""Tests the ParseFileObject function."""
parser = cups_ipp.CupsIppParser()
header_data = self._CreateHeaderData(parser)
session = sessions.Session()
storage_writer = self._CreateStorageWriter()
parser_mediator = self._CreateParserMediator(session, storage_writer)
file_object = self._CreateFileObject(
'cups_ipp', b''.join([header_data, self._ATTRIBUTES_GROUP_DATA]))
parser.ParseFileObject(parser_mediator, file_object)
self.assertEqual(storage_writer.number_of_events, 0)
self.assertEqual(storage_writer.number_of_extraction_warnings, 0)
self.assertEqual(storage_writer.number_of_recovery_warnings, 0)
# Test with attribute group data too small.
session = sessions.Session()
storage_writer = self._CreateStorageWriter()
parser_mediator = self._CreateParserMediator(session, storage_writer)
file_object = self._CreateFileObject(
'cups_ipp',
b''.join([header_data, self._ATTRIBUTES_GROUP_DATA[:-1]]))
parser.ParseFileObject(parser_mediator, file_object)
self.assertEqual(storage_writer.number_of_events, 0)
self.assertEqual(storage_writer.number_of_extraction_warnings, 1)
self.assertEqual(storage_writer.number_of_recovery_warnings, 0)
# Test attribute with date time value.
datetime_data = self._CreateDateTimeValueData(parser)
attribute_data = self._CreateAttributeTestData(
parser, 0x31, 'date-time-at-creation', datetime_data)
session = sessions.Session()
storage_writer = self._CreateStorageWriter()
parser_mediator = self._CreateParserMediator(session, storage_writer)
file_object = self._CreateFileObject(
'cups_ipp',
b''.join([header_data, b'\x01', attribute_data, b'\x03']))
parser.ParseFileObject(parser_mediator, file_object)
self.assertEqual(storage_writer.number_of_events, 1)
self.assertEqual(storage_writer.number_of_extraction_warnings, 0)
self.assertEqual(storage_writer.number_of_recovery_warnings, 0)
def testParseDateTimeValue(self):
"""Tests the _ParseDateTimeValue function."""
parser = cups_ipp.CupsIppParser()
datetime_data = self._CreateDateTimeValueData(parser)
datetime_value = parser._ParseDateTimeValue(datetime_data, 0)
self.assertIsNotNone(datetime_value)
self.assertEqual(datetime_value.year, 2018)
# Test with data too small.
with self.assertRaises(errors.ParseError):
parser._ParseDateTimeValue(datetime_data[:-1], 0)
def testParseBooleanValue(self):
"""Tests the _ParseBooleanValue function."""
parser = cups_ipp.CupsIppParser()
boolean_value = parser._ParseBooleanValue(b'\x00')
self.assertFalse(boolean_value)
boolean_value = parser._ParseBooleanValue(b'\x01')
self.assertTrue(boolean_value)
# Test with unsupported data.
with self.assertRaises(errors.ParseError):
parser._ParseBooleanValue(b'\x02')
def testParseHeader(self):
"""Tests the _ParseHeader function."""
file_system_builder = fake_file_system_builder.FakeFileSystemBuilder()
file_system_builder.AddFile('/cups_ipp', b'')
test_path_spec = fake_path_spec.FakePathSpec(location='/cups_ipp')
test_file_entry = file_system_builder.file_system.GetFileEntryByPathSpec(
test_path_spec)
storage_writer = self._CreateStorageWriter()
parser_mediator = self._CreateParserMediator(
storage_writer, file_entry=test_file_entry)
parser = cups_ipp.CupsIppParser()
header_map = parser._GetDataTypeMap('cups_ipp_header')
header = header_map.CreateStructureValues(major_version=1,
minor_version=1,
operation_identifier=5,
request_identifier=0)
header_data = header_map.FoldByteStream(header)
file_object = io.BytesIO(header_data)
parser._ParseHeader(parser_mediator, file_object)
# Test with header data too small.
file_object = io.BytesIO(header_data[:-1])
with self.assertRaises(errors.UnableToParseFile):
parser._ParseHeader(parser_mediator, file_object)
# Test with unsupported format version.
header = header_map.CreateStructureValues(major_version=99,
minor_version=1,
operation_identifier=5,
request_identifier=0)
header_data = header_map.FoldByteStream(header)
file_object = io.BytesIO(header_data)
with self.assertRaises(errors.UnableToParseFile):
parser._ParseHeader(parser_mediator, file_object)
# Test with unsupported operation identifier.
header = header_map.CreateStructureValues(major_version=1,
minor_version=1,
operation_identifier=99,
request_identifier=0)
header_data = header_map.FoldByteStream(header)
file_object = io.BytesIO(header_data)
parser._ParseHeader(parser_mediator, file_object)
def testParseFileObject(self):
"""Tests the ParseFileObject function."""
parser = cups_ipp.CupsIppParser()
header_map = parser._GetDataTypeMap('cups_ipp_header')
header = header_map.CreateStructureValues(major_version=1,
minor_version=1,
operation_identifier=5,
request_identifier=0)
header_data = header_map.FoldByteStream(header)
storage_writer = self._CreateStorageWriter()
parser_mediator = self._CreateParserMediator(storage_writer)
file_object = io.BytesIO(b''.join(
[header_data, self._ATTRIBUTES_GROUP_DATA]))
parser.ParseFileObject(parser_mediator, file_object)
self.assertEqual(storage_writer.number_of_warnings, 0)
self.assertEqual(storage_writer.number_of_events, 0)
# Test with attribute group data too small.
storage_writer = self._CreateStorageWriter()
parser_mediator = self._CreateParserMediator(storage_writer)
file_object = io.BytesIO(b''.join(
[header_data, self._ATTRIBUTES_GROUP_DATA[:-1]]))
parser.ParseFileObject(parser_mediator, file_object)
self.assertEqual(storage_writer.number_of_warnings, 1)
self.assertEqual(storage_writer.number_of_events, 0)
# Test attribute with date time value.
datetime_data = self._CreateDateTimeValueData(parser)
attribute_data = self._CreateAttributeTestData(
parser, 0x31, 'date-time-at-creation', datetime_data)
storage_writer = self._CreateStorageWriter()
parser_mediator = self._CreateParserMediator(storage_writer)
file_object = io.BytesIO(b''.join(
[header_data, b'\x01', attribute_data, b'\x03']))
parser.ParseFileObject(parser_mediator, file_object)
self.assertEqual(storage_writer.number_of_warnings, 0)
self.assertEqual(storage_writer.number_of_events, 1)
def testParse(self):
"""Tests the Parse function."""
# TODO: only tested against MacOS Cups IPP (Version 2.0)
parser = cups_ipp.CupsIppParser()
storage_writer = self._ParseFile(['mac_cups_ipp'], parser)
self.assertEqual(storage_writer.number_of_warnings, 0)
self.assertEqual(storage_writer.number_of_events, 3)
events = list(storage_writer.GetSortedEvents())
expected_event_values = {
'application': 'LibreOffice',
'computer_name': 'localhost',
'copies': 1,
'doc_type': 'application/pdf',
'job_id': 'urn:uuid:d51116d9-143c-3863-62aa-6ef0202de49a',
'job_name': 'Assignament 1',
'owner': 'Joaquin Moreno Garijo',
'printer_id': 'RHULBW',
'timestamp': '2013-11-03 18:07:21.000000',
'timestamp_desc': definitions.TIME_DESCRIPTION_CREATION,
'uri': 'ipp://localhost:631/printers/RHULBW',
'user': '******'}
self.CheckEventValues(storage_writer, events[0], expected_event_values)
expected_message = (
'User: moxilo '
'Owner: Joaquin Moreno Garijo '
'Job Name: Assignament 1 '
'Application: LibreOffice '
'Printer: RHULBW')
expected_short_message = 'Job Name: Assignament 1'
event_data = self._GetEventDataOfEvent(storage_writer, events[0])
self._TestGetMessageStrings(
event_data, expected_message, expected_short_message)
expected_event_values = {
'timestamp': '2013-11-03 18:07:21.000000',
'timestamp_desc': definitions.TIME_DESCRIPTION_START}
self.CheckEventValues(storage_writer, events[1], expected_event_values)
expected_event_values = {
'timestamp': '2013-11-03 18:07:32.000000',
'timestamp_desc': definitions.TIME_DESCRIPTION_END}
self.CheckEventValues(storage_writer, events[2], expected_event_values)
def testParse(self):
"""Tests the Parse function."""
# TODO: only tested against MacOS Cups IPP (Version 2.0)
parser = cups_ipp.CupsIppParser()
storage_writer = self._ParseFile(['mac_cups_ipp'], parser)
number_of_events = storage_writer.GetNumberOfAttributeContainers('event')
self.assertEqual(number_of_events, 3)
number_of_warnings = storage_writer.GetNumberOfAttributeContainers(
'extraction_warning')
self.assertEqual(number_of_warnings, 0)
number_of_warnings = storage_writer.GetNumberOfAttributeContainers(
'recovery_warning')
self.assertEqual(number_of_warnings, 0)
events = list(storage_writer.GetSortedEvents())
expected_event_values = {
'application': 'LibreOffice',
'computer_name': 'localhost',
'copies': 1,
'data_type': 'cups:ipp:event',
'date_time': '2013-11-03 18:07:21',
'doc_type': 'application/pdf',
'job_id': 'urn:uuid:d51116d9-143c-3863-62aa-6ef0202de49a',
'job_name': 'Assignament 1',
'owner': 'Joaquin Moreno Garijo',
'printer_id': 'RHULBW',
'timestamp_desc': definitions.TIME_DESCRIPTION_CREATION,
'uri': 'ipp://localhost:631/printers/RHULBW',
'user': '******'}
self.CheckEventValues(storage_writer, events[0], expected_event_values)
expected_event_values = {
'data_type': 'cups:ipp:event',
'date_time': '2013-11-03 18:07:21',
'timestamp_desc': definitions.TIME_DESCRIPTION_START}
self.CheckEventValues(storage_writer, events[1], expected_event_values)
expected_event_values = {
'data_type': 'cups:ipp:event',
'date_time': '2013-11-03 18:07:32',
'timestamp_desc': definitions.TIME_DESCRIPTION_END}
self.CheckEventValues(storage_writer, events[2], expected_event_values)
def testParseAttributesGroup(self):
"""Tests the _ParseAttributesGroup function."""
parser = cups_ipp.CupsIppParser()
file_object = io.BytesIO(self._ATTRIBUTES_GROUP_DATA)
name_value_pairs = list(parser._ParseAttributesGroup(file_object))
self.assertEqual(name_value_pairs, [('attributes-charset', 'utf-8')])
# Test with unsupported attributes groups start tag value.
file_object = io.BytesIO(b''.join(
[b'\xff', self._ATTRIBUTES_GROUP_DATA[1:]]))
with self.assertRaises(errors.ParseError):
list(parser._ParseAttributesGroup(file_object))
def testParseAttribute(self):
"""Tests the _ParseAttribute function."""
parser = cups_ipp.CupsIppParser()
attribute_data = self._CreateAttributeTestData(parser, 0x00, 'test',
b'\x12')
file_object = io.BytesIO(attribute_data)
name, value = parser._ParseAttribute(file_object)
self.assertEqual(name, 'test')
self.assertEqual(value, b'\x12')
# Test with attribute data too small.
file_object = io.BytesIO(attribute_data[:-1])
with self.assertRaises(errors.ParseError):
parser._ParseAttribute(file_object)
# Test attribute with integer value.
attribute_data = self._CreateAttributeTestData(parser, 0x21, 'int',
b'\x12\x34\x56\x78')
file_object = io.BytesIO(attribute_data)
name, value = parser._ParseAttribute(file_object)
self.assertEqual(name, 'int')
self.assertEqual(value, 0x12345678)
# Test attribute with boolean value.
attribute_data = self._CreateAttributeTestData(parser, 0x22, 'bool',
b'\x01')
file_object = io.BytesIO(attribute_data)
name, value = parser._ParseAttribute(file_object)
self.assertEqual(name, 'bool')
self.assertEqual(value, True)
# Test attribute with date time value.
datetime_data = self._CreateDateTimeValueData(parser)
attribute_data = self._CreateAttributeTestData(parser, 0x31,
'datetime',
datetime_data)
file_object = io.BytesIO(attribute_data)
name, value = parser._ParseAttribute(file_object)
self.assertEqual(name, 'datetime')
self.assertIsNotNone(value)
self.assertEqual(value.year, 2018)
# Test attribute with string without language.
attribute_data = self._CreateAttributeTestData(parser, 0x42, 'string',
b'NOLANG')
file_object = io.BytesIO(attribute_data)
name, value = parser._ParseAttribute(file_object)
self.assertEqual(name, 'string')
self.assertEqual(value, 'NOLANG')
# Test attribute with ASCII string and tag value charset.
attribute_data = self._CreateAttributeTestData(parser, 0x47, 'charset',
b'utf8')
file_object = io.BytesIO(attribute_data)
name, value = parser._ParseAttribute(file_object)
self.assertEqual(name, 'charset')
self.assertEqual(value, 'utf8')
def setUp(self):
"""Sets up the needed objects used throughout the test."""
self._parser = cups_ipp.CupsIppParser()
def setUp(self):
"""Makes preparations before running an individual test."""
self._parser = cups_ipp.CupsIppParser()
def testParse(self):
"""Tests the Parse function."""
parser_object = cups_ipp.CupsIppParser()
# TODO: only tested against Mac OS X Cups IPP (Version 2.0)
test_file = self._GetTestFilePath([u'mac_cups_ipp'])
events = self._ParseFile(parser_object, test_file)
event_objects = self._GetEventObjectsFromQueue(events)
self.assertEqual(len(event_objects), 3)
event_object = event_objects[0]
expected_timestamp = timelib.Timestamp.CopyFromString(
u'2013-11-03 18:07:21')
self.assertEqual(event_object.timestamp, expected_timestamp)
self.assertEqual(
event_object.timestamp_desc,
eventdata.EventTimestamp.CREATION_TIME)
self.assertEqual(event_object.application, u'LibreOffice')
self.assertEqual(event_object.job_name, u'Assignament 1')
self.assertEqual(event_object.computer_name, u'localhost')
self.assertEqual(event_object.copies, 1)
self.assertEqual(event_object.doc_type, u'application/pdf')
expected_job = u'urn:uuid:d51116d9-143c-3863-62aa-6ef0202de49a'
self.assertEqual(event_object.job_id, expected_job)
self.assertEqual(event_object.owner, u'Joaquin Moreno Garijo')
self.assertEqual(event_object.user, u'moxilo')
self.assertEqual(event_object.printer_id, u'RHULBW')
expected_uri = u'ipp://localhost:631/printers/RHULBW'
self.assertEqual(event_object.uri, expected_uri)
expected_msg = (
u'User: moxilo '
u'Owner: Joaquin Moreno Garijo '
u'Job Name: Assignament 1 '
u'Application: LibreOffice '
u'Printer: RHULBW')
expected_msg_short = (
u'Job Name: Assignament 1')
self._TestGetMessageStrings(event_object, expected_msg, expected_msg_short)
event_object = event_objects[1]
expected_timestamp = timelib.Timestamp.CopyFromString(
u'2013-11-03 18:07:21')
self.assertEqual(event_object.timestamp, expected_timestamp)
self.assertEqual(
event_object.timestamp_desc,
eventdata.EventTimestamp.START_TIME)
event_object = event_objects[2]
expected_timestamp = timelib.Timestamp.CopyFromString(
u'2013-11-03 18:07:32')
self.assertEqual(event_object.timestamp, expected_timestamp)
self.assertEqual(
event_object.timestamp_desc,
eventdata.EventTimestamp.END_TIME)
def setUp(self):
"""Sets up the needed objects used throughout the test."""
pre_obj = event.PreprocessObject()
self._parser = cups_ipp.CupsIppParser(pre_obj, None)
