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)