def test_cdl_file(self):
# Testing whether you can run compliance checker on a .cdl file
cs = CheckSuite()
cs.load_all_available_checkers()
# Load the cdl file
ds = cs.load_dataset(static_files['test_cdl'])
vals = cs.run(ds, 'cf')
limit = 2
for checker, rpair in vals.items():
groups, errors = rpair
score_list, cdl_points, cdl_out_of = cs.standard_output(limit, checker, groups)
# This asserts that print is able to generate all of the unicode output
cs.non_verbose_output_generation(score_list, groups, limit, cdl_points, cdl_out_of)
# Ok now load the nc file that it came from
ds = cs.load_dataset(static_files['test_cdl_nc'])
vals = cs.run(ds, 'cf')
limit = 2
for checker, rpair in vals.items():
groups, errors = rpair
score_list, nc_points, nc_out_of = cs.standard_output(limit, checker, groups)
# This asserts that print is able to generate all of the unicode output
cs.non_verbose_output_generation(score_list, groups, limit, nc_points, nc_out_of)
nc_file_path = static_files['test_cdl'].replace('.cdl', '.nc')
self.addCleanup(os.remove, nc_file_path)
# Ok the scores should be equal!
self.assertEqual(nc_points, cdl_points)
self.assertEqual(nc_out_of, cdl_out_of)
def test_suite(self):
# BWA: what's the purpose of this test? Just to see if the suite
# runs without errors?
cs = CheckSuite()
cs.load_all_available_checkers()
ds = cs.load_dataset(static_files['2dim'])
cs.run(ds, 'acdd')
def run_checker(self, checker, dataset_location):
cs = CheckSuite()
cs.load_all_available_checkers()
ds = cs.load_dataset(dataset_location)
score_groups = cs.run(ds, [], checker)
results, self.errors = score_groups[checker]
self.results = cs.build_structure(checker, results, dataset_location)
def run_checker(self, checker, dataset_location):
cs = CheckSuite()
cs.load_all_available_checkers()
ds = cs.load_dataset(dataset_location)
score_groups = cs.run(ds, [], checker)
results, self.errors = score_groups[checker]
self.results = cs.build_structure(checker, results, dataset_location)
def test_suite(self):
# BWA: what's the purpose of this test? Just to see if the suite
# runs without errors?
cs = CheckSuite()
cs.load_all_available_checkers()
ds = cs.load_dataset(static_files['2dim'])
vals = cs.run(ds, 'acdd')
def test_erddap(self):
"""
Tests that a connection can be made to ERDDAP's GridDAP
"""
url = "http://coastwatch.pfeg.noaa.gov/erddap/griddap/osuChlaAnom"
cs = CheckSuite()
ds = cs.load_dataset(url)
assert ds is not None
def test_hyrax(self):
"""
Tests that a connection can be made to Hyrax
"""
url = "http://ingria.coas.oregonstate.edu/opendap/hyrax/aggregated/ocean_time_aggregation.ncml"
cs = CheckSuite()
ds = cs.load_dataset(url)
assert ds is not None
def test_thredds(self):
'''
Tests that a connection can be made to a remote THREDDS endpoint
'''
url = 'http://data.ioos.us/thredds/dodsC/deployments/rutgers/ru24-20150105T1441/ru24-20150105T1441.nc3.nc'
cs = CheckSuite()
ds = cs.load_dataset(url)
assert ds is not None
def test_sos(self):
"""
Tests that a connection can be made to an SOS endpoint
"""
url = "https://data.oceansmap.com/thredds/sos/caricoos_ag/VIA/VIA.ncml"
cs = CheckSuite()
ds = cs.load_dataset(url)
assert ds is not None
def test_skip_checks(self):
"""Tests that checks are properly skipped when specified"""
cs = CheckSuite()
cs.load_all_available_checkers()
ds = cs.load_dataset(static_files['2dim'])
# exclude title from the check attributes
score_groups = cs.run(ds, ['check_high'], 'acdd')
assert all(sg.name not in {'Conventions', 'title', 'keywords',
'summary'} for sg in score_groups['acdd'][0])
def test_netcdf_content_type(self):
"""
Check that urls with Content-Type header of "application/x-netcdf" can
successfully be read into memory for checks.
"""
url = "https://gliders.ioos.us/erddap/tabledap/amelia-20180501T0000.ncCF?&time%3E=max(time)-1%20hour"
cs = CheckSuite()
ds = cs.load_dataset(url)
assert ds is not None
def run_checker(cls, ds_loc, checker_names, verbose, criteria,
skip_checks=None, output_filename='-',
output_format='text'):
"""
Static check runner.
@param ds_loc Dataset location (url or file)
@param checker_names List of string names to run, should match keys of checkers dict (empty list means run all)
@param verbose Verbosity of the output (0, 1, 2)
@param criteria Determines failure (lenient, normal, strict)
@param output_filename Path to the file for output
@param skip_checks Names of checks to skip
@param output_format Format of the output
@returns If the tests failed (based on the criteria)
"""
cs = CheckSuite()
ds = cs.load_dataset(ds_loc)
score_groups = cs.run(ds, [] if skip_checks is None else skip_checks,
*checker_names)
if not score_groups:
raise ValueError("No checks found, please check the name of the checker(s) and that they are installed")
if criteria == 'normal':
limit = 2
elif criteria == 'strict':
limit = 1
elif criteria == 'lenient':
limit = 3
if output_format == 'text':
if output_filename == '-':
groups = cls.stdout_output(cs, score_groups, verbose, limit)
# need to redirect output from stdout since print functions are
# presently used to generate the standard report output
else:
with io.open(output_filename, 'w', encoding='utf-8') as f:
with stdout_redirector(f):
groups = cls.stdout_output(cs, score_groups, verbose,
limit)
elif output_format == 'html':
groups = cls.html_output(cs, score_groups, output_filename, ds_loc,
limit)
elif output_format == 'json':
groups = cls.json_output(cs, score_groups, output_filename, ds_loc,
limit)
else:
raise TypeError('Invalid format %s' % output_format)
errors_occurred = cls.check_errors(score_groups, verbose)
return cs.passtree(groups, limit), errors_occurred
def test_thredds(self):
'''
Tests that a connection can be made to a remote THREDDS endpoint
'''
url = "http://thredds.ucar.edu/thredds/dodsC/grib/NCEP/GFS/Global_0p25deg_ana/TP"
cs = CheckSuite()
ds = cs.load_dataset(url)
assert ds is not None
def test_skip_checks(self):
"""Tests that checks are properly skipped when specified"""
cs = CheckSuite()
cs.load_all_available_checkers()
ds = cs.load_dataset(static_files['2dim'])
# exclude title from the check attributes
score_groups = cs.run(ds, ['check_high'], 'acdd')
assert all(sg.name not in {'Conventions', 'title', 'keywords',
'summary'} for sg in score_groups['acdd'][0])
def test_unicode_formatting(self):
cs = CheckSuite()
cs.load_all_available_checkers()
ds = cs.load_dataset(static_files['bad_region'])
score_groups = cs.run(ds, 'cf')
limit = 2
for checker, rpair in score_groups.iteritems():
groups, errors = rpair
score_list, points, out_of = cs.standard_output(limit, checker, groups)
# This asserts that print is able to generate all of the unicode output
cs.non_verbose_output_generation(score_list, groups, limit, points, out_of)
def run_checker(cls, ds_loc, checker_names, verbose, criteria,
skip_checks=None, output_filename='-',
output_format='text'):
"""
Static check runner.
@param ds_loc Dataset location (url or file)
@param checker_names List of string names to run, should match keys of checkers dict (empty list means run all)
@param verbose Verbosity of the output (0, 1, 2)
@param criteria Determines failure (lenient, normal, strict)
@param output_filename Path to the file for output
@param skip_checks Names of checks to skip
@param output_format Format of the output
@returns If the tests failed (based on the criteria)
"""
cs = CheckSuite()
ds = cs.load_dataset(ds_loc)
score_groups = cs.run(ds, [] if skip_checks is None else skip_checks,
*checker_names)
if criteria == 'normal':
limit = 2
elif criteria == 'strict':
limit = 1
elif criteria == 'lenient':
limit = 3
if output_format == 'text':
if output_filename == '-':
groups = cls.stdout_output(cs, score_groups, verbose, limit)
# need to redirect output from stdout since print functions are
# presently used to generate the standard report output
else:
with io.open(output_filename, 'w', encoding='utf-8') as f:
with stdout_redirector(f):
groups = cls.stdout_output(cs, score_groups, verbose,
limit)
elif output_format == 'html':
groups = cls.html_output(cs, score_groups, output_filename, ds_loc, limit)
elif output_format == 'json':
groups = cls.json_output(cs, score_groups, output_filename, ds_loc, limit)
else:
raise TypeError('Invalid format %s' % output_format)
errors_occurred = cls.check_errors(score_groups, verbose)
return cs.passtree(groups, limit), errors_occurred
def test_cdl_file(self):
# Testing whether you can run compliance checker on a .cdl file
cs = CheckSuite()
cs.load_all_available_checkers()
# Load the cdl file
ds = cs.load_dataset(static_files['test_cdl'])
vals = cs.run(ds, 'cf')
limit = 2
for checker, rpair in vals.items():
groups, errors = rpair
score_list, cdl_points, cdl_out_of = cs.standard_output(
limit, checker, groups)
# This asserts that print is able to generate all of the unicode output
cs.non_verbose_output_generation(score_list, groups, limit,
cdl_points, cdl_out_of)
ds.close()
# Ok now load the nc file that it came from
ds = cs.load_dataset(static_files['test_cdl_nc'])
vals = cs.run(ds, 'cf')
limit = 2
for checker, rpair in vals.items():
groups, errors = rpair
score_list, nc_points, nc_out_of = cs.standard_output(
limit, checker, groups)
# This asserts that print is able to generate all of the unicode output
cs.non_verbose_output_generation(score_list, groups, limit,
nc_points, nc_out_of)
ds.close()
nc_file_path = static_files['test_cdl'].replace('.cdl', '.nc')
self.addCleanup(os.remove, nc_file_path)
# Ok the scores should be equal!
self.assertEqual(nc_points, cdl_points)
self.assertEqual(nc_out_of, cdl_out_of)
def test_standardise_cf(standardised):
suite = CheckSuite()
suite.load_all_available_checkers()
ds = suite.load_dataset(standardised)
results = suite.run(ds, [], 'cf')
check_failures = 0
for r in results['cf'][0]:
if r.value[1] - r.value[0] > 0:
print(r, file=sys.stderr)
check_failures += 1
assert check_failures == 0
def test_group_func(self):
# This is checking for issue #183, where group_func results in
# IndexError: list index out of range
cs = CheckSuite()
cs.load_all_available_checkers()
ds = cs.load_dataset(static_files['bad_data_type'])
score_groups = cs.run(ds, 'cf')
limit = 2
for checker, rpair in score_groups.iteritems():
groups, errors = rpair
score_list, points, out_of = cs.standard_output(limit, checker, groups)
# This asserts that print is able to generate all of the unicode output
cs.non_verbose_output_generation(score_list, groups, limit, points, out_of)
def run_checker(cls,
ds_loc,
checker_names,
verbose,
criteria,
output_filename='stdout',
output_format='stdout'):
"""
Static check runner.
@param ds_loc Dataset location (url or file)
@param checker_names List of string names to run, should match keys of checkers dict (empty list means run all)
@param verbose Verbosity of the output (0, 1, 2)
@param criteria Determines failure (lenient, normal, strict)
@param output_filename Path to the file for output
@param output_format Format of the output
@returns If the tests failed (based on the criteria)
"""
retval = True
cs = CheckSuite()
ds = cs.load_dataset(ds_loc)
score_groups = cs.run(ds, *checker_names)
if criteria == 'normal':
limit = 2
elif criteria == 'strict':
limit = 1
elif criteria == 'lenient':
limit = 3
if output_filename == '-' and output_format == 'text':
groups = cls.stdout_output(cs, score_groups, verbose, limit)
elif output_format == 'html':
groups = cls.html_output(cs, score_groups, output_filename, ds_loc,
limit)
elif output_format == 'json':
groups = cls.json_output(cs, score_groups, output_filename, ds_loc,
limit)
else:
raise TypeError('Invalid format %s' % output_format)
errors_occurred = cls.check_errors(score_groups, verbose)
return cs.passtree(groups, limit), errors_occurred
def run_checker(cls, ds_loc, checker_names, verbose, criteria, output_filename='stdout', output_format='stdout'):
"""
Static check runner.
@param ds_loc Dataset location (url or file)
@param checker_names List of string names to run, should match keys of checkers dict (empty list means run all)
@param verbose Verbosity of the output (0, 1, 2)
@param criteria Determines failure (lenient, normal, strict)
@param output_filename Path to the file for output
@param output_format Format of the output
@returns If the tests failed (based on the criteria)
"""
retval = True
cs = CheckSuite()
ds = cs.load_dataset(ds_loc)
score_groups = cs.run(ds, *checker_names)
if criteria == 'normal':
limit = 2
elif criteria == 'strict':
limit = 1
elif criteria == 'lenient':
limit = 3
if output_filename == '-' and output_format == 'text':
groups = cls.stdout_output(cs, score_groups, verbose, limit)
elif output_format == 'html':
groups = cls.html_output(cs, score_groups, output_filename, ds_loc, limit)
elif output_format == 'json':
groups = cls.json_output(cs, score_groups, output_filename, ds_loc, limit)
else:
raise TypeError('Invalid format %s' % output_format)
errors_occurred = cls.check_errors(score_groups, verbose)
return cs.passtree(groups, limit), errors_occurred
class TestSuite(unittest.TestCase):
# @see
# http://www.saltycrane.com/blog/2012/07/how-prevent-nose-unittest-using-docstring-when-verbosity-2/
def setUp(self):
self.cs = CheckSuite()
self.cs.load_all_available_checkers()
def shortDescription(self):
return None
# override __str__ and __repr__ behavior to show a copy-pastable nosetest name for ion tests
# ion.module:TestClassName.test_function_name
def __repr__(self):
name = self.id()
name = name.split('.')
if name[0] not in ["ion", "pyon"]:
return "%s (%s)" % (name[-1], '.'.join(name[:-1]))
else:
return "%s ( %s )" % (name[-1], '.'.join(name[:-2]) + ":" +
'.'.join(name[-2:]))
__str__ = __repr__
def test_suite(self):
# BWA: what's the purpose of this test? Just to see if the suite
# runs without errors?
ds = self.cs.load_dataset(static_files['2dim'])
self.cs.run(ds, 'acdd')
def test_unicode_formatting(self):
ds = self.cs.load_dataset(static_files['bad_region'])
score_groups = self.cs.run(ds, 'cf')
limit = 2
for checker, rpair in score_groups.items():
groups, errors = rpair
score_list, points, out_of = self.cs.standard_output(ds.filepath(),
limit, checker,
groups)
# This asserts that print is able to generate all of the unicode output
self.cs.standard_output_generation(groups, limit, points, out_of, checker)
def test_skip_checks(self):
"""Tests that checks are properly skipped when specified"""
ds = self.cs.load_dataset(static_files['2dim'])
# exclude title from the check attributes
score_groups = self.cs.run(ds, ['check_high'], 'acdd')
assert all(sg.name not in {'Conventions', 'title', 'keywords',
'summary'} for sg in score_groups['acdd'][0])
def test_group_func(self):
# This is checking for issue #183, where group_func results in
# IndexError: list index out of range
ds = self.cs.load_dataset(static_files['bad_data_type'])
score_groups = self.cs.run(ds, 'cf')
limit = 2
for checker, rpair in score_groups.items():
groups, errors = rpair
score_list, points, out_of = self.cs.standard_output(ds.filepath(),
limit, checker,
groups)
# This asserts that print is able to generate all of the unicode output
self.cs.standard_output_generation(groups, limit, points, out_of, checker)
def test_score_grouping(self):
# Testing the grouping of results for output, which can fail
# if some assumptions are not met, e.g. if a Result object has
# a value attribute of unexpected type
res = [
Result(BaseCheck.MEDIUM, True, 'one'),
Result(BaseCheck.MEDIUM, (1, 3), 'one'),
Result(BaseCheck.MEDIUM, None, 'one'),
Result(BaseCheck.MEDIUM, True, 'two'),
Result(BaseCheck.MEDIUM, np.isnan(1), 'two') # value is type numpy.bool_
]
score = self.cs.scores(res)
self.assertEqual(score[0].name, 'one')
self.assertEqual(score[0].value, (2, 4))
self.assertEqual(score[1].name, 'two')
self.assertEqual(score[1].value, (1, 2))
def test_cdl_file(self):
# Testing whether you can run compliance checker on a .cdl file
# Load the cdl file
ds = self.cs.load_dataset(static_files['test_cdl'])
vals = self.cs.run(ds, 'cf')
limit = 2
for checker, rpair in vals.items():
groups, errors = rpair
score_list, cdl_points, cdl_out_of = self.cs.standard_output(ds.filepath(),
limit,
checker,
groups)
# This asserts that print is able to generate all of the unicode output
self.cs.standard_output_generation(groups, limit, cdl_points, cdl_out_of, checker)
ds.close()
# Ok now load the nc file that it came from
ds = self.cs.load_dataset(static_files['test_cdl_nc'])
vals = self.cs.run(ds, 'cf')
limit = 2
for checker, rpair in vals.items():
groups, errors = rpair
score_list, nc_points, nc_out_of = self.cs.standard_output(ds.filepath(),
limit,
checker,
groups)
# This asserts that print is able to generate all of the unicode output
self.cs.standard_output_generation(groups, limit, nc_points, nc_out_of, checker)
ds.close()
nc_file_path = static_files['test_cdl'].replace('.cdl', '.nc')
self.addCleanup(os.remove, nc_file_path)
# Ok the scores should be equal!
self.assertEqual(nc_points, cdl_points)
self.assertEqual(nc_out_of, cdl_out_of)
def test_load_local_dataset_GenericFile(self):
resp = self.cs.load_local_dataset(static_files['empty'])
assert isinstance(resp, GenericFile) == True
def test_standard_output_score_header(self):
"""
Check that the output score header only checks the number of
of potential issues, rather than the weighted score
"""
ds = self.cs.load_dataset(static_files['bad_region'])
score_groups = self.cs.run(ds, [], 'cf')
limit = 2
groups, errors = score_groups['cf']
score_list, all_passed, out_of = self.cs.standard_output(
ds.filepath(),
limit, 'cf',
groups)
self.assertEqual((all_passed, out_of), (30, 47))
def run_checker(
cls,
ds_loc,
checker_names,
verbose,
criteria,
skip_checks=None,
output_filename="-",
output_format=["text"],
options=None,
):
"""
Static check runner.
@param ds_loc Dataset location (url or file)
@param checker_names List of string names to run, should match keys of checkers dict (empty list means run all)
@param verbose Verbosity of the output (0, 1, 2)
@param criteria Determines failure (lenient, normal, strict)
@param output_filename Path to the file for output
@param skip_checks Names of checks to skip
@param output_format Format of the output(s)
@returns If the tests failed (based on the criteria)
"""
all_groups = []
cs = CheckSuite(options=options or {})
# using OrderedDict is important here to preserve the order
# of multiple datasets which may be passed in
score_dict = OrderedDict()
if not isinstance(ds_loc, str):
locs = ds_loc
# if single dataset, put in list
else:
locs = [ds_loc]
# Make sure output format is a list
if isinstance(output_format, str):
output_format = [output_format]
for loc in locs: # loop through each dataset and run specified checks
ds = cs.load_dataset(loc)
score_groups = cs.run(ds, skip_checks, *checker_names)
for group in score_groups.values():
all_groups.append(group[0])
# TODO: consider wrapping in a proper context manager instead
if hasattr(ds, "close"):
ds.close()
if not score_groups:
raise ValueError(
"No checks found, please check the name of the checker(s) and that they are installed"
)
else:
score_dict[loc] = score_groups
# define a score limit to truncate the ouput to the strictness level
# specified by the user
if criteria == "normal":
limit = 2
elif criteria == "strict":
limit = 1
elif criteria == "lenient":
limit = 3
for out_fmt in output_format:
if out_fmt == "text":
if output_filename == "-":
cls.stdout_output(cs, score_dict, verbose, limit)
# need to redirect output from stdout since print functions are
# presently used to generate the standard report output
else:
if len(output_format) > 1:
# Update file name if needed
output_filename = "{}.txt".format(
os.path.splitext(output_filename)[0])
with io.open(output_filename, "w", encoding="utf-8") as f:
with stdout_redirector(f):
cls.stdout_output(cs, score_dict, verbose, limit)
elif out_fmt == "html":
# Update file name if needed
if len(output_format) > 1 and output_filename != "-":
output_filename = "{}.html".format(
os.path.splitext(output_filename)[0])
cls.html_output(cs, score_dict, output_filename, ds_loc, limit)
elif out_fmt in {"json", "json_new"}:
# Update file name if needed
if len(output_format) > 1 and output_filename != "-":
output_filename = "{}.json".format(
os.path.splitext(output_filename)[0])
cls.json_output(cs, score_dict, output_filename, ds_loc, limit,
out_fmt)
else:
raise TypeError("Invalid format %s" % out_fmt)
errors_occurred = cls.check_errors(score_groups, verbose)
return (
all(cs.passtree(groups, limit) for groups in all_groups),
errors_occurred,
)
def run_checker(cls, ds_loc, checker_names, verbose, criteria,
skip_checks=None, output_filename='-',
output_format=['text']):
"""
Static check runner.
@param ds_loc Dataset location (url or file)
@param checker_names List of string names to run, should match keys of checkers dict (empty list means run all)
@param verbose Verbosity of the output (0, 1, 2)
@param criteria Determines failure (lenient, normal, strict)
@param output_filename Path to the file for output
@param skip_checks Names of checks to skip
@param output_format Format of the output(s)
@returns If the tests failed (based on the criteria)
"""
all_groups = []
cs = CheckSuite()
# using OrderedDict is important here to preserve the order
# of multiple datasets which may be passed in
score_dict = OrderedDict()
if not isinstance(ds_loc, six.string_types):
locs = ds_loc
# if single dataset, put in list
else:
locs = [ds_loc]
# Make sure output format is a list
if isinstance(output_format, six.string_types):
output_format = [output_format]
for loc in locs: # loop through each dataset and run specified checks
ds = cs.load_dataset(loc)
score_groups = cs.run(ds, skip_checks, *checker_names)
for group in score_groups.values():
all_groups.append(group[0])
# TODO: consider wrapping in a proper context manager instead
if hasattr(ds, 'close'):
ds.close()
if not score_groups:
raise ValueError("No checks found, please check the name of the checker(s) and that they are installed")
else:
score_dict[loc] = score_groups
# define a score limit to truncate the ouput to the strictness level
# specified by the user
if criteria == 'normal':
limit = 2
elif criteria == 'strict':
limit = 1
elif criteria == 'lenient':
limit = 3
for out_fmt in output_format:
if out_fmt == 'text':
if output_filename == '-':
cls.stdout_output(cs, score_dict, verbose, limit)
# need to redirect output from stdout since print functions are
# presently used to generate the standard report output
else:
if len(output_format) > 1:
# Update file name if needed
output_filename = '{}.txt'.format(os.path.splitext(output_filename)[0])
with io.open(output_filename, 'w', encoding='utf-8') as f:
with stdout_redirector(f):
cls.stdout_output(cs, score_dict, verbose, limit)
elif out_fmt == 'html':
# Update file name if needed
if len(output_format) > 1 and output_filename != '-':
output_filename = '{}.html'.format(os.path.splitext(output_filename)[0])
cls.html_output(cs, score_dict, output_filename, ds_loc, limit)
elif out_fmt in {'json', 'json_new'}:
# Update file name if needed
if len(output_format) > 1 and output_filename != '-':
output_filename = '{}.json'.format(os.path.splitext(output_filename)[0])
cls.json_output(cs, score_dict, output_filename, ds_loc, limit,
out_fmt)
else:
raise TypeError('Invalid format %s' % out_fmt)
errors_occurred = cls.check_errors(score_groups, verbose)
return (all(cs.passtree(groups, limit) for groups in all_groups),
errors_occurred)
class TestSuite(unittest.TestCase):
# @see
# http://www.saltycrane.com/blog/2012/07/how-prevent-nose-unittest-using-docstring-when-verbosity-2/
def setUp(self):
self.cs = CheckSuite()
self.cs.load_all_available_checkers()
def shortDescription(self):
return None
# override __str__ and __repr__ behavior to show a copy-pastable nosetest name for ion tests
# ion.module:TestClassName.test_function_name
def __repr__(self):
name = self.id()
name = name.split('.')
if name[0] not in ["ion", "pyon"]:
return "%s (%s)" % (name[-1], '.'.join(name[:-1]))
else:
return "%s ( %s )" % (name[-1], '.'.join(name[:-2]) + ":" +
'.'.join(name[-2:]))
__str__ = __repr__
def test_suite(self):
# BWA: what's the purpose of this test? Just to see if the suite
# runs without errors?
ds = self.cs.load_dataset(static_files['2dim'])
self.cs.run(ds, 'acdd')
def test_unicode_formatting(self):
ds = self.cs.load_dataset(static_files['bad_region'])
score_groups = self.cs.run(ds, 'cf')
limit = 2
for checker, rpair in score_groups.items():
groups, errors = rpair
score_list, points, out_of = self.cs.standard_output(ds.filepath(),
limit, checker,
groups)
# This asserts that print is able to generate all of the unicode output
self.cs.standard_output_generation(groups, limit, points, out_of, checker)
def test_skip_checks(self):
"""Tests that checks are properly skipped when specified"""
ds = self.cs.load_dataset(static_files['2dim'])
# exclude title from the check attributes
score_groups = self.cs.run(ds, ['check_high'], 'acdd')
assert all(sg.name not in {'Conventions', 'title', 'keywords',
'summary'} for sg in score_groups['acdd'][0])
def test_skip_check_level(self):
"""Checks level limited skip checks"""
ds = self.cs.load_dataset(static_files['ru07'])
score_groups = self.cs.run(ds, ['check_flags:A',
'check_convention_possibly_var_attrs:M',
'check_standard_name:L'], 'cf')
name_set = {sg.name for sg in score_groups['cf'][0]}
# flattened set of messages
msg_set = {msg for sg in score_groups['cf'][0] for msg in sg.msgs}
expected_excluded_names = {u'§3.5 flag_meanings for lat',
u'§3.5 flag_meanings for lon',
u'§3.5 lat is a valid flags variable',
u'§3.5 lat is a valid flags variable',
u'§3.5 lon is a valid flags variable'}
self.assertTrue(len(expected_excluded_names & name_set) == 0)
# should skip references
ref_msg = u'references global attribute should be a non-empty string'
self.assertTrue(ref_msg not in msg_set)
# check_standard_name is high priority, but we requested only low,
# so the standard_name check should still exist
standard_name_hdr = u'§3.3 Standard Name'
self.assertTrue(standard_name_hdr in name_set)
def test_group_func(self):
# This is checking for issue #183, where group_func results in
# IndexError: list index out of range
ds = self.cs.load_dataset(static_files['bad_data_type'])
score_groups = self.cs.run(ds, 'cf')
limit = 2
for checker, rpair in score_groups.items():
groups, errors = rpair
score_list, points, out_of = self.cs.standard_output(ds.filepath(),
limit, checker,
groups)
# This asserts that print is able to generate all of the unicode output
self.cs.standard_output_generation(groups, limit, points, out_of, checker)
def test_score_grouping(self):
# Testing the grouping of results for output, which can fail
# if some assumptions are not met, e.g. if a Result object has
# a value attribute of unexpected type
res = [
Result(BaseCheck.MEDIUM, True, 'one'),
Result(BaseCheck.MEDIUM, (1, 3), 'one'),
Result(BaseCheck.MEDIUM, None, 'one'),
Result(BaseCheck.MEDIUM, True, 'two'),
Result(BaseCheck.MEDIUM, np.isnan(1), 'two') # value is type numpy.bool_
]
score = self.cs.scores(res)
self.assertEqual(score[0].name, 'one')
self.assertEqual(score[0].value, (2, 4))
self.assertEqual(score[1].name, 'two')
self.assertEqual(score[1].value, (1, 2))
def test_cdl_file(self):
# Testing whether you can run compliance checker on a .cdl file
# Load the cdl file
ds = self.cs.load_dataset(static_files['test_cdl'])
vals = self.cs.run(ds, 'cf')
limit = 2
for checker, rpair in vals.items():
groups, errors = rpair
score_list, cdl_points, cdl_out_of = self.cs.standard_output(ds.filepath(),
limit,
checker,
groups)
# This asserts that print is able to generate all of the unicode output
self.cs.standard_output_generation(groups, limit, cdl_points, cdl_out_of, checker)
ds.close()
# Ok now load the nc file that it came from
ds = self.cs.load_dataset(static_files['test_cdl_nc'])
vals = self.cs.run(ds, 'cf')
limit = 2
for checker, rpair in vals.items():
groups, errors = rpair
score_list, nc_points, nc_out_of = self.cs.standard_output(ds.filepath(),
limit,
checker,
groups)
# This asserts that print is able to generate all of the unicode output
self.cs.standard_output_generation(groups, limit, nc_points, nc_out_of, checker)
ds.close()
nc_file_path = static_files['test_cdl'].replace('.cdl', '.nc')
self.addCleanup(os.remove, nc_file_path)
# Ok the scores should be equal!
self.assertEqual(nc_points, cdl_points)
self.assertEqual(nc_out_of, cdl_out_of)
def test_load_local_dataset_GenericFile(self):
resp = self.cs.load_local_dataset(static_files['empty'])
assert isinstance(resp, GenericFile) == True
def test_standard_output_score_header(self):
"""
Check that the output score header only checks the number of
of potential issues, rather than the weighted score
"""
ds = self.cs.load_dataset(static_files['bad_region'])
score_groups = self.cs.run(ds, [], 'cf')
limit = 2
groups, errors = score_groups['cf']
score_list, all_passed, out_of = self.cs.standard_output(
ds.filepath(),
limit, 'cf',
groups)
assert all_passed < out_of
class TestSuite(unittest.TestCase):
# @see
# http://www.saltycrane.com/blog/2012/07/how-prevent-nose-unittest-using-docstring-when-verbosity-2/
def setUp(self):
self.cs = CheckSuite()
self.cs.load_all_available_checkers()
def shortDescription(self):
return None
# override __str__ and __repr__ behavior to show a copy-pastable nosetest name for ion tests
# ion.module:TestClassName.test_function_name
def __repr__(self):
name = self.id()
name = name.split(".")
if name[0] not in ["ion", "pyon"]:
return "%s (%s)" % (name[-1], ".".join(name[:-1]))
else:
return "%s ( %s )" % (
name[-1],
".".join(name[:-2]) + ":" + ".".join(name[-2:]),
)
__str__ = __repr__
def test_suite(self):
# BWA: what's the purpose of this test? Just to see if the suite
# runs without errors?
ds = self.cs.load_dataset(static_files["2dim"])
self.cs.run(ds, "acdd")
def test_unicode_formatting(self):
ds = self.cs.load_dataset(static_files["bad_region"])
score_groups = self.cs.run(ds, "cf")
limit = 2
for checker, rpair in score_groups.items():
groups, errors = rpair
score_list, points, out_of = self.cs.standard_output(
ds.filepath(), limit, checker, groups)
# This asserts that print is able to generate all of the unicode output
self.cs.standard_output_generation(groups, limit, points, out_of,
checker)
def test_generate_dataset_netCDF4(self):
"""
Tests that suite.generate_dataset works with cdl file with netCDF4
features.
"""
# create netCDF4 file
ds_name = self.cs.generate_dataset(static_files["netCDF4"])
# check if correct name is return
assert ds_name == static_files["netCDF4"].replace(".cdl", ".nc")
# check if netCDF4 file was created
assert os.path.isfile(static_files["netCDF4"].replace(".cdl", ".nc"))
def test_skip_checks(self):
"""Tests that checks are properly skipped when specified"""
ds = self.cs.load_dataset(static_files["2dim"])
# exclude title from the check attributes
score_groups = self.cs.run(ds, ["check_high"], "acdd")
assert all(
sg.name not in {"Conventions", "title", "keywords", "summary"}
for sg in score_groups["acdd"][0])
def test_skip_check_level(self):
"""Checks level limited skip checks"""
ds = self.cs.load_dataset(static_files["ru07"])
score_groups = self.cs.run(
ds,
[
"check_flags:A",
"check_convention_possibly_var_attrs:M",
"check_standard_name:L",
],
"cf",
)
name_set = {sg.name for sg in score_groups["cf"][0]}
# flattened set of messages
msg_set = {msg for sg in score_groups["cf"][0] for msg in sg.msgs}
expected_excluded_names = {
u"§3.5 flag_meanings for lat",
u"§3.5 flag_meanings for lon",
u"§3.5 lat is a valid flags variable",
u"§3.5 lat is a valid flags variable",
u"§3.5 lon is a valid flags variable",
}
self.assertTrue(len(expected_excluded_names & name_set) == 0)
# should skip references
ref_msg = u"references global attribute should be a non-empty string"
self.assertTrue(ref_msg not in msg_set)
# check_standard_name is high priority, but we requested only low,
# so the standard_name check should still exist
standard_name_hdr = u"§3.3 Standard Name"
self.assertTrue(standard_name_hdr in name_set)
def test_group_func(self):
# This is checking for issue #183, where group_func results in
# IndexError: list index out of range
ds = self.cs.load_dataset(static_files["bad_data_type"])
score_groups = self.cs.run(ds, "cf")
limit = 2
for checker, rpair in score_groups.items():
groups, errors = rpair
score_list, points, out_of = self.cs.standard_output(
ds.filepath(), limit, checker, groups)
# This asserts that print is able to generate all of the unicode output
self.cs.standard_output_generation(groups, limit, points, out_of,
checker)
def test_score_grouping(self):
# Testing the grouping of results for output, which can fail
# if some assumptions are not met, e.g. if a Result object has
# a value attribute of unexpected type
res = [
Result(BaseCheck.MEDIUM, True, "one"),
Result(BaseCheck.MEDIUM, (1, 3), "one"),
Result(BaseCheck.MEDIUM, None, "one"),
Result(BaseCheck.MEDIUM, True, "two"),
Result(BaseCheck.MEDIUM, np.isnan(1),
"two"), # value is type numpy.bool_
]
score = self.cs.scores(res)
self.assertEqual(score[0].name, "one")
self.assertEqual(score[0].value, (2, 4))
self.assertEqual(score[1].name, "two")
self.assertEqual(score[1].value, (1, 2))
def test_cdl_file(self):
# Testing whether you can run compliance checker on a .cdl file
# Load the cdl file
ds = self.cs.load_dataset(static_files["test_cdl"])
vals = self.cs.run(ds, "cf")
limit = 2
for checker, rpair in vals.items():
groups, errors = rpair
score_list, cdl_points, cdl_out_of = self.cs.standard_output(
ds.filepath(), limit, checker, groups)
# This asserts that print is able to generate all of the unicode output
self.cs.standard_output_generation(groups, limit, cdl_points,
cdl_out_of, checker)
ds.close()
# Ok now load the nc file that it came from
ds = self.cs.load_dataset(static_files["test_cdl_nc"])
vals = self.cs.run(ds, "cf")
limit = 2
for checker, rpair in vals.items():
groups, errors = rpair
score_list, nc_points, nc_out_of = self.cs.standard_output(
ds.filepath(), limit, checker, groups)
# This asserts that print is able to generate all of the unicode output
self.cs.standard_output_generation(groups, limit, nc_points,
nc_out_of, checker)
ds.close()
nc_file_path = static_files["test_cdl"].replace(".cdl", ".nc")
self.addCleanup(os.remove, nc_file_path)
# Ok the scores should be equal!
self.assertEqual(nc_points, cdl_points)
self.assertEqual(nc_out_of, cdl_out_of)
def test_load_local_dataset_GenericFile(self):
resp = self.cs.load_local_dataset(static_files["empty"])
assert isinstance(resp, GenericFile) == True
def test_standard_output_score_header(self):
"""
Check that the output score header only checks the number of
of potential issues, rather than the weighted score
"""
ds = self.cs.load_dataset(static_files["bad_region"])
score_groups = self.cs.run(ds, [], "cf")
limit = 2
groups, errors = score_groups["cf"]
score_list, all_passed, out_of = self.cs.standard_output(
ds.filepath(), limit, "cf", groups)
assert all_passed < out_of
def test_netCDF4_features(self):
"""
Check if a proper netCDF4 file with netCDF4-datatypes is created.
"""
# create and open dataset
ds = self.cs.load_dataset(static_files["netCDF4"])
# check if netCDF type of global attributes is correct
assert isinstance(ds.global_att_of_type_int, np.int32)
# check if netCDF4 type of global attributes is correct
assert isinstance(ds.global_att_of_type_int64, np.int64)
# check if netCDF type of variable is correct
assert ds["tas"].dtype is np.dtype("float32")
# check if netCDF4 type of variable is correct
assert ds["mask"].dtype is np.dtype("int64")
def test_suite(self):
cs = CheckSuite()
cs.load_all_available_checkers()
ds = cs.load_dataset(static_files['2dim'])
vals = cs.run(ds, 'acdd')
def run_checker(cls, ds_loc, checker_names, verbose, criteria,
skip_checks=None, output_filename='-',
output_format=['text']):
"""
Static check runner.
@param ds_loc Dataset location (url or file)
@param checker_names List of string names to run, should match keys of checkers dict (empty list means run all)
@param verbose Verbosity of the output (0, 1, 2)
@param criteria Determines failure (lenient, normal, strict)
@param output_filename Path to the file for output
@param skip_checks Names of checks to skip
@param output_format Format of the output(s)
@returns If the tests failed (based on the criteria)
"""
cs = CheckSuite()
# using OrderedDict is important here to preserve the order
# of multiple datasets which may be passed in
score_dict = OrderedDict()
if not isinstance(ds_loc, six.string_types):
locs = ds_loc
# if single dataset, put in list
else:
locs = [ds_loc]
# Make sure output format is a list
if isinstance(output_format, six.string_types):
output_format = [output_format]
for loc in locs:
ds = cs.load_dataset(loc)
score_groups = cs.run(ds, [] if skip_checks is None else skip_checks,
*checker_names)
if not score_groups:
raise ValueError("No checks found, please check the name of the checker(s) and that they are installed")
else:
score_dict[loc] = score_groups
if criteria == 'normal':
limit = 2
elif criteria == 'strict':
limit = 1
elif criteria == 'lenient':
limit = 3
for out_fmt in output_format:
if out_fmt == 'text':
if output_filename == '-':
groups = cls.stdout_output(cs, score_dict, verbose, limit)
# need to redirect output from stdout since print functions are
# presently used to generate the standard report output
else:
if len(output_format) > 1:
# Update file name if needed
output_filename = '{}.txt'.format(os.path.splitext(output_filename)[0])
with io.open(output_filename, 'w', encoding='utf-8') as f:
with stdout_redirector(f):
groups = cls.stdout_output(cs, score_dict, verbose,
limit)
elif out_fmt == 'html':
# Update file name if needed
if len(output_format) > 1 and output_filename != '-':
output_filename = '{}.html'.format(os.path.splitext(output_filename)[0])
groups = cls.html_output(cs, score_dict, output_filename, ds_loc,
limit)
elif out_fmt == 'json' or 'json_new':
# Update file name if needed
if len(output_format) > 1 and output_filename != '-':
output_filename = '{}.json'.format(os.path.splitext(output_filename)[0])
groups = cls.json_output(cs, score_dict, output_filename, ds_loc,
limit, out_fmt)
else:
raise TypeError('Invalid format %s' % out_fmt)
errors_occurred = cls.check_errors(score_groups, verbose)
return cs.passtree(groups, limit), errors_occurred
