OnroerendErfgoed / oe_utils

tests/test_validation.py

# -*- coding: utf-8 -*-
import os
import unittest

import colander
import responses
from cornice import Service
from sqlalchemy import engine_from_config
from sqlalchemy.orm import sessionmaker

from oe_utils.validation import sqlalchemy_validator, OEIDSchemaNode, OEEmailSchemaNode, OEBoolSchemaNode, UrlSchemaNode, UriSchemaNode, ExternalUriSchemaNode
from tests import init_test_db, DummyDossier, DummySchema, init_validation_responses

from zope.sqlalchemy import ZopeTransactionExtension
from pyramid.testing import DummyRequest

try:
    from unittest.mock import Mock, patch, MagicMock
except ImportError:
    from mock import Mock, patch, MagicMock
try:
    import configparser
except ImportError:
    import ConfigParser as configparser

service = Service('dummy_service', path='/test')


class ValdiationTests(unittest.TestCase):
    @classmethod

This code seems to be duplicated in your project.

    def setUpClass(cls):
        config = configparser.ConfigParser()
        config.read(os.path.join(os.path.dirname(__file__), 'test.ini'))
        settings = config.items('app:oe_utils')
        settings = dict((s[0], s[1]) for s in settings)
        cls.engine = engine_from_config(settings, prefix='sqlalchemy.')
        cls.session_maker = sessionmaker(
            bind=cls.engine,
            extension=ZopeTransactionExtension()
        )
        init_test_db(cls.engine)

    def setUp(self):
        self.session = self.session_maker()
        self.request = DummyRequest()
        init_validation_responses()

        mapping_strict = colander.Mapping(unknown='raise')

        self.test_oe_id_schema = TestOEIDSchema(typ=mapping_strict).bind(request=self.request)
        self.test_oe_email_schema = TestOEEmailSchema(typ=mapping_strict).bind(request=self.request)
        self.test_oe_bool_schema = TestOEBoolSchema(typ=mapping_strict).bind(request=self.request)
        self.test_url_schema = TestUrlSchema(typ=mapping_strict).bind(request=self.request)
        self.test_uri_schema = TestUriSchema(typ=mapping_strict).bind(request=self.request)
        self.test_external_uri_schema = TestExternalUriSchema(typ=mapping_strict).bind(request=self.request)

    def tearDown(self):
        self.session.rollback()
        self.session.close()

    def test_sqlalchemy_validator_invalid(self):
        with self.assertRaises(colander.Invalid) as e:
            sqlalchemy_validator(DummySchema, 987654321, DummyDossier, self.session,
                             '%s is geen geldig dummydossier id')

            self.assertIn('987654321 is geen geldig dummydossier id', e.exception.__str__())

    def test_sqlalchemy_validator(self):
        result = sqlalchemy_validator(DummySchema, 1, DummyDossier, self.session,
                             '%s is geen geldig dummydossier id')
        self.assertIsInstance(result, DummyDossier)

    def test_oe_id_schema_node_invalid(self):
        data = {'test': -5}
        with self.assertRaises(colander.Invalid) as e:
            self.test_oe_id_schema.deserialize(data)
        self.assertIn('Geen geldig ID (-5< 0)', e.exception.__str__())

    def test_oe_id_schema_node_no_int(self):
        data = {'test': 'test'}
        with self.assertRaises(colander.Invalid) as e:
            self.test_oe_id_schema.deserialize(data)
        self.assertIn('is not a valid Integer.', e.exception.__str__())

    def test_oe_id_schema_node(self):
        data = {'test': 5}
        self.test_oe_id_schema.deserialize(data)

    def test_oe_email_schema_node_invalid(self):
        data = {'test': 'x'*256}
        with self.assertRaises(colander.Invalid) as e:
            self.test_oe_email_schema.deserialize(data)
        self.assertIn('Dit is geen geldig emailadres.', e.exception.__str__())

    def test_oe_email_schema_node(self):
        data = {'test': 'test@test.be'}
        self.test_oe_email_schema.deserialize(data)

    def test_oe_email_schema_node_invalid(self):
        data = {'test': 'x'*256}
        with self.assertRaises(colander.Invalid) as e:
            self.test_oe_email_schema.deserialize(data)
        self.assertIn('Dit is geen geldig emailadres.', e.exception.__str__())

    def test_oe_bool_schema_node_no_bool(self):
        data = {'test': 'test'}
        with self.assertRaises(colander.Invalid) as e:
            self.test_oe_bool_schema.deserialize(data)
        self.assertIn('is not a valid Boolean.', e.exception.__str__())

    def test_url_schema_node_to_long(self):
        data = {'test': 'a' * 2084}
        with self.assertRaises(colander.Invalid) as e:
            self.test_url_schema.deserialize(data)
        self.assertIn('URI is too long (max=2083).', e.exception.__str__())

    def test_url_schema_node_not_rfc3987_compliant(self):
        data = {'test': 'https://test@test.be test'}
        with self.assertRaises(colander.Invalid) as e:
            self.test_url_schema.deserialize(data)
        self.assertIn('https://test@test.be test is geen geldige URL.', e.exception.__str__())

    def test_url_schema_node_not_existing(self):
        data = {'test': 'https://id.erfgoed.net/inventaris/teksten/987654321'}
        with self.assertRaises(colander.Invalid) as e:
            self.test_url_schema.deserialize(data)
        self.assertIn('URL bestaat niet.', e.exception.__str__())

    @responses.activate
    def test_url_schema_node(self):
        data = {'test': 'https://id.erfgoed.net/inventaris/teksten/1'}
        self.test_url_schema.deserialize(data)

    def test_uri_schema_node_to_long(self):
        data = {'test': 'a' * 101}
        with self.assertRaises(colander.Invalid) as e:
            self.test_uri_schema.deserialize(data)
        self.assertIn('URI is too long (max=100).', e.exception.__str__())

    def test_uri_schema_node_not_rfc3987_compliable(self):
        data = {'test': 'https://test@test.be test'}
        with self.assertRaises(colander.Invalid) as e:
            self.test_uri_schema.deserialize(data)
        self.assertIn('https://test@test.be test is geen geldige URI.', e.exception.__str__())

    def test_extarnal_uri_schema_node_not_existing(self):
        data = {'test': 'https://id.erfgoed.net/inventaris/teksten/987654321'}
        with self.assertRaises(colander.Invalid) as e:
            self.test_external_uri_schema.deserialize(data)
        self.assertIn('URI bestaat niet.', e.exception.__str__())

    @responses.activate
    def test_extarnal_uri_schema_node(self):
        data = {'test': 'https://id.erfgoed.net/inventaris/teksten/1'}
        self.test_external_uri_schema.deserialize(data)


# Helper test classes
class TestOEIDSchema(colander.MappingSchema):
    test = OEIDSchemaNode()


class TestOEEmailSchema(colander.MappingSchema):
    test = OEEmailSchemaNode()


class TestOEBoolSchema(colander.MappingSchema):
    test = OEBoolSchemaNode()


class TestUrlSchema(colander.MappingSchema):
    test = UrlSchemaNode()


class TestUriSchema(colander.MappingSchema):
    test = UriSchemaNode()


class TestExternalUriSchema(colander.MappingSchema):
    test = ExternalUriSchemaNode()