def test_nonreadable(app, status, warning):
basename = 'nonreadable'
with nonreadable(path(basename, 'nonreadable.json')), nonreadable(
path(basename, 'nonreadable.csv')):
assert_build(app, status, warning, basename, [
f"ERROR: JSON Schema file not readable: {path(basename, 'nonreadable.json')}",
f"ERROR: CSV codelist file not readable: {path(basename, 'nonreadable.csv')}",
])
def test_command_check(stderr, monkeypatch):
with open(path('schema-strict.json'), 'rb') as f:
expected = f.read()
run_command(monkeypatch, main, ['schema-strict', '--check', path('schema-strict.json')])
with open(path('schema-strict.json'), 'rb') as f:
assert f.read() == expected
assert stderr.getvalue() == 'ERROR: tests/fixtures/schema-strict.json is missing validation properties\n'
def test_post_file(self):
with open(path('schemas/ocds-ppp-1_0_0-release-schema.json')) as f:
self.assertSuccess('post',
'results/ocds-ppp-1_0_0-mapping-sheet.csv', {
'type': 'file',
'custom_file': f,
})
def test_command_order_by(monkeypatch):
with patch('sys.stdout', new_callable=StringIO) as actual:
monkeypatch.setattr(sys, 'argv', ['ocdskit', 'mapping-sheet', '--order-by', 'path',
'--infer-required', path('release-schema.json')])
main()
assert actual.getvalue() == read('mapping-sheet_order-by.csv', newline='')
def test_command_bods(monkeypatch):
with patch('sys.stdout', new_callable=StringIO) as actual:
monkeypatch.setattr(sys, 'argv', ['ocdskit', 'mapping-sheet', '--order-by', 'path',
path('bods/person-statement.json')])
main()
assert actual.getvalue() == read('mapping-sheet_bods.csv', newline='')
def test_patched_release_schema_with_absolute_path():
url = Path(path('ocds_coveredBy_extension')).resolve().as_uri()
builder = ProfileBuilder('1__1__4', [url])
result = builder.patched_release_schema()
assert '$schema' in result
assert 'coveredBy' in result['definitions']['Tender']['properties']
def test_command_extension_and_extension_field_location(monkeypatch):
url = 'https://github.com/open-contracting-extensions/ocds_location_extension/archive/v1.1.4.zip'
assert_command(monkeypatch, main, [
'mapping-sheet', '--infer-required', '--extension-field', 'extension',
path('release-schema.json'), '--extension', url
], 'mapping-sheet_extension_extension-field_location.csv')
def test_command_min_occurrences(monkeypatch):
actual = run_command(monkeypatch, main, [
'schema-report', '--min-occurrences', '1', '--no-codelists',
path('test-schema.json')
])
assert 'codelist,openCodelist' not in actual
assert '1:' in actual
def test_command_no_definitions(monkeypatch):
actual = run_command(monkeypatch, main, [
'schema-report', '--min-occurrences', '2', '--no-definitions',
path('test-schema.json')
])
assert 'codelist,openCodelist' in actual
assert ':' not in actual
def test_command_root_path_nonexistent(monkeypatch, caplog):
assert_command_error(monkeypatch,
main, [
'detect-format', '--root-path', 'nonexistent',
path('record_minimal.json')
],
error=StopIteration)
assert len(caplog.records) == 0
def test_command_no_unique_items(monkeypatch, tmpdir):
with open(path('schema-strict.json'), 'rb') as f:
schema = f.read()
p = tmpdir.join('schema.json')
p.write(schema)
run_command(monkeypatch, main, ['schema-strict', '--no-unique-items', str(p)])
assert 'uniqueItems' not in json.loads(p.read())['properties']['array']
def test_command(monkeypatch, tmpdir):
with open(path('schema-strict.json'), 'rb') as f:
schema = f.read()
p = tmpdir.join('schema.json')
p.write(schema)
run_command(monkeypatch, main, ['schema-strict', str(p)])
assert p.read() == expected
def test_command_unknown_format(basename, result, monkeypatch, caplog):
filename = 'detect-format_{}.json'.format(basename)
assert_command(monkeypatch, main, ['detect-format', path(filename)], '')
assert len(caplog.records) == 1
assert caplog.records[0].levelname == 'WARNING'
assert caplog.records[
0].message == 'tests/fixtures/{}: unknown (top-level JSON value is a {})'.format(
filename, result)
def test_command_order_by_nonexistent(monkeypatch, caplog):
assert_command_error(monkeypatch, main, [
'mapping-sheet', '--order-by', 'nonexistent',
path('release-schema.json')
])
assert len(caplog.records) == 1
assert caplog.records[0].levelname == 'CRITICAL'
assert caplog.records[
0].message == "the column 'nonexistent' doesn't exist – did you make a typo?"
def test_command_order_by_nonexistent(monkeypatch, caplog):
with pytest.raises(SystemExit) as excinfo:
with patch('sys.stdout', new_callable=StringIO) as actual:
monkeypatch.setattr(sys, 'argv', ['ocdskit', 'mapping-sheet', '--order-by', 'nonexistent',
path('release-schema.json')])
main()
assert actual.getvalue() == ''
assert len(caplog.records) == 1
assert caplog.records[0].levelname == 'CRITICAL'
assert caplog.records[0].message == "the column 'nonexistent' doesn't exist – did you make a typo?"
assert excinfo.value.code == 1
def test_importers_generic(self):
"""Testing: parse method for all importers."""
for manager in tests.conf:
with self.subTest(manager):
importer = tests.cls(manager)
testpath = tests.path(manager)
reference = tests.reference(manager)
encoding = tests.conf[manager]['encoding']
with open(testpath, 'r', encoding=encoding) as file:
importer.parse(file)
self.assertImport(importer.data, reference)
def assert_build(app,
status,
warning,
basename,
buildername='html',
messages=None):
app.build()
warnings = warning.getvalue().strip()
if buildername == 'html':
with open(path(basename, '_build', buildername, 'index.html'),
encoding='utf-8') as f:
element = lxml.html.fromstring(
f.read()).xpath('//div[@class="documentwrapper"]')[0]
actual = lxml.html.tostring(element).decode()
with open(path(f'{basename}.html'), encoding='utf-8') as f:
expected = f.read()
assert normalize(actual) == normalize(expected)
elif buildername == 'gettext':
with open(path(basename, '_build', buildername, 'index.pot'),
encoding='utf-8') as f:
actual = re.sub(r"POT-Creation-Date: [0-9: +-]+",
"POT-Creation-Date: ", f.read())
with open(path(f'{basename}.pot'), encoding='utf-8') as f:
expected = f.read()
assert actual == expected
assert 'build succeeded' in status.getvalue()
if messages:
for message in messages:
assert message in warnings
assert len(messages) == len(warnings.split('\n'))
else:
assert warnings == ''
def test_command(monkeypatch):
actual = run_command(
monkeypatch, main,
['schema-report', '--min-occurrences', '2',
path('test-schema.json')])
assert actual == 'codelist,openCodelist\n' \
'a.csv,False/True\n' \
'b.csv,False\n' \
'c.csv,False\n' \
'd.csv,False\n' \
'\n' \
" 2: {'codelist': 'a.csv', 'openCodelist': True, 'type': ['string', 'null']}\n"
def assert_build(app, status, warning, basename, messages=None):
app.build()
warnings = warning.getvalue().strip()
with open(path(basename, '_build', 'html', 'index.html'),
encoding='utf-8') as f:
element = lxml.html.fromstring(
f.read()).xpath('//div[@class="documentwrapper"]')[0]
actual = lxml.html.tostring(element).decode()
with open(path(f'{basename}.html'), encoding='utf-8') as f:
expected = f.read()
assert 'build succeeded' in status.getvalue()
if messages:
for message in messages:
assert message in warnings
assert len(messages) == len(warnings.split('\n'))
else:
assert warnings == ''
assert normalize(actual) == normalize(expected)
def get_test_cases():
test_valid_argvalues = []
release_schema_path = 'release-schema-{}.json'
versioned_release_schema_path = 'versioned-release-validation-schema-{}.json'
for minor_version, patch_tag in tags.items():
filenames = glob(path(os.path.join(minor_version, '*.json')))
assert len(filenames), 'ocds fixtures not found'
for versioned, schema_path in ((False, release_schema_path), (True, versioned_release_schema_path)):
schema = load(schema_path.format(patch_tag))
for filename in filenames:
if not versioned ^ filename.endswith('-versioned.json'):
test_valid_argvalues.append((filename, schema))
return test_valid_argvalues
def test_importers_csv(self):
"""Testing: parse method for the generic CSV importer."""
csv = ['1password4', 'roboform']
cols = {
'1password4': 'title,comments,login,password,url',
'roboform': 'title,url,login,password,comments,group,,'
}
for manager in csv:
with self.subTest(manager):
importer = tests.cls('csv')
importer.cols = cols[manager]
testpath = tests.path(manager)
reference = tests.reference(manager)
encoding = tests.conf[manager]['encoding']
with open(testpath, 'r', encoding=encoding) as file:
importer.parse(file)
self.assertImport(importer.data, reference)
def test_go_with_files(self):
results = {
'csv': [
'releases.csv',
'ten_items.csv',
'parties.csv',
],
'xlsx': [
'xl/worksheets/sheet1.xml',
'xl/worksheets/sheet2.xml',
'xl/worksheets/sheet3.xml',
]
}
contents = self.upload_and_go({'type': 'release-package'})
self.assertEqual(len(contents), len(results))
prefix = r'^/result/' + '{:%Y-%m-%d}'.format(
date.today()) + r'/[0-9a-f-]{36}/'
for extension, content in contents.items():
self.assertEqual(len(content), 2)
self.assertIsInstance(content['size'], int)
self.assertRegex(content['url'], prefix + extension + r'/$')
zipfile = self.get_zipfile(contents['csv'])
self.assertEqual(len(zipfile.namelist()), len(results['csv']))
for name in results['csv']:
self.assertEqual(
zipfile.read(name).decode('utf-8').replace('\r\n', '\n'),
read('results/flattened/' + name))
actual = self.get_zipfile(contents['xlsx'])
with open(path('results/flattened.xlsx'), 'rb') as f:
expected = ZipFile(f)
self.assertEqual(_worksheets_length(actual),
_worksheets_length(expected))
for name in results['xlsx']:
self.assertEqual(actual.read(name), expected.read(name))
assert normalize(actual) == normalize(expected)
@contextmanager
def nonreadable(filename):
file = Path(filename)
file.touch()
file.chmod(0)
try:
yield
finally:
file.unlink()
@pytest.mark.sphinx(buildername='html',
srcdir=path('field-description'),
freshenv=True)
def test_field_description(app, status, warning):
basename = 'field-description'
assert_build(app, status, warning, basename, [
f"ERROR: JSON Schema file not found: {path(basename, 'nonexistent.json')}",
f"ERROR: JSON Schema file not valid: {path(basename, 'invalid.json')}",
f"ERROR: Pointer '/properties/nonexistent/description' not found: {path(basename, 'schema.json')}",
])
@pytest.mark.sphinx(buildername='html',
srcdir=path('code-description'),
freshenv=True)
def test_code_description(app, status, warning):
def test_command_oc4ids(monkeypatch):
assert_command(
monkeypatch, main,
['mapping-sheet', path('project-schema.json')],
'mapping-sheet_oc4ids.csv')
def test_command(monkeypatch):
assert_command(
monkeypatch, main,
['mapping-sheet', '--infer-required',
path('release-schema.json')], 'mapping-sheet.csv')
def test_command_sedl(monkeypatch):
with patch('sys.stdout', new_callable=StringIO) as actual:
monkeypatch.setattr(sys, 'argv', ['ocdskit', 'mapping-sheet', path('sedl-schema.json')])
main()
assert actual.getvalue() == read('mapping-sheet_sedl.csv', newline='')
def test_command_bods(monkeypatch):
assert_command(monkeypatch, main, [
'mapping-sheet', '--order-by', 'path',
path('bods/person-statement.json')
], 'mapping-sheet_bods.csv')
def test_command_sedl(monkeypatch):
assert_command(monkeypatch, main,
['mapping-sheet', path('sedl-schema.json')],
'mapping-sheet_sedl.csv')
with open(path(f'{basename}.pot'), encoding='utf-8') as f:
expected = f.read()
assert actual == expected
assert 'build succeeded' in status.getvalue()
if messages:
for message in messages:
assert message in warnings
assert len(messages) == len(warnings.split('\n'))
else:
assert warnings == ''
@pytest.mark.sphinx(buildername='html', srcdir=path('basic'), freshenv=True)
def test_basic(app, status, warning):
assert_build(app, status, warning, 'basic')
@pytest.mark.sphinx(buildername='gettext', srcdir=path('basic'), freshenv=True)
def test_basic_gettext(app, status, warning):
assert_build(app, status, warning, 'basic', buildername='gettext')
@pytest.mark.sphinx(buildername='html',
srcdir=path('basic-externallinks'),
freshenv=True)
def test_basic_externallinks(app, status, warning):
assert_build(app, status, warning, 'basic-externallinks')
def test_command_root_path(filename, root_path, result, monkeypatch):
expected = 'tests/fixtures/{}: {}\n'.format(filename, result)
assert_command(monkeypatch, main,
['detect-format', '--root-path', root_path,
path(filename)], expected)
