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))