Ejemplo n.º 1
0
    def _validate_concept(self, json_concept, conceptscheme_id):
        from atramhasis.validators import Concept as ConceptSchema, concept_schema_validator

        concept_schema = ConceptSchema(validator=concept_schema_validator).bind(
            request=self.request, conceptscheme_id=conceptscheme_id
        )
        try:
            return concept_schema.deserialize(json_concept)
        except colander.Invalid as e:
            raise ValidationError("Concept could not be validated", e.asdict())
Ejemplo n.º 2
0
    def _validate_concept(self, json_concept, conceptscheme_id):
        from atramhasis.validators import (Concept as ConceptSchema,
                                           concept_schema_validator)

        concept_schema = ConceptSchema(
            validator=concept_schema_validator).bind(
                request=self.request, conceptscheme_id=conceptscheme_id)
        try:
            return concept_schema.deserialize(json_concept)
        except colander.Invalid as e:
            raise ValidationError('Concept could not be validated', e.asdict())
Ejemplo n.º 3
0
 def setUp(self):
     self.config = testing.setUp()
     self.request = testing.DummyRequest()
     self.request.db = db(self.request)
     self.concept_schema = ConceptSchema(
         validator=concept_schema_validator
     ).bind(
         request=self.request,
         conceptscheme_id=1
     )
     self.language = LanguageTag(
         validator=languagetag_validator
     ).bind(
         request=self.request,
         new=True
     )
     self.json_concept = {
         "narrower": [{"id": 8}, {"id": 7}, {"id": 9}],
         "label": "Belgium",
         "type": "concept",
         "id": 4,
         "broader": [{"id": 2}],
         "related": [{"id": 5}],
         "labels": [{
                        "label": "Belgium",
                        "type": "prefLabel",
                        "language": "en"
                    }],
         "notes": [{
                       "note": "een notitie",
                       "type": "note",
                       "language": "nl"
                   }],
         "member_of": [{"id": 666}]
     }
     self.json_collection = {
         "id": 0,
         "labels": [{
                        "language": "nl-BE",
                        "label": "Stijlen en culturen",
                        "type": "prefLabel"
                    }],
         "type": "collection",
         "label": "Stijlen en culturen",
         "members": [{"id": 61}, {"id": 60}],
         "notes": [{
                       "note": "een notitie",
                       "type": "note",
                       "language": "nl"
                   }],
         "member_of": [{"id": 666}]
     }
Ejemplo n.º 4
0
 def setUp(self):
     self.config = testing.setUp()
     self.request = testing.DummyRequest()
     self.request.db = db(self.request)
     self.concept_schema = ConceptSchema(
         validator=concept_schema_validator
     ).bind(
         request=self.request,
         conceptscheme_id=1
     )
     self.json_concept = {
         "narrower": [8, 7, 9],
         "label": "Belgium",
         "type": "concept",
         "id": 4,
         "broader": [2],
         "related": [5],
         "labels": [{
                        "label": "Belgium",
                        "type": "prefLabel",
                        "language": "en"
                    }],
         "notes": [{
                       "note": "een notitie",
                       "type": "note",
                       "language": "nl"
                   }],
         "member_of": [666]
     }
     self.json_collection = {
         "id": 0,
         "labels": [{
                        "language": "nl",
                        "label": "Stijlen en culturen",
                        "type": "prefLabel"
                    }],
         "type": "collection",
         "label": "Stijlen en culturen",
         "members": [61, 60],
         "notes": [{
                       "note": "een notitie",
                       "type": "note",
                       "language": "nl"
                   }],
         "member_of": [666]
     }
Ejemplo n.º 5
0
class TestValidation(unittest.TestCase):
    def setUp(self):
        self.config = testing.setUp()
        self.request = testing.DummyRequest()
        session = session_maker()
        self.request.data_managers = {'skos_manager': SkosManager(session),
                                      'conceptscheme_manager': ConceptSchemeManager(session),
                                      'languages_manager': LanguagesManager(session)}
        self.concept_schema = ConceptSchema(
            validator=concept_schema_validator
        ).bind(
            request=self.request,
            conceptscheme_id=1
        )
        self.language = LanguageTag(
            validator=languagetag_validator
        ).bind(
            request=self.request,
            new=True
        )
        self.conceptscheme_schema = ConceptSchemeSchema(
            validator=conceptscheme_schema_validator
        ).bind(
            request=self.request
        )
        self.json_concept = {
            "narrower": [{"id": 8}, {"id": 7}, {"id": 9}],
            "label": "Belgium",
            "type": "concept",
            "id": 4,
            "broader": [{"id": 2}],
            "related": [{"id": 5}],
            "labels": [{
                "label": "Belgium",
                "type": "prefLabel",
                "language": "en"
            }],
            "notes": [{
                "note": "een notitie",
                "type": "note",
                "language": "nl"
            }],
            "sources": [{
                "citation": "Van Daele K. 2014"
            }],
            "member_of": [{"id": 666}]
        }
        self.json_collection = {
            "id": 0,
            "labels": [{
                "language": "nl-BE",
                "label": "Stijlen en culturen",
                "type": "prefLabel"
            }],
            "type": "collection",
            "label": "Stijlen en culturen",
            "members": [{"id": 61}, {"id": 60}],
            "notes": [{
                "note": "een notitie",
                "type": "note",
                "language": "nl"
            }],
            "member_of": [{"id": 666}]
        }
        self.json_conceptscheme = {
            "labels": [{
                "language": "nl-BE",
                "label": "Stijlen en culturen",
                "type": "prefLabel"
            }],
            "label": "Stijlen en culturen",
            "notes": [{
                "note": "een notitie",
                "type": "note",
                "language": "nl"
            }],
            "sources": [{
                "citation": "Van Daele K. 2014"
            }]
        }

    def tearDown(self):
        testing.tearDown()

    def test_validation_conceptscheme(self):
        validated_conceptscheme = self.conceptscheme_schema.deserialize(self.json_conceptscheme)
        self.assertIsNotNone(validated_conceptscheme)
        self.assertEqual(1, len(validated_conceptscheme['labels']))
        self.assertEqual(1, len(validated_conceptscheme['notes']))
        self.assertEqual(1, len(validated_conceptscheme['sources']))

    def test_invalid_conceptscheme(self):
        self.json_conceptscheme.pop('labels')
        self.assertRaises(ValidationError, self.conceptscheme_schema.deserialize, self.json_conceptscheme)

    def test_validation_concept(self):
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_concept)
        self.assertEqual(1, len(validated_concept['labels']))
        self.assertEqual(1, len(validated_concept['notes']))
        self.assertEqual(1, len(validated_concept['sources']))
        self.assertEqual(3, len(validated_concept['narrower']))
        self.assertEqual(1, len(validated_concept['broader']))
        self.assertEqual(1, len(validated_concept['related']))
        self.assertEqual(1, len(validated_concept['member_of']))

    def test_max_preflabels_2_en(self):
        self.json_concept['labels'].append({
            "label": "B",
            "type": "prefLabel",
            "language": "en"
        })
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn({'labels': 'Only one prefLabel per language allowed.'}, error.errors)

    def test_max_preflabels_1_en_1_nl(self):
        self.json_concept['labels'].append({
            "label": "B",
            "type": "prefLabel",
            "language": "nl"
        })
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_concept)

    def test_related_concept_type_concept(self):
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_concept)

    def test_related_concept_type_collection(self):
        self.json_concept['related'].append({"id": 666})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn({'related': 'A narrower, broader or related concept'
                                  ' should always be a concept, not a collection'}, error.errors)

    def test_collection_with_related(self):
        # Collections can not have related relations
        self.json_collection['related'] = []
        self.json_collection['related'].append({"id": 2})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_collection)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn({'related': 'Only concepts can have narrower/broader/related relations'}, error.errors)

    def test_narrower_concept_type_concept(self):
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_concept)

    def test_narrower_concept_type_collection(self):
        self.json_concept['narrower'].append({"id": 666})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn({'narrower': 'A narrower, broader or related concept'
                                   ' should always be a concept, not a collection'}, error.errors)

    def test_collection_with_narrower(self):
        # Collections can not have narrower relations
        self.json_collection['narrower'] = []
        self.json_collection['narrower'].append({"id": 2})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_collection)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn({'narrower': 'Only concepts can have narrower/broader/related relations'}, error.errors)

    def test_broader_concept_type_concept(self):
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_concept)

    def test_broader_concept_type_collection(self):
        self.json_concept['broader'].append({"id": 666})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn({'broader': 'A narrower, broader or related concept should always be'
                                  ' a concept, not a collection'}, error.errors)

    def test_collection_with_broader(self):
        # Collections can not have broader relations
        self.json_collection['broader'] = []
        self.json_collection['broader'].append({"id": 2})
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_collection)
        except ValidationError:
            error_raised = True
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)

    def test_related_concept_different_conceptscheme(self):
        self.json_concept['related'].append({"id": 777})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn({'related': 'Concept not found, check concept_id. Please be aware members'
                                  ' should be within one scheme'}, error.errors)

    def test_narrower_concept_different_conceptscheme(self):
        self.json_concept['narrower'].append({"id": 777})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn({'narrower': 'Concept not found, check concept_id. Please be aware members'
                                   ' should be within one scheme'}, error.errors)

    def test_narrower_concept_to_self(self):
        self.json_concept['narrower'].append({"id": 4})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn({'narrower': 'A concept or collection cannot be related to itself'}, error.errors)

    def test_broader_concept_different_conceptscheme(self):
        self.json_concept['broader'].append({"id": 777})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn({'broader': 'Concept not found, check concept_id. Please be aware members'
                                  ' should be within one scheme'}, error.errors)

    def test_broader_concept_hierarchy(self):
        self.json_concept['broader'].append({"id": 14})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn({'broader': 'The broader concept of a concept must not itself '
                                  'be a narrower concept of the concept being edited.'}, error.errors)

    def test_broader_concept_hierarchy_no_narrower(self):
        self.json_concept['broader'].append({"id": 8})
        self.json_concept['narrower'] = []
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_concept)

    def test_narrower_concept_hierarchy(self):
        self.json_concept['narrower'].append({"id": 1})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn({'narrower': 'The narrower concept of a concept must not itself '
                                   'be a broader concept of the concept being edited.'}, error.errors)

    def test_narrower_concept_hierarchy_no_broader(self):
        self.json_concept['narrower'].append({"id": 1})
        self.json_concept['broader'] = []
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_concept)

    def test_validation_collection(self):
        error_raised = False
        validated_collection = None
        try:
            validated_collection = self.concept_schema.deserialize(self.json_collection)
        except ValidationError as e:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_collection)
        self.assertEqual(2, len(validated_collection['members']))
        self.assertEqual(1, len(validated_collection['labels']))
        self.assertEqual(1, len(validated_collection['notes']))

    def test_member_concept_different_conceptscheme(self):
        error_raised = False
        error = None
        validated_collection = None
        self.json_collection['members'].append({"id": 777})
        try:
            validated_collection = self.concept_schema.deserialize(self.json_collection)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_collection)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn({'members': 'Concept not found, check concept_id. Please be aware members'
                                  ' should be within one scheme'}, error.errors)

    def test_label_type(self):
        error_raised = False
        validated_concept = None
        self.json_concept['labels'].append({
            "label": "Belgium",
            "type": "altLabel",
            "language": "en"
        })
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_concept)

    def test_label_type_invalid(self):
        error_raised = False
        error = None
        validated_concept = None
        self.json_concept['labels'].append({
            "label": "Belgium",
            "type": "testLabelInvalid",
            "language": "en"
        })
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn({'labels': 'Invalid labeltype.'}, error.errors)

    def test_label_language_invalid(self):
        error_raised = False
        error = None
        validated_concept = None
        self.json_concept['labels'].append({
            "label": "Belgium",
            "type": "altLabel",
            "language": "eng"
        })
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn({'labels': 'Invalid language tag: Unknown code \'eng\', Missing language tag in \'eng\'.'},
                      error.errors)

    def test_label_language_missing(self):
        error_raised = False
        validated_concept = None
        self.json_concept['labels'].append({
            "label": "Belgium",
            "type": "altLabel",
            "language": "af"
        })
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_concept)

    def test_label_invalid(self):
        error_raised = False
        error = None
        validated_concept = None
        self.json_concept['labels'].append({
            "note": "Belgium",
            "type": "altLabel",
            "language": "en"
        })
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except colander.Invalid as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, colander.Invalid))

    def test_note_invalid(self):
        error_raised = False
        error = None
        validated_concept = None
        self.json_concept['notes'].append({
            "label": "een notitie",
            "type": 5,
            "language": "nl"
        })
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except colander.Invalid as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, colander.Invalid))

    def test_memberof_concept_type_collection(self):
        # A Collection/Concept can be a member_of a Collection
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_concept)

    def test_memberof_concept_type_concept(self):
        # Nothing can be a member_of a Concept
        self.json_concept['member_of'].append({"id": 2})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn({'member_of': 'A member_of parent should always be a collection'}, error.errors)

    def test_members_collection_unique(self):
        # A Collection is a Set (every element of the Collection should be unique).
        self.json_collection['members'].append({"id": 61})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_collection)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn({'members': 'All members of a collection should be unique.'}, error.errors)

    def test_concept_members(self):
        # A Concept does not have members.
        self.json_concept['members'] = []
        self.json_concept['members'].append({"id": 2})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn({'members': 'Only collections can have members.'}, error.errors)

    def test_memberof_concept_hierarchy_simple(self):
        # The hierarchy should not contain loops
        self.json_collection['members'].append({"id": 666})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_collection)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn({'member_of': 'The parent member_of collection of a concept must not itself'
                                    ' be a member of the concept being edited.'}, error.errors)

    def test_memberof_concept_hierarchy_deep(self):
        # The hierarchy should not contain loops
        self.json_collection['members'].append({"id": 62})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_collection)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn({'member_of': 'The parent member_of collection of a concept must not itself'
                                    ' be a member of the concept being edited.'}, error.errors)

    def test_members_concept_hierarchy_simple(self):
        # The hierarchy should not contain loops
        self.json_collection['member_of'].append({"id": 61})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_collection)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn({'members': 'The item of a members collection must not itself be a parent of'
                                  ' the concept/collection being edited.'}, error.errors)

    def test_members_concept_hierarchy_deep(self):
        # The hierarchy should not contain loops
        self.json_collection['member_of'].append({"id": 667})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_collection)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn({'members': 'The item of a members collection must not itself be a parent of'
                                  ' the concept/collection being edited.'}, error.errors)

    def test_min_labels_rule(self):
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_concept)

    def test_min_labels_rule_empty_labels(self):
        error_raised = False
        validated_concept = None
        self.json_concept['labels'] = []
        error = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertIsNotNone(error)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn({'labels': 'At least one label is necessary'}, error.errors)

    def test_min_labels_rule_no_labels(self):
        error_raised = False
        validated_concept = None
        json_concept = {
            "narrower": [{"id": 8}, {"id": 7}, {"id": 9}],
            "type": "concept",
            "id": 4,
            "broader": [{"id": 2}],
            "related": [{"id": 5}],
            "notes": [{
                "note": "een notitie",
                "type": "note",
                "language": "nl"
            }],
            "member_of": [{"id": 666}]
        }
        error = None
        try:
            validated_concept = self.concept_schema.deserialize(json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertIsNotNone(error)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn({'labels': 'At least one label is necessary'}, error.errors)

    def test_concept_matches_rule(self):
        error_raised = False
        validated_concept = None
        json_concept = {
            "type": "collection",
            "labels": [{
                "language": "nl",
                "label": "Stijlen en culturen",
                "type": "prefLabel"
            }],
            "id": 4,
            "members": [{"id": 666}],
            "matches": {"exactMatch": ["urn:sample:666"], "broadMatch": ["urn:somewhere:93"]}
        }
        error = None
        try:
            validated_concept = self.concept_schema.deserialize(json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertIsNotNone(error)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn({'matches': 'Only concepts can have matches'}, error.errors)

    def test_concept_matches_unique_rule(self):
        error_raised = False
        validated_concept = None
        json_concept = {
            "type": "concept",
            "labels": [{
                "language": "nl",
                "label": "Stijlen en culturen",
                "type": "prefLabel"
            }],
            "id": 4,
            "member_of": [{"id": 666}],
            "matches": {"exact": ["urn:sample:666"], "broad": ["urn:sample:666"]}
        }
        error = None
        try:
            validated_concept = self.concept_schema.deserialize(json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertIsNotNone(error)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn({'matches': 'All matches of a concept should be unique.'}, error.errors)

    def test_concept_matches_unique_rule_pass(self):
        error_raised = False
        validated_concept = None
        json_concept = {
            "type": "concept",
            "labels": [{
                "language": "nl",
                "label": "Stijlen en culturen",
                "type": "prefLabel"
            }],
            "id": 4,
            "member_of": [{"id": 666}],
            "matches": {"exactMatch": ["urn:sample:666"], "broadMatch": ["urn:sample:93"]}
        }
        try:
            validated_concept = self.concept_schema.deserialize(json_concept)
        except ValidationError:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_concept)

    def test_languages_pass(self):
        error_raised = False
        validated_language = None
        json_language = {
            "id": "af",
            "name": "Afrikaans"
        }
        try:
            validated_language = self.language.deserialize(json_language)
        except ValidationError:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_language)

    def test_languages_duplicate(self):
        error_raised = False
        validated_language = None
        json_language = {
            "id": "en",
            "name": "English"
        }
        error = None
        try:
            validated_language = self.language.deserialize(json_language)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_language)
        self.assertIsNotNone(error)
        self.assertIn({'id': 'Duplicate language tag: en'}, error.errors)

    def test_languages_edit_not_raise_duplicate(self):
        error_raised = False
        validated_language = None
        json_language = {
            "id": "en",
            "name": "English"
        }
        language = LanguageTag(
            validator=languagetag_validator
        ).bind(
            request=self.request,
            new=False
        )
        try:
            validated_language = language.deserialize(json_language)
        except ValidationError:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_language)

    def test_languages_invalid(self):
        error_raised = False
        validated_language = None
        json_language = {
            "id": "flup",
            "name": "test"
        }
        error = None
        try:
            validated_language = self.language.deserialize(json_language)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_language)
        self.assertIsNotNone(error)
        self.assertIn({"id": "Invalid language tag: Unknown code 'flup', Missing language tag in 'flup'."},
                      error.errors)

    def test_subordinate_arrays(self):
        error_raised = False
        validated_json = None
        self.json_concept['subordinate_arrays'] = [{"id": 667}]
        try:
            validated_json = self.concept_schema.deserialize(self.json_concept)
        except ValidationError:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_json)

    def test_subordinate_arrays_no_concept(self):
        error_raised = False
        validated_json = None
        error = None
        self.json_collection['subordinate_arrays'] = [{"id": 666}]
        try:
            validated_json = self.concept_schema.deserialize(self.json_collection)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_json)
        self.assertIsNotNone(error)
        self.assertIn({'subordinate_arrays': 'Only concept can have subordinate arrays.'}, error.errors)

    def test_subordinate_arrays_no_collection(self):
        error_raised = False
        validated_json = None
        error = None
        self.json_concept['subordinate_arrays'] = [{"id": 7}]
        try:
            validated_json = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_json)
        self.assertIsNotNone(error)
        self.assertIn({'subordinate_arrays': 'A subordinate array should always be a collection'}, error.errors)

    def test_subordinate_arrays_hierarchy(self):
        error_raised = False
        validated_json = None
        error = None
        self.json_concept['subordinate_arrays'] = [{"id": 666}]
        try:
            validated_json = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_json)
        self.assertIsNotNone(error)
        self.assertIn({
            'subordinate_arrays': 'The subordinate_array collection of a concept must not itself be a parent of the concept being edited.'},
            error.errors)

    def test_superordinates(self):
        error_raised = False
        validated_json = None
        self.json_collection['superordinates'] = [{"id": 7}]
        try:
            validated_json = self.concept_schema.deserialize(self.json_collection)
        except ValidationError:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_json)

    def test_superordinates_no_concept(self):
        error_raised = False
        validated_json = None
        error = None
        self.json_collection['superordinates'] = [{"id": 666}]
        try:
            validated_json = self.concept_schema.deserialize(self.json_collection)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_json)
        self.assertIsNotNone(error)
        self.assertIn({'superordinates': 'A superordinate should always be a concept'}, error.errors)

    def test_superordinates_no_collection(self):
        error_raised = False
        validated_json = None
        error = None
        self.json_concept['superordinates'] = [{"id": 7}]
        try:
            validated_json = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_json)
        self.assertIsNotNone(error)
        self.assertIn({'superordinates': 'Only collection can have superordinates.'}, error.errors)

    def test_superordinates_hierarchy(self):
        error_raised = False
        validated_json = None
        error = None
        self.json_collection['superordinates'] = [{"id": 61}]
        try:
            validated_json = self.concept_schema.deserialize(self.json_collection)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_json)
        self.assertIsNotNone(error)
        self.assertIn({
            'superordinates': 'The superordinates of a collection must not itself be a member of the collection being edited.'},
            error.errors)

    def test_html_in_notes(self):
        json_concept = {
            "narrower": [{"id": 8}, {"id": 7}, {"id": 9}],
            "label": "Belgium",
            "type": "concept",
            "id": 4,
            "broader": [{"id": 2}],
            "related": [{"id": 5}],
            "labels": [{
                "label": "Belgium",
                "type": "prefLabel",
                "language": "en"
            }],
            "notes": [{
                "note": "een <strong><h2>notitie</h2></strong>",
                "type": "note",
                "language": "nl"
            }],
            "sources": [{
                "citation": "Van Daele K. 2014"
            }],
            "member_of": [{"id": 666}]
        }
        validated_json = self.concept_schema.deserialize(json_concept)
        note = validated_json['notes'][0]
        self.assertEqual("een <strong>notitie</strong>", note['note'])

    def test_html_in_sources(self):
        json_concept = {
            "narrower": [{"id": 8}, {"id": 7}, {"id": 9}],
            "label": "Belgium",
            "type": "concept",
            "id": 4,
            "broader": [{"id": 2}],
            "related": [{"id": 5}],
            "labels": [{
                "label": "Belgium",
                "type": "prefLabel",
                "language": "en"
            }],
            "notes": [{
                "note": "een notitie",
                "type": "note",
                "language": "nl"
            }],
            "sources": [{
                "citation": "Van Daele K. <strong><h2>2014</h2></strong>"
            }],
            "member_of": [{"id": 666}]
        }
        validated_json = self.concept_schema.deserialize(json_concept)
        source = validated_json['sources'][0]
        self.assertEqual("Van Daele K. <strong>2014</strong>", source['citation'])
Ejemplo n.º 6
0
 def setUp(self):
     self.config = testing.setUp()
     self.request = testing.DummyRequest()
     session = session_maker()
     self.request.data_managers = {'skos_manager': SkosManager(session),
                                   'conceptscheme_manager': ConceptSchemeManager(session),
                                   'languages_manager': LanguagesManager(session)}
     self.concept_schema = ConceptSchema(
         validator=concept_schema_validator
     ).bind(
         request=self.request,
         conceptscheme_id=1
     )
     self.language = LanguageTag(
         validator=languagetag_validator
     ).bind(
         request=self.request,
         new=True
     )
     self.conceptscheme_schema = ConceptSchemeSchema(
         validator=conceptscheme_schema_validator
     ).bind(
         request=self.request
     )
     self.json_concept = {
         "narrower": [{"id": 8}, {"id": 7}, {"id": 9}],
         "label": "Belgium",
         "type": "concept",
         "id": 4,
         "broader": [{"id": 2}],
         "related": [{"id": 5}],
         "labels": [{
             "label": "Belgium",
             "type": "prefLabel",
             "language": "en"
         }],
         "notes": [{
             "note": "een notitie",
             "type": "note",
             "language": "nl"
         }],
         "sources": [{
             "citation": "Van Daele K. 2014"
         }],
         "member_of": [{"id": 666}]
     }
     self.json_collection = {
         "id": 0,
         "labels": [{
             "language": "nl-BE",
             "label": "Stijlen en culturen",
             "type": "prefLabel"
         }],
         "type": "collection",
         "label": "Stijlen en culturen",
         "members": [{"id": 61}, {"id": 60}],
         "notes": [{
             "note": "een notitie",
             "type": "note",
             "language": "nl"
         }],
         "member_of": [{"id": 666}]
     }
     self.json_conceptscheme = {
         "labels": [{
             "language": "nl-BE",
             "label": "Stijlen en culturen",
             "type": "prefLabel"
         }],
         "label": "Stijlen en culturen",
         "notes": [{
             "note": "een notitie",
             "type": "note",
             "language": "nl"
         }],
         "sources": [{
             "citation": "Van Daele K. 2014"
         }]
     }
Ejemplo n.º 7
0
class TestValidation(unittest.TestCase):
    def setUp(self):
        self.config = testing.setUp()
        self.request = testing.DummyRequest()
        self.request.db = db(self.request)
        self.concept_schema = ConceptSchema(
            validator=concept_schema_validator
        ).bind(
            request=self.request,
            conceptscheme_id=1
        )
        self.json_concept = {
            "narrower": [8, 7, 9],
            "label": "Belgium",
            "type": "concept",
            "id": 4,
            "broader": [2],
            "related": [5],
            "labels": [{
                           "label": "Belgium",
                           "type": "prefLabel",
                           "language": "en"
                       }],
            "notes": [{
                          "note": "een notitie",
                          "type": "note",
                          "language": "nl"
                      }],
            "member_of": [666]
        }
        self.json_collection = {
            "id": 0,
            "labels": [{
                           "language": "nl",
                           "label": "Stijlen en culturen",
                           "type": "prefLabel"
                       }],
            "type": "collection",
            "label": "Stijlen en culturen",
            "members": [61, 60],
            "notes": [{
                          "note": "een notitie",
                          "type": "note",
                          "language": "nl"
                      }],
            "member_of": [666]
        }

    def tearDown(self):
        testing.tearDown()

    def test_validation_concept(self):
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_concept)
        self.assertEqual(1, len(validated_concept['labels']))
        self.assertEqual(1, len(validated_concept['notes']))
        self.assertEqual(3, len(validated_concept['narrower']))
        self.assertEqual(1, len(validated_concept['broader']))
        self.assertEqual(1, len(validated_concept['related']))
        self.assertEqual(1, len(validated_concept['member_of']))

    def test_max_preflabels_2_en(self):
        self.json_concept['labels'].append({
            "label": "B",
            "type": "prefLabel",
            "language": "en"
        })
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)

    def test_max_preflabels_1_en_1_nl(self):
        self.json_concept['labels'].append({
            "label": "B",
            "type": "prefLabel",
            "language": "nl"
        })
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_concept)

    def test_related_concept_type_concept(self):
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_concept)

    def test_related_concept_type_collection(self):
        self.json_concept['related'].append(666)
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)

    def test_collection_with_related(self):
        # Collections can not have related relations
        self.json_collection['related'] = []
        self.json_collection['related'].append(2)
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_collection)
        except ValidationError as e:
            error_raised = True
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)

    def test_narrower_concept_type_concept(self):
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_concept)

    def test_narrower_concept_type_collection(self):
        self.json_concept['narrower'].append(666)
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)

    def test_collection_with_narrower(self):
        # Collections can not have narrower relations
        self.json_collection['narrower'] = []
        self.json_collection['narrower'].append(2)
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_collection)
        except ValidationError as e:
            error_raised = True
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)

    def test_broader_concept_type_concept(self):
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_concept)

    def test_broader_concept_type_collection(self):
        self.json_concept['broader'].append(666)
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)

    def test_collection_with_broader(self):
        # Collections can not have broader relations
        self.json_collection['broader'] = []
        self.json_collection['broader'].append(2)
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_collection)
        except ValidationError as e:
            error_raised = True
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)

    def test_related_concept_different_conceptscheme(self):
        self.json_concept['related'].append(777)
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)

    def test_narrower_concept_different_conceptscheme(self):
        self.json_concept['narrower'].append(777)
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)

    def test_broader_concept_different_conceptscheme(self):
        self.json_concept['broader'].append(777)
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)

    def test_broader_concept_hierarchy(self):
        self.json_concept['broader'].append(14)
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)

    def test_broader_concept_hierarchy_no_narrower(self):
        self.json_concept['broader'].append(8)
        self.json_concept['narrower'] = []
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_concept)

    def test_narrower_concept_hierarchy(self):
        self.json_concept['narrower'].append(1)
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)

    def test_narrower_concept_hierarchy_no_broader(self):
        self.json_concept['narrower'].append(1)
        self.json_concept['broader'] = []
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_concept)

    def test_validation_collection(self):
        error_raised = False
        validated_collection = None
        try:
            validated_collection = self.concept_schema.deserialize(self.json_collection)
        except ValidationError as e:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_collection)
        self.assertEqual(2, len(validated_collection['members']))
        self.assertEqual(1, len(validated_collection['labels']))
        self.assertEqual(1, len(validated_collection['notes']))

    def test_member_concept_different_conceptscheme(self):
        error_raised = False
        validated_collection = None
        self.json_collection['members'].append(777)
        try:
            validated_collection = self.concept_schema.deserialize(self.json_collection)
        except ValidationError as e:
            error_raised = True
        self.assertTrue(error_raised)
        self.assertIsNone(validated_collection)

    def test_label_type(self):
        error_raised = False
        validated_concept = None
        self.json_concept['labels'].append({
            "label": "Belgium",
            "type": "altLabel",
            "language": "en"
        })
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_concept)

    def test_label_type_invalid(self):
        error_raised = False
        validated_concept = None
        self.json_concept['labels'].append({
            "label": "Belgium",
            "type": "testLabelInvalid",
            "language": "en"
        })
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)

    def test_label_language_invalid(self):
        error_raised = False
        validated_concept = None
        self.json_concept['labels'].append({
            "label": "Belgium",
            "type": "altLabel",
            "language": "en-FR"
        })
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)

    def test_label_invalid(self):
        error_raised = False
        validated_concept = None
        self.json_concept['labels'].append({
            "note": "Belgium",
            "type": "altLabel",
            "language": "en"
        })
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except colander.Invalid as e:
            error_raised = True
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)

    def test_note_invalid(self):
        error_raised = False
        validated_concept = None
        self.json_concept['notes'].append({
            "label": "een notitie",
            "type": "note",
            "language": "nl"
        })
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except colander.Invalid as e:
            error_raised = True
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)

    def test_memberof_concept_type_collection(self):
        #A Collection/Concept can be a member_of a Collection
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_concept)

    def test_memberof_concept_type_concept(self):
        # Nothing can be a member_of a Concept
        self.json_concept['member_of'].append(2)
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)

    def test_members_collection_unique(self):
        # A Collection is a Set (every element of the Collection should be unique).
        self.json_collection['members'].append(61)
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_collection)
        except ValidationError as e:
            error_raised = True
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)

    def test_concept_members(self):
        # A Concept does not have members.
        self.json_concept['members'] = []
        self.json_concept['members'].append(2)
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)

    def test_memberof_concept_hierarchy_simple(self):
        # The hierarchy should not contain loops
        self.json_collection['members'].append(666)
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_collection)
        except ValidationError as e:
            error_raised = True
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)

    def test_memberof_concept_hierarchy_deep(self):
        # The hierarchy should not contain loops
        self.json_collection['members'].append(62)
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_collection)
        except ValidationError as e:
            error_raised = True
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)

    def test_members_concept_hierarchy_simple(self):
        # The hierarchy should not contain loops
        self.json_collection['member_of'].append(61)
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_collection)
        except ValidationError as e:
            error_raised = True
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)

    def test_members_concept_hierarchy_deep(self):
        # The hierarchy should not contain loops
        self.json_collection['member_of'].append(667)
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(self.json_collection)
        except ValidationError as e:
            error_raised = True
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
Ejemplo n.º 8
0
 def setUp(self):
     self.config = testing.setUp()
     self.request = testing.DummyRequest()
     session = session_maker()
     self.request.data_managers = {
         'skos_manager': SkosManager(session),
         'conceptscheme_manager': ConceptSchemeManager(session),
         'languages_manager': LanguagesManager(session)
     }
     self.concept_schema = ConceptSchema(
         validator=concept_schema_validator).bind(request=self.request,
                                                  conceptscheme_id=1)
     self.language = LanguageTag(validator=languagetag_validator).bind(
         request=self.request, new=True)
     self.conceptscheme_schema = ConceptSchemeSchema(
         validator=conceptscheme_schema_validator).bind(
             request=self.request)
     self.json_concept = {
         "narrower": [{
             "id": 8
         }, {
             "id": 7
         }, {
             "id": 9
         }],
         "label": "Belgium",
         "type": "concept",
         "id": 4,
         "broader": [{
             "id": 2
         }],
         "related": [{
             "id": 5
         }],
         "labels": [{
             "label": "Belgium",
             "type": "prefLabel",
             "language": "en"
         }],
         "notes": [{
             "note": "een notitie",
             "type": "note",
             "language": "nl"
         }],
         "sources": [{
             "citation": "Van Daele K. 2014"
         }],
         "member_of": [{
             "id": 666
         }]
     }
     self.json_collection = {
         "id":
         0,
         "labels": [{
             "language": "nl-BE",
             "label": "Stijlen en culturen",
             "type": "prefLabel"
         }],
         "type":
         "collection",
         "label":
         "Stijlen en culturen",
         "members": [{
             "id": 61
         }, {
             "id": 60
         }],
         "notes": [{
             "note": "een notitie",
             "type": "note",
             "language": "nl"
         }],
         "member_of": [{
             "id": 666
         }]
     }
     self.json_conceptscheme = {
         "labels": [{
             "language": "nl-BE",
             "label": "Stijlen en culturen",
             "type": "prefLabel"
         }],
         "label":
         "Stijlen en culturen",
         "notes": [{
             "note": "een notitie",
             "type": "note",
             "language": "nl"
         }],
         "sources": [{
             "citation": "Van Daele K. 2014"
         }]
     }
Ejemplo n.º 9
0
class TestValidation(unittest.TestCase):
    def setUp(self):
        self.config = testing.setUp()
        self.request = testing.DummyRequest()
        session = session_maker()
        self.request.data_managers = {
            'skos_manager': SkosManager(session),
            'conceptscheme_manager': ConceptSchemeManager(session),
            'languages_manager': LanguagesManager(session)
        }
        self.concept_schema = ConceptSchema(
            validator=concept_schema_validator).bind(request=self.request,
                                                     conceptscheme_id=1)
        self.language = LanguageTag(validator=languagetag_validator).bind(
            request=self.request, new=True)
        self.conceptscheme_schema = ConceptSchemeSchema(
            validator=conceptscheme_schema_validator).bind(
                request=self.request)
        self.json_concept = {
            "narrower": [{
                "id": 8
            }, {
                "id": 7
            }, {
                "id": 9
            }],
            "label": "Belgium",
            "type": "concept",
            "id": 4,
            "broader": [{
                "id": 2
            }],
            "related": [{
                "id": 5
            }],
            "labels": [{
                "label": "Belgium",
                "type": "prefLabel",
                "language": "en"
            }],
            "notes": [{
                "note": "een notitie",
                "type": "note",
                "language": "nl"
            }],
            "sources": [{
                "citation": "Van Daele K. 2014"
            }],
            "member_of": [{
                "id": 666
            }]
        }
        self.json_collection = {
            "id":
            0,
            "labels": [{
                "language": "nl-BE",
                "label": "Stijlen en culturen",
                "type": "prefLabel"
            }],
            "type":
            "collection",
            "label":
            "Stijlen en culturen",
            "members": [{
                "id": 61
            }, {
                "id": 60
            }],
            "notes": [{
                "note": "een notitie",
                "type": "note",
                "language": "nl"
            }],
            "member_of": [{
                "id": 666
            }]
        }
        self.json_conceptscheme = {
            "labels": [{
                "language": "nl-BE",
                "label": "Stijlen en culturen",
                "type": "prefLabel"
            }],
            "label":
            "Stijlen en culturen",
            "notes": [{
                "note": "een notitie",
                "type": "note",
                "language": "nl"
            }],
            "sources": [{
                "citation": "Van Daele K. 2014"
            }]
        }

    def tearDown(self):
        testing.tearDown()

    def test_validation_conceptscheme(self):
        validated_conceptscheme = self.conceptscheme_schema.deserialize(
            self.json_conceptscheme)
        self.assertIsNotNone(validated_conceptscheme)
        self.assertEqual(1, len(validated_conceptscheme['labels']))
        self.assertEqual(1, len(validated_conceptscheme['notes']))
        self.assertEqual(1, len(validated_conceptscheme['sources']))

    def test_invalid_conceptscheme(self):
        self.json_conceptscheme.pop('labels')
        self.assertRaises(ValidationError,
                          self.conceptscheme_schema.deserialize,
                          self.json_conceptscheme)

    def test_validation_concept(self):
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_concept)
        except ValidationError:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_concept)
        self.assertEqual(1, len(validated_concept['labels']))
        self.assertEqual(1, len(validated_concept['notes']))
        self.assertEqual(1, len(validated_concept['sources']))
        self.assertEqual(3, len(validated_concept['narrower']))
        self.assertEqual(1, len(validated_concept['broader']))
        self.assertEqual(1, len(validated_concept['related']))
        self.assertEqual(1, len(validated_concept['member_of']))

    def test_max_preflabels_2_en(self):
        self.json_concept['labels'].append({
            "label": "B",
            "type": "prefLabel",
            "language": "en"
        })
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn({'labels': 'Only one prefLabel per language allowed.'},
                      error.errors)

    def test_max_preflabels_1_en_1_nl(self):
        self.json_concept['labels'].append({
            "label": "B",
            "type": "prefLabel",
            "language": "nl"
        })
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_concept)
        except ValidationError:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_concept)

    def test_related_concept_type_concept(self):
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_concept)
        except ValidationError:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_concept)

    def test_related_concept_type_collection(self):
        self.json_concept['related'].append({"id": 666})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn(
            {
                'related':
                'A narrower, broader or related concept'
                ' should always be a concept, not a collection'
            }, error.errors)

    def test_collection_with_related(self):
        # Collections can not have related relations
        self.json_collection['related'] = []
        self.json_collection['related'].append({"id": 2})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_collection)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn(
            {
                'related':
                'Only concepts can have narrower/broader/related relations'
            }, error.errors)

    def test_narrower_concept_type_concept(self):
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_concept)
        except ValidationError:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_concept)

    def test_narrower_concept_type_collection(self):
        self.json_concept['narrower'].append({"id": 666})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn(
            {
                'narrower':
                'A narrower, broader or related concept'
                ' should always be a concept, not a collection'
            }, error.errors)

    def test_collection_with_narrower(self):
        # Collections can not have narrower relations
        self.json_collection['narrower'] = []
        self.json_collection['narrower'].append({"id": 2})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_collection)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn(
            {
                'narrower':
                'Only concepts can have narrower/broader/related relations'
            }, error.errors)

    def test_broader_concept_type_concept(self):
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_concept)
        except ValidationError:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_concept)

    def test_broader_concept_type_collection(self):
        self.json_concept['broader'].append({"id": 666})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn(
            {
                'broader':
                'A narrower, broader or related concept should always be'
                ' a concept, not a collection'
            }, error.errors)

    def test_collection_with_broader(self):
        # Collections can not have broader relations
        self.json_collection['broader'] = []
        self.json_collection['broader'].append({"id": 2})
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_collection)
        except ValidationError:
            error_raised = True
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)

    def test_related_concept_different_conceptscheme(self):
        self.json_concept['related'].append({"id": 777})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn(
            {
                'related':
                'Concept not found, check concept_id. Please be aware members'
                ' should be within one scheme'
            }, error.errors)

    def test_narrower_concept_different_conceptscheme(self):
        self.json_concept['narrower'].append({"id": 777})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn(
            {
                'narrower':
                'Concept not found, check concept_id. Please be aware members'
                ' should be within one scheme'
            }, error.errors)

    def test_narrower_concept_to_self(self):
        self.json_concept['narrower'].append({"id": 4})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn(
            {
                'narrower':
                'A concept or collection cannot be related to itself'
            }, error.errors)

    def test_broader_concept_different_conceptscheme(self):
        self.json_concept['broader'].append({"id": 777})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn(
            {
                'broader':
                'Concept not found, check concept_id. Please be aware members'
                ' should be within one scheme'
            }, error.errors)

    def test_broader_concept_hierarchy(self):
        self.json_concept['broader'].append({"id": 14})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn(
            {
                'broader':
                'The broader concept of a concept must not itself '
                'be a narrower concept of the concept being edited.'
            }, error.errors)

    def test_broader_concept_hierarchy_no_narrower(self):
        self.json_concept['broader'].append({"id": 8})
        self.json_concept['narrower'] = []
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_concept)
        except ValidationError:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_concept)

    def test_narrower_concept_hierarchy(self):
        self.json_concept['narrower'].append({"id": 1})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn(
            {
                'narrower':
                'The narrower concept of a concept must not itself '
                'be a broader concept of the concept being edited.'
            }, error.errors)

    def test_narrower_concept_hierarchy_no_broader(self):
        self.json_concept['narrower'].append({"id": 1})
        self.json_concept['broader'] = []
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_concept)
        except ValidationError:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_concept)

    def test_validation_collection(self):
        error_raised = False
        validated_collection = None
        try:
            validated_collection = self.concept_schema.deserialize(
                self.json_collection)
        except ValidationError as e:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_collection)
        self.assertEqual(2, len(validated_collection['members']))
        self.assertEqual(1, len(validated_collection['labels']))
        self.assertEqual(1, len(validated_collection['notes']))

    def test_member_concept_different_conceptscheme(self):
        error_raised = False
        error = None
        validated_collection = None
        self.json_collection['members'].append({"id": 777})
        try:
            validated_collection = self.concept_schema.deserialize(
                self.json_collection)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_collection)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn(
            {
                'members':
                'Concept not found, check concept_id. Please be aware members'
                ' should be within one scheme'
            }, error.errors)

    def test_label_type(self):
        error_raised = False
        validated_concept = None
        self.json_concept['labels'].append({
            "label": "Belgium",
            "type": "altLabel",
            "language": "en"
        })
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_concept)
        except ValidationError:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_concept)

    def test_label_type_invalid(self):
        error_raised = False
        error = None
        validated_concept = None
        self.json_concept['labels'].append({
            "label": "Belgium",
            "type": "testLabelInvalid",
            "language": "en"
        })
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn({'labels': 'Invalid labeltype.'}, error.errors)

    def test_label_language_invalid(self):
        error_raised = False
        error = None
        validated_concept = None
        self.json_concept['labels'].append({
            "label": "Belgium",
            "type": "altLabel",
            "language": "eng"
        })
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn(
            {
                'labels':
                'Invalid language tag: Unknown code \'eng\', Missing language tag in \'eng\'.'
            }, error.errors)

    def test_label_language_missing(self):
        error_raised = False
        validated_concept = None
        self.json_concept['labels'].append({
            "label": "Belgium",
            "type": "altLabel",
            "language": "af"
        })
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_concept)
        except ValidationError as e:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_concept)

    def test_label_invalid(self):
        error_raised = False
        error = None
        validated_concept = None
        self.json_concept['labels'].append({
            "note": "Belgium",
            "type": "altLabel",
            "language": "en"
        })
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_concept)
        except colander.Invalid as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, colander.Invalid))

    def test_note_invalid(self):
        error_raised = False
        error = None
        validated_concept = None
        self.json_concept['notes'].append({
            "label": "een notitie",
            "type": 5,
            "language": "nl"
        })
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_concept)
        except colander.Invalid as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, colander.Invalid))

    def test_memberof_concept_type_collection(self):
        # A Collection/Concept can be a member_of a Collection
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_concept)
        except ValidationError:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_concept)

    def test_memberof_concept_type_concept(self):
        # Nothing can be a member_of a Concept
        self.json_concept['member_of'].append({"id": 2})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn(
            {'member_of': 'A member_of parent should always be a collection'},
            error.errors)

    def test_members_collection_unique(self):
        # A Collection is a Set (every element of the Collection should be unique).
        self.json_collection['members'].append({"id": 61})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_collection)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn(
            {'members': 'All members of a collection should be unique.'},
            error.errors)

    def test_concept_members(self):
        # A Concept does not have members.
        self.json_concept['members'] = []
        self.json_concept['members'].append({"id": 2})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn({'members': 'Only collections can have members.'},
                      error.errors)

    def test_memberof_concept_hierarchy_simple(self):
        # The hierarchy should not contain loops
        self.json_collection['members'].append({"id": 666})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_collection)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn(
            {
                'member_of':
                'The parent member_of collection of a concept must not itself'
                ' be a member of the concept being edited.'
            }, error.errors)

    def test_memberof_concept_hierarchy_deep(self):
        # The hierarchy should not contain loops
        self.json_collection['members'].append({"id": 62})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_collection)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn(
            {
                'member_of':
                'The parent member_of collection of a concept must not itself'
                ' be a member of the concept being edited.'
            }, error.errors)

    def test_members_concept_hierarchy_simple(self):
        # The hierarchy should not contain loops
        self.json_collection['member_of'].append({"id": 61})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_collection)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn(
            {
                'members':
                'The item of a members collection must not itself be a parent of'
                ' the concept/collection being edited.'
            }, error.errors)

    def test_members_concept_hierarchy_deep(self):
        # The hierarchy should not contain loops
        self.json_collection['member_of'].append({"id": 667})
        error_raised = False
        error = None
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_collection)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn(
            {
                'members':
                'The item of a members collection must not itself be a parent of'
                ' the concept/collection being edited.'
            }, error.errors)

    def test_min_labels_rule(self):
        error_raised = False
        validated_concept = None
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_concept)
        except ValidationError:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_concept)

    def test_min_labels_rule_empty_labels(self):
        error_raised = False
        validated_concept = None
        self.json_concept['labels'] = []
        error = None
        try:
            validated_concept = self.concept_schema.deserialize(
                self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertIsNotNone(error)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn({'labels': 'At least one label is necessary'},
                      error.errors)

    def test_min_labels_rule_no_labels(self):
        error_raised = False
        validated_concept = None
        json_concept = {
            "narrower": [{
                "id": 8
            }, {
                "id": 7
            }, {
                "id": 9
            }],
            "type": "concept",
            "id": 4,
            "broader": [{
                "id": 2
            }],
            "related": [{
                "id": 5
            }],
            "notes": [{
                "note": "een notitie",
                "type": "note",
                "language": "nl"
            }],
            "member_of": [{
                "id": 666
            }]
        }
        error = None
        try:
            validated_concept = self.concept_schema.deserialize(json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertIsNotNone(error)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn({'labels': 'At least one label is necessary'},
                      error.errors)

    def test_concept_matches_rule(self):
        error_raised = False
        validated_concept = None
        json_concept = {
            "type":
            "collection",
            "labels": [{
                "language": "nl",
                "label": "Stijlen en culturen",
                "type": "prefLabel"
            }],
            "id":
            4,
            "members": [{
                "id": 666
            }],
            "matches": {
                "exactMatch": ["urn:sample:666"],
                "broadMatch": ["urn:somewhere:93"]
            }
        }
        error = None
        try:
            validated_concept = self.concept_schema.deserialize(json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertIsNotNone(error)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn({'matches': 'Only concepts can have matches'},
                      error.errors)

    def test_concept_matches_unique_rule(self):
        error_raised = False
        validated_concept = None
        json_concept = {
            "type":
            "concept",
            "labels": [{
                "language": "nl",
                "label": "Stijlen en culturen",
                "type": "prefLabel"
            }],
            "id":
            4,
            "member_of": [{
                "id": 666
            }],
            "matches": {
                "exact": ["urn:sample:666"],
                "broad": ["urn:sample:666"]
            }
        }
        error = None
        try:
            validated_concept = self.concept_schema.deserialize(json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_concept)
        self.assertIsNotNone(error)
        self.assertTrue(isinstance(error, ValidationError))
        self.assertIn(
            {'matches': 'All matches of a concept should be unique.'},
            error.errors)

    def test_concept_matches_unique_rule_pass(self):
        error_raised = False
        validated_concept = None
        json_concept = {
            "type":
            "concept",
            "labels": [{
                "language": "nl",
                "label": "Stijlen en culturen",
                "type": "prefLabel"
            }],
            "id":
            4,
            "member_of": [{
                "id": 666
            }],
            "matches": {
                "exactMatch": ["urn:sample:666"],
                "broadMatch": ["urn:sample:93"]
            }
        }
        try:
            validated_concept = self.concept_schema.deserialize(json_concept)
        except ValidationError:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_concept)

    def test_languages_pass(self):
        error_raised = False
        validated_language = None
        json_language = {"id": "af", "name": "Afrikaans"}
        try:
            validated_language = self.language.deserialize(json_language)
        except ValidationError:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_language)

    def test_languages_duplicate(self):
        error_raised = False
        validated_language = None
        json_language = {"id": "en", "name": "English"}
        error = None
        try:
            validated_language = self.language.deserialize(json_language)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_language)
        self.assertIsNotNone(error)
        self.assertIn({'id': 'Duplicate language tag: en'}, error.errors)

    def test_languages_edit_not_raise_duplicate(self):
        error_raised = False
        validated_language = None
        json_language = {"id": "en", "name": "English"}
        language = LanguageTag(validator=languagetag_validator).bind(
            request=self.request, new=False)
        try:
            validated_language = language.deserialize(json_language)
        except ValidationError:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_language)

    def test_languages_invalid(self):
        error_raised = False
        validated_language = None
        json_language = {"id": "flup", "name": "test"}
        error = None
        try:
            validated_language = self.language.deserialize(json_language)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_language)
        self.assertIsNotNone(error)
        self.assertIn(
            {
                "id":
                "Invalid language tag: Unknown code 'flup', Missing language tag in 'flup'."
            }, error.errors)

    def test_subordinate_arrays(self):
        error_raised = False
        validated_json = None
        self.json_concept['subordinate_arrays'] = [{"id": 667}]
        try:
            validated_json = self.concept_schema.deserialize(self.json_concept)
        except ValidationError:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_json)

    def test_subordinate_arrays_no_concept(self):
        error_raised = False
        validated_json = None
        error = None
        self.json_collection['subordinate_arrays'] = [{"id": 666}]
        try:
            validated_json = self.concept_schema.deserialize(
                self.json_collection)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_json)
        self.assertIsNotNone(error)
        self.assertIn(
            {
                'subordinate_arrays':
                'Only concept can have subordinate arrays.'
            }, error.errors)

    def test_subordinate_arrays_no_collection(self):
        error_raised = False
        validated_json = None
        error = None
        self.json_concept['subordinate_arrays'] = [{"id": 7}]
        try:
            validated_json = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_json)
        self.assertIsNotNone(error)
        self.assertIn(
            {
                'subordinate_arrays':
                'A subordinate array should always be a collection'
            }, error.errors)

    def test_subordinate_arrays_hierarchy(self):
        error_raised = False
        validated_json = None
        error = None
        self.json_concept['subordinate_arrays'] = [{"id": 666}]
        try:
            validated_json = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_json)
        self.assertIsNotNone(error)
        self.assertIn(
            {
                'subordinate_arrays':
                'The subordinate_array collection of a concept must not itself be a parent of the concept being edited.'
            }, error.errors)

    def test_superordinates(self):
        error_raised = False
        validated_json = None
        self.json_collection['superordinates'] = [{"id": 7}]
        try:
            validated_json = self.concept_schema.deserialize(
                self.json_collection)
        except ValidationError:
            error_raised = True
        self.assertFalse(error_raised)
        self.assertIsNotNone(validated_json)

    def test_superordinates_no_concept(self):
        error_raised = False
        validated_json = None
        error = None
        self.json_collection['superordinates'] = [{"id": 666}]
        try:
            validated_json = self.concept_schema.deserialize(
                self.json_collection)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_json)
        self.assertIsNotNone(error)
        self.assertIn(
            {'superordinates': 'A superordinate should always be a concept'},
            error.errors)

    def test_superordinates_no_collection(self):
        error_raised = False
        validated_json = None
        error = None
        self.json_concept['superordinates'] = [{"id": 7}]
        try:
            validated_json = self.concept_schema.deserialize(self.json_concept)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_json)
        self.assertIsNotNone(error)
        self.assertIn(
            {'superordinates': 'Only collection can have superordinates.'},
            error.errors)

    def test_superordinates_hierarchy(self):
        error_raised = False
        validated_json = None
        error = None
        self.json_collection['superordinates'] = [{"id": 61}]
        try:
            validated_json = self.concept_schema.deserialize(
                self.json_collection)
        except ValidationError as e:
            error_raised = True
            error = e
        self.assertTrue(error_raised)
        self.assertIsNone(validated_json)
        self.assertIsNotNone(error)
        self.assertIn(
            {
                'superordinates':
                'The superordinates of a collection must not itself be a member of the collection being edited.'
            }, error.errors)

    def test_html_in_notes(self):
        json_concept = {
            "narrower": [{
                "id": 8
            }, {
                "id": 7
            }, {
                "id": 9
            }],
            "label":
            "Belgium",
            "type":
            "concept",
            "id":
            4,
            "broader": [{
                "id": 2
            }],
            "related": [{
                "id": 5
            }],
            "labels": [{
                "label": "Belgium",
                "type": "prefLabel",
                "language": "en"
            }],
            "notes": [{
                "note": "een <strong><h2>notitie</h2></strong>",
                "type": "note",
                "language": "nl"
            }],
            "sources": [{
                "citation": "Van Daele K. 2014"
            }],
            "member_of": [{
                "id": 666
            }]
        }
        validated_json = self.concept_schema.deserialize(json_concept)
        note = validated_json['notes'][0]
        self.assertEqual("een <strong>notitie</strong>", note['note'])

    def test_html_in_sources(self):
        json_concept = {
            "narrower": [{
                "id": 8
            }, {
                "id": 7
            }, {
                "id": 9
            }],
            "label":
            "Belgium",
            "type":
            "concept",
            "id":
            4,
            "broader": [{
                "id": 2
            }],
            "related": [{
                "id": 5
            }],
            "labels": [{
                "label": "Belgium",
                "type": "prefLabel",
                "language": "en"
            }],
            "notes": [{
                "note": "een notitie",
                "type": "note",
                "language": "nl"
            }],
            "sources": [{
                "citation":
                "Van Daele K. <strong><h2>2014</h2></strong>"
            }],
            "member_of": [{
                "id": 666
            }]
        }
        validated_json = self.concept_schema.deserialize(json_concept)
        source = validated_json['sources'][0]
        self.assertEqual("Van Daele K. <strong>2014</strong>",
                         source['citation'])
Ejemplo n.º 10
0
 def setUp(self):
     self.config = testing.setUp()
     self.request = testing.DummyRequest()
     self.request.db = db(self.request)
     self.concept_schema = ConceptSchema(
         validator=concept_schema_validator).bind(request=self.request,
                                                  conceptscheme_id=1)
     self.language = LanguageTag(validator=languagetag_validator).bind(
         request=self.request, new=True)
     self.json_concept = {
         "narrower": [{
             "id": 8
         }, {
             "id": 7
         }, {
             "id": 9
         }],
         "label": "Belgium",
         "type": "concept",
         "id": 4,
         "broader": [{
             "id": 2
         }],
         "related": [{
             "id": 5
         }],
         "labels": [{
             "label": "Belgium",
             "type": "prefLabel",
             "language": "en"
         }],
         "notes": [{
             "note": "een notitie",
             "type": "note",
             "language": "nl"
         }],
         "member_of": [{
             "id": 666
         }]
     }
     self.json_collection = {
         "id":
         0,
         "labels": [{
             "language": "nl-BE",
             "label": "Stijlen en culturen",
             "type": "prefLabel"
         }],
         "type":
         "collection",
         "label":
         "Stijlen en culturen",
         "members": [{
             "id": 61
         }, {
             "id": 60
         }],
         "notes": [{
             "note": "een notitie",
             "type": "note",
             "language": "nl"
         }],
         "member_of": [{
             "id": 666
         }]
     }