def assertFileExist(self, obj, field_path): # pylint: disable=invalid-name
"""Compare output file of a processor to the given correct file.
:param obj: Data object which includes file that we want to
compare.
:type obj: :obj:`server.models.Data`
:param field_path: Path to file name in Data object.
:type field_path: :obj:`str`
"""
field = dict_dot(obj['output'], field_path)
output = os.path.join(settings.DATAFS['data_path'], str(obj.pk), field['file'])
if not os.path.isfile(output):
self.fail(msg="File {} does not exist.".format(field_path))
def assertFiles(self, obj, field_path, fn, compression=None): # pylint: disable=invalid-name
"""Compare output file of a processor to the given correct file.
:param obj: Data object which includes file that we want to
compare.
:type obj: :obj:`server.models.Data`
:param field_path: Path to file name in Data object.
:type field_path: :obj:`str`
:param fn: File name (and relative path) of file to which we
want to compare. Name/path is relative to
'server/tests/processor/outputs'.
:type fn: :obj:`str`
:param compression: If not None, files will be uncompressed with
the appropriate compression library before comparison.
Currently supported compression formats are "gzip" and
"zip".
:type compression: :obj:`str`
"""
if compression is None:
open_fn = open
elif compression == 'gzip':
open_fn = gzip.open
elif compression == 'zip':
open_fn = zipfile.ZipFile.open
else:
raise ValueError("Unsupported compression format.")
field = dict_dot(obj['output'], field_path)
output = os.path.join(settings.DATAFS['data_path'], str(obj.pk), field['file'])
output_file = open_fn(output)
output_hash = hashlib.sha256(output_file.read()).hexdigest()
wanted = os.path.join(self.current_path, 'outputs', fn)
if not os.path.isfile(wanted):
shutil.copyfile(output, wanted)
self.fail(msg="Output file {} missing so it was created.".format(fn))
wanted_file = open_fn(wanted)
wanted_hash = hashlib.sha256(wanted_file.read()).hexdigest()
self.assertEqual(wanted_hash, output_hash,
msg="File hash mismatch: {} != {}".format(wanted_hash, output_hash) + self._msg_stdout(obj))
def assertFields(self, obj, path, value): # pylint: disable=invalid-name
"""Compare Data object's field to given value.
:param obj: Data object with field to compare
:type obj: :obj:`server.models.Data`
:param path: Path to field in Data object.
:type path: :obj:`str`
:param value: Desired value.
:type value: :obj:`str`
"""
field = dict_dot(obj['output'], path)
self.assertEqual(field, value,
msg="Field 'output.{}' mismatch: {} != {}".format(path, field, str(value)) +
self._msg_stdout(obj))
def assertJSON(self, obj, storage, field_path, file_name): # pylint: disable=invalid-name
"""Compare JSON in Storage object to the given correct output.
:param obj: Data object which includes file that we want to
compare.
:type obj: :obj:`server.models.Data`
:param storage: Storage (or storage id) which contains JSON to
compare.
:type storage: :obj:`server.models.Storage` or :obj:`str`
:param field_path: Path to JSON subset to compare in Storage
object. If it is empty, entire Storage object will be
compared.
:type field_path: :obj:`str`
:param file_name: File name (and relative path) of file to which we
want to compare. Name/path is relative to
'server/tests/processor/outputs'.
:type file_name: :obj:`str`
"""
self.assertEqual(os.path.splitext(file_name)[1], '.gz', msg='File extension must be .gz')
if not isinstance(storage, Storage):
storage = Storage.objects.get(pk=str(storage))
storage_obj = dict_dot(storage['json'], field_path)
file_path = os.path.join(self.current_path, 'outputs', file_name)
if not os.path.isfile(file_path):
with gzip.open(file_path, 'w') as f:
json.dump(storage_obj, f)
self.fail(msg="Output file {} missing so it was created.".format(file_name))
with gzip.open(file_path) as f:
file_obj = json.load(f)
self.assertEqual(storage_obj, file_obj,
msg="Storage {} field '{}' does not match file {}".format(
storage.id, field_path, file_name) + self._msg_stdout(obj))