def test_migrate_3_most_viewed_packages_to_virtuoso(self):
packages_to_migrate = []
condition = Package.id == TED_PACKAGE_ID
ted_package = find_any_in_database(TEST_CONFIG_FILE_PATH, condition,
Package)[0]
condition = Package.id == DGT_TRANSLATION_PACKAGE_ID
dgt_translation_package = find_any_in_database(TEST_CONFIG_FILE_PATH,
condition, Package)[0]
condition = Package.id == CORDISH2020PROJECTS_PACKAGE_ID
cordisH2020projects_package = find_any_in_database(
TEST_CONFIG_FILE_PATH, condition, Package)[0]
packages_to_migrate.append(ted_package)
packages_to_migrate.append(dgt_translation_package)
packages_to_migrate.append(cordisH2020projects_package)
controlled_vocabulary = ControlledVocabulary()
for package in packages_to_migrate:
datasets_migration_manager.migrate_package_to_virtuoso(
config_file_path=TEST_CONFIG_FILE_PATH,
package=package,
controlled_vocabulary=controlled_vocabulary)
dataset = DatasetDcatApOp(DATASET_URI_PREFIX + "ted-1")
result = dataset.get_description_from_ts()
assert result is True
dataset = DatasetDcatApOp(DATASET_URI_PREFIX + "cordisH2020projects")
result = dataset.get_description_from_ts()
assert result is True
dataset = DatasetDcatApOp(DATASET_URI_PREFIX +
"dgt-translation-memory")
result = dataset.get_description_from_ts()
assert result is True
def test_get_description_from_ts(self):
ds1 = DatasetDcatApOp(
"http://data.europa.eu/88u/dataset/dgt-translation-memory-V1-2")
ds2 = DatasetDcatApOp(
"http://data.europa.eu/88u/dataset/dgt-translation-memory-V3")
ds_private = DatasetDcatApOp(
"http://data.europa.eu/88u/dataset/dgt-translation-memory-V4",
privacy_state="private",
graph_name=DCATAPOP_PRIVATE_GRAPH_NAME)
desc1 = ds1.get_description_from_ts()
desc2 = ds2.get_description_from_ts()
desc_private = ds_private.get_description_from_ts()
ckan_name1 = ds1.schema.ckanName_dcatapop['0'].value_or_uri
ckan_name2 = ds2.schema.ckanName_dcatapop['0'].value_or_uri
ckan_name_private = ds_private.schema.ckanName_dcatapop[
'0'].value_or_uri
self.assertTrue(
ckan_name1 == "dgt-translation-memory-V1-2"
and ckan_name_private == "dgt-translation-memory-V4",
"TestDataSet: CkanName is not correct")
keyword_ds1 = ds1.schema.keyword_dcat['0'].value_or_uri
len_keyword_ds2 = ds2.schema.keyword_dcat.__len__()
self.assertTrue(keyword_ds1 == "translation" and len_keyword_ds2 == 4,
"TestDataSet: Structure of keyword error ")
self.assertTrue(ds1.get_telephone_numbers() == {'0': u'tel:086631722'})
def test_save_as_public(self):
ds_private = DatasetDcatApOp(TRANSLATION_MEMORY_V_4,
privacy_state=PRIVACY_STATE_PRIVATE,
graph_name=DCATAPOP_PRIVATE_GRAPH_NAME)
ds_private.privacy_state = PRIVACY_STATE_PUBLIC
ds_private.get_description_from_ts()
ds_private.save_to_ts()
def test_update_dataset(self):
ds = DatasetDcatApOp(
"http://data.europa.eu/88u/dataset"
"/european-structural-investment-funds-esif-2014-2020-finance-implementation-details"
)
ds.get_description_from_ts()
ds.save_to_ts()
def test_save_to_ts_new(self):
dataset = DatasetDcatApOp(
"http://data.europa.eu/88u/dataset/dgt-translation-memory")
dataset.get_description_from_ts()
r = dataset.save_to_ts()
self.assertTrue(r)
pass
def test_data_change_in_ts(self):
ds = DatasetDcatApOp(
'http://data.europa.eu/88u/dataset/efsa-botanical-compendium')
ds.get_description_from_ts()
ds.schema.identifier_adms.get('0').uri = '10.5281/zenodo.1212387'
result = ds.save_to_ts()
self.assertTrue(result)
def test_delete_from_ts(self):
ds = DatasetDcatApOp(
"http://data.europa.eu/88u/dataset/dgt-translation-memory-V1-2")
if ds.get_description_from_ts():
ds.get_description_from_ts()
ds.delete_from_ts()
ds.get_description_from_ts()
count_ttl_lines = len(ds.ttl_as_in_ts.splitlines(2))
self.assertTrue(count_ttl_lines == 2,
"Delete dataset from ts failed")
def test_ts_and_cache_equality(self):
name_or_id = uri_prefix_test + "dgt-translation-memory-V1-2"
ts_dataset = None # type: DatasetDcatApOp
cache_dataset = None # type: DatasetDcatApOp
ts_dataset = DatasetDcatApOp(name_or_id)
ts_dataset.get_description_from_ts()
dataset_string = redis_cache.get_from_cache(name_or_id, pool=redis_cache.DATASET_POOL)
if dataset_string:
cache_dataset = pickle.loads(dataset_string)
assert_equal(ts_dataset.schema.__dict__, cache_dataset.schema.__dict__)
def test_get_revisions(self):
ds = DatasetDcatApOp(
"http://data.europa.eu/88u/dataset"
"/european-structural-investment-funds-esif-2014-2020-finance-implementation-details"
)
ds.get_description_from_ts()
list_of_revisions = ds.get_list_revisions_ordred(2)
pass
# ds.save_to_ts()
pass
def edit_save_to_ts():
ds1 = DatasetDcatApOp("http://data.europa.eu/88u/dataset/dgt-translation-memory-V1-2")
if ds1.get_description_from_ts():
ds1.privacy_state = "public"
ds1.schema.ckanName_dcatapop['0'].value_or_uri = "NEW CKAN NAME"
ds1.schema.keyword_dcat['fr'] = ResourceValue(u'la réussite', lang="fr")
ds1.schema.keyword_dcat['grg'] = ResourceValue(u'επιτυχία', lang="gr")
ds1.schema.contactPoint_dcat['0'].hasTelephone_vcard['0'].hasValue_vcard['0'].uri = "TEL:213232323"
if ds1.save_to_ts():
print " Save done"
ds1after = DatasetDcatApOp("http://data.europa.eu/88u/dataset/dgt-translation-memory-V1-2")
ds1after.get_description_from_ts()
pass
def test_serialize_dataset(self): # TODO
ds = DatasetDcatApOp(
"http://data.europa.eu/88u/dataset/dgt-translation-memory-V1-2")
desc = ds.get_description_from_ts()
if desc:
phone_source = ds.schema.contactPoint_dcat['0'].hasTelephone_vcard[
'0'].hasValue_vcard['0'].uri
redis_ds = pickle.dumps(ds)
ds2 = pickle.loads(redis_ds)
phone = ds2.schema.contactPoint_dcat['0'].hasTelephone_vcard[
'0'].hasValue_vcard['0'].uri
self.assertEqual(
phone_source, phone, "Test serialize dataset: Phone numbers "
"should be equal ({0}) ({1})".format(phone_source, phone))
ds.schema.contactPoint_dcat['0'].hasTelephone_vcard[
'0'].hasValue_vcard['0'].uri = "123456"
phone_new = ds.schema.contactPoint_dcat['0'].hasTelephone_vcard[
'0'].hasValue_vcard['0'].uri
self.assertNotEqual(
phone, phone_new, "Test serialize dataset: Phone numbers "
"should be different ({0}) ({1})".format(phone_new, phone))
def test_create_multi_lang_full_text(self): # TODO finish it
ds = DatasetDcatApOp(
"http://data.europa.eu/88u/dataset/dgt-translation-memory-V1-2")
if ds.get_description_from_ts():
mega_field = ds.create_multi_lang_full_text()
# TODO add an assertion
pass
def test_export_to_json(self):
ds = DatasetDcatApOp(
"http://data.europa.eu/88u/dataset/dgt-translation-memory-V3")
if ds.get_description_from_ts():
json_dict = {}
json_string = ds.get_dataset_as_json()
pass
def test_at_most_one_by_language(self):
ds = DatasetDcatApOp(
"http://data.europa.eu/88u/dataset/dgt-translation-memory-V1-2")
if ds.get_description_from_ts():
ds.schema.title_dcterms['1'] = ResourceValue("new title", "fr")
ds.schema.title_dcterms['2'] = ResourceValue("new title2", "it")
validator = ValidationSchema(ds.schema,
ds.schema.get_schema_type())
report = validator.validate()
# validation_result = True
for result in report:
if result.get("property") == "title_dcterms" and result.get(
"constraint") == "card_1..n_en":
validation_result = False if result.get(
"result") == ValidationTypeResult.error else True
break
self.assertTrue(validation_result,
" Test validation of test_at_least_one_en failed")
# test the case of empty value
ds.schema.title_dcterms['0'].value_or_uri = ''
validator = ValidationSchema(ds.schema,
ds.schema.get_schema_type())
report = validator.validate()
for result in report:
if result.get("property") == "title_dcterms" and result.get(
"constraint") == "card_1..n_en":
validation_result = False if result.get(
"result") == ValidationTypeResult.error else True
self.assertTrue(not validation_result,
" Test validation of test_at_least_one_en failed")
ds.schema.title_dcterms['0'].value_or_uri = None
validator = ValidationSchema(ds.schema,
ds.schema.get_schema_type())
report = validator.validate()
for result in report:
if result.get("property") == "title_dcterms" and result.get(
"constraint") == "card_1..n_en":
validation_result = False if result.get(
"result") == ValidationTypeResult.error else True
self.assertTrue(not validation_result,
" Test validation of test_at_least_one_en failed")
# No english title
ds.schema.title_dcterms['0'] = ResourceValue("new title", "de")
validator = ValidationSchema(ds.schema,
ds.schema.get_schema_type())
report = validator.validate()
for result in report:
if result.get("property") == "title_dcterms" and result.get(
"constraint") == "card_1..n_en":
validation_result = False if result.get(
"result") == ValidationTypeResult.error else True
self.assertTrue(not validation_result,
" Test validation of test_at_least_one_en failed")
def test_edit_save_to_ts(self):
self.test_get_description_from_ts()
dataset = DatasetDcatApOp(TRANSLATION_MEMORY_V_1_2)
if dataset.get_description_from_ts():
dataset.privacy_state = PRIVACY_STATE_PUBLIC
dataset.schema.ckanName_dcatapop[
'0'].value_or_uri = "NEW CKAN NAME"
dataset.schema.keyword_dcat[LanguagesConstants.LANGUAGE_CODE_FR] = \
ResourceValue(u'la réussite', lang=LanguagesConstants.LANGUAGE_CODE_FR)
dataset.schema.keyword_dcat[LanguagesConstants.LANGUAGE_CODE_EL] = \
ResourceValue(u'επιτυχία', lang=LanguagesConstants.LANGUAGE_CODE_EL)
dataset.schema.contactPoint_dcat['0'].hasTelephone_vcard[
'0'].hasValue_vcard['0'].uri = "TEL:213232323"
if dataset.save_to_ts():
print " Save done"
ds1after = DatasetDcatApOp(TRANSLATION_MEMORY_V_1_2)
ds1after.get_description_from_ts()
pass
def test_get_dataset_as_rdfxml(self):
ds = DatasetDcatApOp(
"http://data.europa.eu/88u/dataset/dgt-translation-memory-V3")
if ds.get_description_from_ts():
rdf_xml = ds.get_dataset_as_rdfxml()
tag = "<dcatapop:ckanName>dgt-translation-memory-V3</dcatapop:ckanName>"
ns = 'xmlns:dcatapop="http://data.europa.eu/88u/ontology/dcatapop#"'
self.assertTrue(tag in rdf_xml)
self.assertTrue(ns in rdf_xml)
pass
def generate_pickled_dataset(activate=False):
if activate:
list_ds_vip = [
"http://data.europa.eu/88u/dataset/doi-test1",
"http://data.europa.eu/88u/dataset/eurovoc",
"http://data.europa.eu/88u/dataset/dgt-translation-memory"
]
for ds_uri in list_ds_vip:
ds = DatasetDcatApOp(ds_uri)
ds.get_description_from_ts()
file_name = ds_uri.split("/")[-1] + ".pickle"
with open(self._RESOURCE_FOLDER + file_name,
"w") as pickle_file:
pickle.dump(ds, pickle_file)
with open(self._RESOURCE_FOLDER + file_name + ".json",
"w") as f:
json.dump(self._MOCK_DATASET_DATA, f)
def test_validate(self): # TODO finish the test
ds = DatasetDcatApOp(
"http://data.europa.eu/88u/dataset/dgt-translation-memory-V1-2")
if ds.get_description_from_ts():
# compare lengths of the report and the validation rules
# report = ds.schema.validate_schema()
dataset_validation_report = ds.validate_dataset()
self.assertEqual(len(dataset_validation_report), 4,
"Size of the report incorrect")
def test_convert_to_graph(self):
ds = DatasetDcatApOp(
"http://data.europa.eu/88u/dataset/dgt-translation-memory-V1-2")
ds.get_description_from_ts()
gs_before = ds.build_the_graph()
ttl_as_in_ts = gs_before.serialize(format="nt")
ds.schema.ckanName_dcatapop['0'].value_or_uri = "NEW CKAN NAME"
ds.schema.ckanName_dcatapop['1'] = ResourceValue("NEW CKAN NAME", 'fr')
ds.schema.description_dcterms = {
} # ['0'].value_or_uri = "NEW DESCRIPTION"
gs_after = ds.build_the_graph()
ttl_convert = gs_after.serialize(format="nt")
contain = "NEW CKAN NAME" in ttl_convert
contain_removed_desc = "<http://data.europa.eu/88u/dataset/dgt-translation-memory-V1-2> <http://purl.org/dc/terms/description>" in ttl_convert
self.assertTrue(contain, "Convertion of the graph faild")
self.assertFalse(
contain_removed_desc,
"removed element still in the dataset, build graph failed ")
def test_save_to_ts(self):
ds1 = DatasetDcatApOp(
"http://data.europa.eu/88u/dataset/dgt-translation-memory-V1-2")
if ds1.get_description_from_ts():
ds1.privacy_state = "public"
ds1.schema.ckanName_dcatapop['0'].value_or_uri = "NEW CKAN NAME"
ds1.schema.ckanName_dcatapop['1'] = ResourceValue(
"Second CKAN NAME")
# ckan_name_new = ds1.schema.ckanName_dcatapop['1'] = ResourceValue("another ckan Name")
ds1.schema.contactPoint_dcat['0'].hasTelephone_vcard[
'0'].hasValue_vcard['0'].uri = "TEL:213232323"
ds1.save_to_ts()
ds1after = DatasetDcatApOp(
"http://data.europa.eu/88u/dataset/dgt-translation-memory-V1-2"
)
ds1after.get_description_from_ts()
ckan_name_new = ds1after.schema.ckanName_dcatapop['0'].value_or_uri
lenc = len(ds1after.schema.ckanName_dcatapop)
msg = "Expected name {0}, New value {1}. Expected length {2}, Get {3}"
self.assertTrue(
ckan_name_new == "NEW CKAN NAME" and lenc == 2,
msg.format("NEW CKAN NAME", ckan_name_new, 2, lenc))
# check if the generation of uris from memeber name workds in the case of DASH and DOT
self.assertTrue("organisation-name" in ds1after.ttl_as_in_ts,
"generation of uri from member failed")
ds_new = DatasetDcatApOp("http://newdcatap.com")
ds_new.schema.ckanName_dcatapop['0'] = ResourceValue("ckan Name new")
ds_new.save_to_ts()
ds_new_from_ts = DatasetDcatApOp("http://newdcatap.com")
ds_new_from_ts.get_description_from_ts()
self.assertTrue(
ds_new_from_ts.schema.ckanName_dcatapop['0'].value_or_uri ==
ds_new.schema.ckanName_dcatapop['0'].value_or_uri,
"New dataset is not saved")
def test_at_most_one(self):
ds = DatasetDcatApOp(
"http://data.europa.eu/88u/dataset/dgt-translation-memory-V1-2")
if ds.get_description_from_ts():
validation_error = False
# ds.schema.theme_dcat['1'] = ResourceValue("New CKAN")
validator = ValidationSchema(ds.schema,
ds.schema.get_schema_type())
report = validator.validate()
for result in report:
if result.get(
"property") == "accessRights_dcterms" and result.get(
"constraint") == "card_0..1":
validation_result = False if result.get(
"result") == ValidationTypeResult.error else True
break
self.assertTrue(validation_result,
" Test validation of must_have_one failed")
# add another member
ds.schema.accessRights_dcterms['1'] = SchemaGeneric("newthem")
validator = ValidationSchema(ds.schema,
ds.schema.get_schema_type())
report = validator.validate()
for result in report:
if result.get(
"property") == "accessRights_dcterms" and result.get(
"constraint") == "card_0..1":
validation_result = True if result.get(
"result") == ValidationTypeResult.error else False
break
self.assertTrue(
validation_result,
" Test validation of must_have_one (more than 1) failed")
pass
ds.schema.accessRights_dcterms = None
validator = ValidationSchema(ds.schema,
ds.schema.get_schema_type())
report = validator.validate()
for result in report:
if result.get(
"property") == "accessRights_dcterms" and result.get(
"constraint") == "card_0..1":
validation_result = False if result.get(
"result") == ValidationTypeResult.error else True
break
self.assertTrue(
validation_result,
" Test validation of must_have_one (cardinality 0) failed")
pass
def rollback_dataset_to_revision(self, dataset_uri):
"""
rollback the dataset to the selected revision
:param dataset:
:param revision_id:
:return:
"""
try:
revision = self.get_first_valid_revision(
dataset_uri=dataset_uri) or {}
revision_dataset = revision.get('dataset', None)
if revision_dataset:
context = {"ignore_auth": True}
result = update_exisiting_dataset(revision_dataset, None,
context,
{"uri": dataset_uri})
if result:
log.info(
"[ROLLBACK Dataset] [Successful] [URI:<{0}>]".format(
dataset_uri))
else:
log.error(
"[ROLLBACK Dataset] [Failed] [Updating dataset][URI:<{0}>]"
.format(dataset_uri))
else:
# Remove dataset
log.error(
"[ROLLBACK Dataset] [Revision None] [Try to delete Dataset][URI:<{0}>]"
.format(dataset_uri))
try:
dataset_to_remove = DatasetDcatApOp(dataset_uri)
result = dataset_to_remove.get_description_from_ts()
if result:
dataset_to_remove.delete_from_ts()
log.info(
"[ROLLBACK Dataset] [Delete Dataset] [Successful] [URI:<{0}>]"
.format(dataset_uri))
redis_cache.delete_value_from_cache(
dataset_to_remove.dataset_uri)
package_index.remove_dict(dataset_to_remove)
except BaseException as e:
log.error(traceback.print_exc(e))
log.error(
"[ROLLBACK Dataset] [Delete dataset] [Failed] [URI:<{0}>]"
.format(dataset_uri))
except BaseException as e:
log.error(traceback.print_exc(e))
log.error("[ROLLBACK Dataset] [Failed] [Revision None][URI:<{0}>]".
format(dataset_uri))
def get_description_from_ts():
ds1 = DatasetDcatApOp("http://data.europa.eu/88u/dataset/dgt-translation-memory-V1-2")
ds2 = DatasetDcatApOp("http://data.europa.eu/999/dataset/dgt-translation-memory-V3")
ds_private = DatasetDcatApOp("http://data.europa.eu/999/dataset/dgt-translation-memory-V4", privacy_state="private",
graph_name=DCATAPOP_PRIVATE_GRAPH_NAME)
# extract the dontent from graphs
desc1 = ds1.get_description_from_ts()
desc2 = ds2.get_description_from_ts()
desc_private = ds_private.get_description_from_ts()
ckan_name1 = ds1.schema.ckanName_dcatapop['0'].value_or_uri
ckan_name2 = ds2.schema.ckanName_dcatapop['0'].value_or_uri
ckan_name_private = ds_private.schema.ckanName_dcatapop['0'].value_or_uri
keywords1 = ds1.schema.keyword_dcat
# rv = ResourceValue()
print "Dataset: http://data.europa.eu/88u/dataset/dgt-translation-memory-V1-2"
print "CkanName is : {0} ".format(ckan_name1)
print "keywords are :".format()
for k, rv in keywords1.iteritems():
print "lnaguage '{0}' has the value '{1}'".format(rv.lang, rv.value_or_uri)
def test_migrate_dataset_in_group(self):
condition = Package.id == ECB_WEB_SERVICE_PACKAGE_ID
ecb_web_service_package = find_any_in_database(TEST_CONFIG_FILE_PATH,
condition, Package)[0]
controlled_vocabulary = ControlledVocabulary()
datasets_migration_manager.migrate_package_to_virtuoso(
config_file_path=TEST_CONFIG_FILE_PATH,
package=ecb_web_service_package,
controlled_vocabulary=controlled_vocabulary)
dataset = DatasetDcatApOp(DATASET_URI_PREFIX + "ecb-web-service",
graph_name=DCATAPOP_PRIVATE_GRAPH_NAME)
result = dataset.get_description_from_ts()
assert result is True
def test_get_description_from_ts(self):
self.test_ingestion_files()
dataset_1 = DatasetDcatApOp(TRANSLATION_MEMORY_V_1_2)
dataset_2 = DatasetDcatApOp(TRANSLATION_MEMORY_V_3)
private_dataset = DatasetDcatApOp(
TRANSLATION_MEMORY_V_4,
privacy_state=PRIVACY_STATE_PRIVATE,
graph_name=DCATAPOP_PRIVATE_GRAPH_NAME)
description_dataset_1 = dataset_1.get_description_from_ts()
assert description_dataset_1 is True
description_dataset_2 = dataset_2.get_description_from_ts()
assert description_dataset_2 is True
private_dataset_description = private_dataset.get_description_from_ts(
) # type: DatasetDcatApOp
assert private_dataset_description is not None
assert private_dataset_description.schema.graph_name is DCATAPOP_PRIVATE_GRAPH_NAME
ckan_name_dataset_1 = dataset_1.schema.ckanName_dcatapop[
'0'].value_or_uri
assert ckan_name_dataset_1 is not None
ckan_name_dataset_2 = dataset_2.schema.ckanName_dcatapop[
'0'].value_or_uri
assert ckan_name_dataset_2 is not None
ckan_name_private_dataset = private_dataset.schema.ckanName_dcatapop[
'0'].value_or_uri
assert ckan_name_private_dataset is not None
keywords_dataset_1 = dataset_1.schema.keyword_dcat
# should log instead of print.
print "Dataset: " + TRANSLATION_MEMORY_V_1_2
print "CkanName is : {0} ".format(ckan_name_dataset_1)
print "keywords are :".format()
for k, rv in keywords_dataset_1.iteritems():
print "language '{0}' has the value '{1}'".format(
rv.lang, rv.value_or_uri)
def test_migrate_dataset_in_multiple_groups(self):
condition = Package.id == CONNECT_SPARQL_ENDPOINT_ID
ecb_web_service_package = find_any_in_database(TEST_CONFIG_FILE_PATH,
condition, Package)[0]
controlled_vocabulary = ControlledVocabulary()
datasets_migration_manager.migrate_package_to_virtuoso(
config_file_path=TEST_CONFIG_FILE_PATH,
package=ecb_web_service_package,
controlled_vocabulary=controlled_vocabulary)
dataset = DatasetDcatApOp(DATASET_URI_PREFIX +
"connect-sparql-endpoint",
graph_name=DCATAPOP_PRIVATE_GRAPH_NAME)
result = dataset.get_description_from_ts()
assert result is True
def test_migrate_most_viewed_package_to_virtuoso(self):
controlled_vocabulary = ControlledVocabulary()
condition = Package.id == TED_PACKAGE_ID
ted_package = find_any_in_database(TEST_CONFIG_FILE_PATH, condition,
Package)[0]
datasets_migration_manager.migrate_package_to_virtuoso(
config_file_path=TEST_CONFIG_FILE_PATH,
package=ted_package,
controlled_vocabulary=controlled_vocabulary)
dataset = DatasetDcatApOp(DATASET_URI_PREFIX + "ted-1")
result = dataset.get_description_from_ts()
assert result is True
def load_dataset(self, dataset_uri):
'''
Load dataset from Triple store or the cache
:return: type: DatasetDcatApOp
'''
dataset = None # type: DatasetDcatApOp
dataset_string = redis_cache.get_from_cache(dataset_uri,
pool=redis_cache.MISC_POOL)
if dataset_string:
dataset = pickle.loads(dataset_string)
log.info(
'[Dataset] [LOAD from cache] [URI:<{0}>]'.format(dataset_uri))
if not dataset or not dataset.schema:
dataset = DatasetDcatApOp(dataset_uri)
loaded_from_public = dataset.get_description_from_ts()
if not loaded_from_public:
dataset.set_state_as_private()
loaded_from_private = dataset.get_description_from_ts()
log.info("[Dataset] [Load from private] [URI:<{0}>]".format(
dataset_uri))
return dataset
def test_validation(self):
ds = DatasetDcatApOp(
"http://data.europa.eu/88u/dataset/dgt-translation-memory-V1-2")
if ds.get_description_from_ts():
# must have one ckan name,
validation_result = True
# ds.schema.theme_dcat['1'] = ResourceValue("New CKAN")
validator = ValidationSchema(ds.schema,
ds.schema.get_schema_type())
report = validator.validate()
for result in report:
validation_result = False if result.get(
"result") == ValidationTypeResult.error else True
if not validation_result:
break
self.assertTrue(validation_result,
" Test validation of validation failed")
pass
def test_must_have_one(self):
ds = DatasetDcatApOp(
"http://data.europa.eu/88u/dataset/dgt-translation-memory-V1-2")
if ds.get_description_from_ts():
# must have one ckan name,
validation_error = False
ds.schema.ckanName_dcatapop['1'] = ResourceValue("New CKAN")
validator = ValidationSchema(ds.schema,
ds.schema.get_schema_type())
report = validator.validate()
for result in report:
if result.get(
"property") == "ckanName_dcatapop" and result.get(
"constraint") == "card_1..1":
validation_resul = False if result.get(
"result") == ValidationTypeResult.error else True
self.assertTrue(not validation_resul,
" Test validation of must_have_one failed")