def test_extract_keys(self):
'''extract_keys() with various binary elements.'''
# create a test report with binary elements
large_val = b'A' * 5000000
pr = problem_report.ProblemReport()
pr['Txt'] = 'some text'
pr['MoreTxt'] = 'some more text'
pr['Foo'] = problem_report.CompressedValue(b'FooFoo!')
pr['Uncompressed'] = bin_data
pr['Bin'] = problem_report.CompressedValue()
pr['Bin'].set_value(bin_data)
pr['Large'] = problem_report.CompressedValue(large_val)
pr['Multiline'] = problem_report.CompressedValue(
b'\1\1\1\n\2\2\n\3\3\3')
report = BytesIO()
pr.write(report)
report.seek(0)
self.assertRaises(IOError, pr.extract_keys, report, 'Bin',
os.path.join(self.workdir, 'nonexistant'))
# Test exception handling: Non-binary and nonexistent key
tests = [(ValueError, 'Txt'), (ValueError, ['Foo', 'Txt']),
(KeyError, 'Bar'), (KeyError, ['Foo', 'Bar'])]
for exc, keys_arg in tests:
report.seek(0)
self.assertRaises(exc, pr.extract_keys, report, keys_arg,
self.workdir)
# Check valid single elements
tests = {
'Foo': b'FooFoo!',
'Uncompressed': bin_data,
'Bin': bin_data,
'Large': large_val,
'Multiline': b'\1\1\1\n\2\2\n\3\3\3'
}
for key, expected in tests.items():
report.seek(0)
pr.extract_keys(report, key, self.workdir)
with open(os.path.join(self.workdir, key), 'rb') as f:
self.assertEqual(f.read(), expected)
# remove file for next pass
os.remove(os.path.join(self.workdir, key))
# Check element list
report.seek(0)
tests = {'Foo': b'FooFoo!', 'Uncompressed': bin_data}
pr.extract_keys(report, tests.keys(), self.workdir)
for key, expected in tests.items():
with open(os.path.join(self.workdir, key), 'rb') as f:
self.assertEqual(f.read(), expected)
def test_compressed_values(self):
'''handling of CompressedValue values.'''
large_val = b'A' * 5000000
pr = problem_report.ProblemReport()
pr['Foo'] = problem_report.CompressedValue(b'FooFoo!')
pr['Bin'] = problem_report.CompressedValue()
pr['Bin'].set_value(bin_data)
pr['Large'] = problem_report.CompressedValue(large_val)
self.assertTrue(isinstance(pr['Foo'], problem_report.CompressedValue))
self.assertTrue(isinstance(pr['Bin'], problem_report.CompressedValue))
self.assertEqual(pr['Foo'].get_value(), b'FooFoo!')
self.assertEqual(pr['Bin'].get_value(), bin_data)
self.assertEqual(pr['Large'].get_value(), large_val)
self.assertEqual(len(pr['Foo']), 7)
self.assertEqual(len(pr['Bin']), len(bin_data))
self.assertEqual(len(pr['Large']), len(large_val))
io = BytesIO()
pr['Bin'].write(io)
self.assertEqual(io.getvalue(), bin_data)
io = BytesIO()
pr['Large'].write(io)
self.assertEqual(io.getvalue(), large_val)
pr['Multiline'] = problem_report.CompressedValue(
b'\1\1\1\n\2\2\n\3\3\3')
self.assertEqual(pr['Multiline'].splitlines(),
[b'\1\1\1', b'\2\2', b'\3\3\3'])
# test writing of reports with CompressedValues
io = BytesIO()
pr.write(io)
io.seek(0)
pr = problem_report.ProblemReport()
pr.load(io)
self.assertEqual(pr['Foo'], 'FooFoo!')
self.assertEqual(pr['Bin'], bin_data)
self.assertEqual(pr['Large'], large_val.decode('ASCII'))
def setUpClass(klass):
klass.workdir = tempfile.mkdtemp()
# create problem report file with all possible data types
r = problem_report.ProblemReport()
klass.utf8_str = b'a\xe2\x99\xa5b'
klass.bindata = b'\x00\x01\xFF\x40'
r['utf8'] = klass.utf8_str
r['unicode'] = klass.utf8_str.decode('UTF-8')
r['binary'] = klass.bindata
r['compressed'] = problem_report.CompressedValue(b'FooFoo!')
klass.report_file = os.path.join(klass.workdir, 'test.apport')
with open(klass.report_file, 'wb') as f:
r.write(f)
klass.unpack_dir = os.path.join(klass.workdir, 'un pack')
def test_write_mime_binary(self):
'''write_mime() for binary values and file references.'''
temp = tempfile.NamedTemporaryFile()
temp.write(bin_data)
temp.flush()
tempgz = tempfile.NamedTemporaryFile()
gz = gzip.GzipFile('File1', 'w', fileobj=tempgz)
gz.write(bin_data)
gz.close()
tempgz.flush()
pr = problem_report.ProblemReport(date='now!')
pr['Context'] = 'Test suite'
pr['File1'] = (temp.name, )
pr['File1.gz'] = (tempgz.name, )
pr['Value1'] = bin_data
with open(tempgz.name, 'rb') as f:
pr['Value1.gz'] = f.read()
pr['ZValue'] = problem_report.CompressedValue(bin_data)
io = BytesIO()
pr.write_mime(io)
io.seek(0)
msg = email.message_from_binary_file(io)
parts = [p for p in msg.walk()]
self.assertEqual(len(parts), 7)
# first part is the multipart container
self.assertTrue(parts[0].is_multipart())
# second part should be an inline text/plain attachments with all short
# fields
self.assertTrue(not parts[1].is_multipart())
self.assertEqual(parts[1].get_content_type(), 'text/plain')
self.assertEqual(parts[1].get_content_charset(), 'utf-8')
self.assertEqual(parts[1].get_filename(), None)
self.assertEqual(
parts[1].get_payload(decode=True),
b'ProblemType: Crash\nContext: Test suite\nDate: now!\n')
# third part should be the File1: file contents as gzip'ed attachment
self.assertTrue(not parts[2].is_multipart())
self.assertEqual(parts[2].get_content_type(), 'application/x-gzip')
self.assertEqual(parts[2].get_filename(), 'File1.gz')
f = tempfile.TemporaryFile()
f.write(parts[2].get_payload(decode=True))
f.seek(0)
self.assertEqual(gzip.GzipFile(mode='rb', fileobj=f).read(), bin_data)
f.close()
# fourth part should be the File1.gz: file contents as gzip'ed
# attachment; write_mime() should not compress it again
self.assertTrue(not parts[3].is_multipart())
self.assertEqual(parts[3].get_content_type(), 'application/x-gzip')
self.assertEqual(parts[3].get_filename(), 'File1.gz')
f = tempfile.TemporaryFile()
f.write(parts[3].get_payload(decode=True))
f.seek(0)
self.assertEqual(gzip.GzipFile(mode='rb', fileobj=f).read(), bin_data)
f.close()
# fifth part should be the Value1: value as gzip'ed attachment
self.assertTrue(not parts[4].is_multipart())
self.assertEqual(parts[4].get_content_type(), 'application/x-gzip')
self.assertEqual(parts[4].get_filename(), 'Value1.gz')
f = tempfile.TemporaryFile()
f.write(parts[4].get_payload(decode=True))
f.seek(0)
self.assertEqual(gzip.GzipFile(mode='rb', fileobj=f).read(), bin_data)
f.close()
# sixth part should be the Value1: value as gzip'ed attachment;
# write_mime should not compress it again
self.assertTrue(not parts[5].is_multipart())
self.assertEqual(parts[5].get_content_type(), 'application/x-gzip')
self.assertEqual(parts[5].get_filename(), 'Value1.gz')
f = tempfile.TemporaryFile()
f.write(parts[5].get_payload(decode=True))
f.seek(0)
self.assertEqual(gzip.GzipFile(mode='rb', fileobj=f).read(), bin_data)
f.close()
# seventh part should be the ZValue: value as gzip'ed attachment;
# write_mime should not compress it again
self.assertTrue(not parts[6].is_multipart())
self.assertEqual(parts[6].get_content_type(), 'application/x-gzip')
self.assertEqual(parts[6].get_filename(), 'ZValue.gz')
f = tempfile.TemporaryFile()
f.write(parts[6].get_payload(decode=True))
f.seek(0)
self.assertEqual(gzip.GzipFile(mode='rb', fileobj=f).read(), bin_data)
f.close()