[Python-modules-commits] [python-schema] 02/03: Initial debianization.
Ghislain Vaillant
ghisvail-guest at moszumanska.debian.org
Sun Jul 31 20:00:16 UTC 2016
This is an automated email from the git hooks/post-receive script.
ghisvail-guest pushed a commit to branch debian/master
in repository python-schema.
commit a58512301f760429ed6dbf431f327ea2434531e5
Author: Ghislain Antony Vaillant <ghisvail at gmail.com>
Date: Sat Jul 30 17:51:28 2016 +0100
Initial debianization.
---
debian/changelog | 5 +
debian/compat | 1 +
debian/control | 55 +++
debian/copyright | 31 ++
debian/gbp.conf | 9 +
debian/patches/Add-upstream-testsuite.patch | 520 ++++++++++++++++++++++++++++
debian/patches/series | 1 +
debian/pypy-schema.docs | 1 +
debian/python-schema.docs | 1 +
debian/python3-schema.docs | 1 +
debian/rules | 14 +
debian/source/format | 1 +
debian/tests/control | 7 +
debian/watch | 3 +
14 files changed, 650 insertions(+)
diff --git a/debian/changelog b/debian/changelog
new file mode 100644
index 0000000..ffd24fe
--- /dev/null
+++ b/debian/changelog
@@ -0,0 +1,5 @@
+python-schema (0.6.2-1) UNRELEASED; urgency=low
+
+ * Initial release. (Closes: #832976)
+
+ -- Ghislain Antony Vaillant <ghisvail at gmail.com> Sat, 30 Jul 2016 17:47:44 +0100
diff --git a/debian/compat b/debian/compat
new file mode 100644
index 0000000..ec63514
--- /dev/null
+++ b/debian/compat
@@ -0,0 +1 @@
+9
diff --git a/debian/control b/debian/control
new file mode 100644
index 0000000..51e0edd
--- /dev/null
+++ b/debian/control
@@ -0,0 +1,55 @@
+Source: python-schema
+Maintainer: Debian Python Modules Team <python-modules-team at lists.alioth.debian.org>
+Uploaders: Ghislain Antony Vaillant <ghisvail at gmail.com>
+Section: python
+Testsuite: autopkgtest
+Priority: optional
+Build-Depends: debhelper (>= 9),
+ dh-python,
+ python-all,
+ python-pytest,
+ python-setuptools,
+ python3-all,
+ python3-pytest,
+ python3-setuptools,
+ pypy,
+ pypy-setuptools
+Standards-Version: 3.9.8
+Vcs-Browser: https://anonscm.debian.org/cgit/python-modules/packages/python-schema.git
+Vcs-Git: https://anonscm.debian.org/git/python-modules/packages/python-schema.git
+Homepage: https://github.com/keleshev/schema
+X-Python-Version: >= 2.7
+X-Python3-Version: >= 3.2
+
+Package: python-schema
+Architecture: all
+Depends: ${misc:Depends},
+ ${python:Depends}
+Description: simple data validation library (Python 2)
+ Schema is a library for validating Python data structures, such as those
+ obtained from config-files, forms, external services or command-line parsing,
+ converted from JSON/YAML (or something else) to Python data-types.
+ .
+ This package provides schema for Python 2.
+
+Package: python3-schema
+Architecture: all
+Depends: ${misc:Depends},
+ ${python3:Depends}
+Description: simple data validation library (Python 3)
+ Schema is a library for validating Python data structures, such as those
+ obtained from config-files, forms, external services or command-line parsing,
+ converted from JSON/YAML (or something else) to Python data-types.
+ .
+ This package provides schema for Python 3.
+
+Package: pypy-schema
+Architecture: all
+Depends: ${misc:Depends},
+ ${pypy:Depends}
+Description: simple data validation library (PyPy)
+ Schema is a library for validating Python data structures, such as those
+ obtained from config-files, forms, external services or command-line parsing,
+ converted from JSON/YAML (or something else) to Python data-types.
+ .
+ This package provides schema for PyPy.
diff --git a/debian/copyright b/debian/copyright
new file mode 100644
index 0000000..fb27a51
--- /dev/null
+++ b/debian/copyright
@@ -0,0 +1,31 @@
+Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Upstream-Name: schema
+Upstream-Contact: Vladimir Keleshev <vladimir at keleshev.com>
+Source: https://pypi.python.org/pypi/schema
+
+Files: *
+Copyright: 2012 Vladimir Keleshev <vladimir at keleshev.com>
+License: Expat
+
+Files: debian/*
+Copyright: 2016 Ghislain Antony Vaillant <ghisvail at gmail.com>
+License: Expat
+
+License: Expat
+ Permission is hereby granted, free of charge, to any person obtaining a copy of
+ this software and associated documentation files (the "Software"), to deal in
+ the Software without restriction, including without limitation the rights to
+ use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ of the Software, and to permit persons to whom the Software is furnished to do
+ so, subject to the following conditions:
+ .
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+ .
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
diff --git a/debian/gbp.conf b/debian/gbp.conf
new file mode 100644
index 0000000..ea5c858
--- /dev/null
+++ b/debian/gbp.conf
@@ -0,0 +1,9 @@
+[DEFAULT]
+upstream-branch = upstream/latest
+debian-branch = debian/master
+upstream-tag = upstream/%(version)s
+debian-tag = debian/%(version)s
+pristine-tar = True
+
+[pq]
+patch-numbers = False
diff --git a/debian/patches/Add-upstream-testsuite.patch b/debian/patches/Add-upstream-testsuite.patch
new file mode 100644
index 0000000..508bc6a
--- /dev/null
+++ b/debian/patches/Add-upstream-testsuite.patch
@@ -0,0 +1,520 @@
+From: Ghislain Antony Vaillant <ghisvail at gmail.com>
+Date: Sun, 31 Jul 2016 20:19:42 +0100
+Subject: Add upstream testsuite.
+
+---
+ test_schema.py | 505 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ 1 file changed, 505 insertions(+)
+ create mode 100644 test_schema.py
+
+diff --git a/test_schema.py b/test_schema.py
+new file mode 100644
+index 0000000..2cad212
+--- /dev/null
++++ b/test_schema.py
+@@ -0,0 +1,505 @@
++from __future__ import with_statement
++from collections import defaultdict, namedtuple
++from operator import methodcaller
++import os
++import re
++import sys
++
++from pytest import raises
++
++from schema import (Schema, Use, And, Or, Regex, Optional,
++ SchemaError, SchemaWrongKeyError,
++ SchemaMissingKeyError, SchemaUnexpectedTypeError)
++
++if sys.version_info[0] == 3:
++ basestring = str # Python 3 does not have basestring
++ unicode = str # Python 3 does not have unicode
++
++
++SE = raises(SchemaError)
++
++
++def ve(_):
++ raise ValueError()
++
++
++def se(_):
++ raise SchemaError('first auto', 'first error')
++
++
++def test_schema():
++
++ assert Schema(1).validate(1) == 1
++ with SE: Schema(1).validate(9)
++
++ assert Schema(int).validate(1) == 1
++ with SE: Schema(int).validate('1')
++ assert Schema(Use(int)).validate('1') == 1
++ with SE: Schema(int).validate(int)
++
++ assert Schema(str).validate('hai') == 'hai'
++ with SE: Schema(str).validate(1)
++ assert Schema(Use(str)).validate(1) == '1'
++
++ assert Schema(list).validate(['a', 1]) == ['a', 1]
++ assert Schema(dict).validate({'a': 1}) == {'a': 1}
++ with SE: Schema(dict).validate(['a', 1])
++
++ assert Schema(lambda n: 0 < n < 5).validate(3) == 3
++ with SE: Schema(lambda n: 0 < n < 5).validate(-1)
++
++
++def test_validate_file():
++ assert Schema(
++ Use(open)).validate('LICENSE-MIT').read().startswith('Copyright')
++ with SE: Schema(Use(open)).validate('NON-EXISTENT')
++ assert Schema(os.path.exists).validate('.') == '.'
++ with SE: Schema(os.path.exists).validate('./non-existent/')
++ assert Schema(os.path.isfile).validate('LICENSE-MIT') == 'LICENSE-MIT'
++ with SE: Schema(os.path.isfile).validate('NON-EXISTENT')
++
++
++def test_and():
++ assert And(int, lambda n: 0 < n < 5).validate(3) == 3
++ with SE: And(int, lambda n: 0 < n < 5).validate(3.33)
++ assert And(Use(int), lambda n: 0 < n < 5).validate(3.33) == 3
++ with SE: And(Use(int), lambda n: 0 < n < 5).validate('3.33')
++
++
++def test_or():
++ assert Or(int, dict).validate(5) == 5
++ assert Or(int, dict).validate({}) == {}
++ with SE: Or(int, dict).validate('hai')
++ assert Or(int).validate(4)
++ with SE: Or().validate(2)
++
++
++def test_regex():
++ # Simple case: validate string
++ assert Regex(r'foo').validate('afoot') == 'afoot'
++ with SE: Regex(r'bar').validate('afoot')
++
++ # More complex case: validate string
++ assert Regex(r'^[a-z]+$').validate('letters') == 'letters'
++ with SE:
++ Regex(r'^[a-z]+$').validate('letters + spaces') == 'letters + spaces'
++
++ # Validate dict key
++ assert (Schema({Regex(r'^foo'): str})
++ .validate({'fookey': 'value'}) == {'fookey': 'value'})
++ with SE: Schema({Regex(r'^foo'): str}).validate({'barkey': 'value'})
++
++ # Validate dict value
++ assert (Schema({str: Regex(r'^foo')}).validate({'key': 'foovalue'}) ==
++ {'key': 'foovalue'})
++ with SE: Schema({str: Regex(r'^foo')}).validate({'key': 'barvalue'})
++
++ # Error if the value does not have a buffer interface
++ with SE: Regex(r'bar').validate(1)
++ with SE: Regex(r'bar').validate({})
++ with SE: Regex(r'bar').validate([])
++ with SE: Regex(r'bar').validate(None)
++
++ # Validate that the pattern has a buffer interface
++ assert Regex(re.compile(r'foo')).validate('foo') == 'foo'
++ assert Regex(unicode('foo')).validate('foo') == 'foo'
++ with raises(TypeError): Regex(1).validate('bar')
++ with raises(TypeError): Regex({}).validate('bar')
++ with raises(TypeError): Regex([]).validate('bar')
++ with raises(TypeError): Regex(None).validate('bar')
++
++
++def test_validate_list():
++ assert Schema([1, 0]).validate([1, 0, 1, 1]) == [1, 0, 1, 1]
++ assert Schema([1, 0]).validate([]) == []
++ with SE: Schema([1, 0]).validate(0)
++ with SE: Schema([1, 0]).validate([2])
++ assert And([1, 0], lambda l: len(l) > 2).validate([0, 1, 0]) == [0, 1, 0]
++ with SE: And([1, 0], lambda l: len(l) > 2).validate([0, 1])
++
++
++def test_list_tuple_set_frozenset():
++ assert Schema([int]).validate([1, 2])
++ with SE: Schema([int]).validate(['1', 2])
++ assert Schema(set([int])).validate(set([1, 2])) == set([1, 2])
++ with SE: Schema(set([int])).validate([1, 2]) # not a set
++ with SE: Schema(set([int])).validate(['1', 2])
++ assert Schema(tuple([int])).validate(tuple([1, 2])) == tuple([1, 2])
++ with SE: Schema(tuple([int])).validate([1, 2]) # not a set
++
++
++def test_strictly():
++ assert Schema(int).validate(1) == 1
++ with SE: Schema(int).validate('1')
++
++
++def test_dict():
++ assert Schema({'key': 5}).validate({'key': 5}) == {'key': 5}
++ with SE: Schema({'key': 5}).validate({'key': 'x'})
++ with SE: Schema({'key': 5}).validate(['key', 5])
++ assert Schema({'key': int}).validate({'key': 5}) == {'key': 5}
++ assert Schema({'n': int, 'f': float}).validate(
++ {'n': 5, 'f': 3.14}) == {'n': 5, 'f': 3.14}
++ with SE: Schema({'n': int, 'f': float}).validate(
++ {'n': 3.14, 'f': 5})
++ with SE:
++ try:
++ Schema({}).validate({'abc': None, 1: None})
++ except SchemaWrongKeyError as e:
++ assert e.args[0].startswith("Wrong keys 'abc', 1 in")
++ raise
++ with SE:
++ try:
++ Schema({'key': 5}).validate({})
++ except SchemaMissingKeyError as e:
++ assert e.args[0] == "Missing keys: 'key'"
++ raise
++ with SE:
++ try:
++ Schema({'key': 5}).validate({'n': 5})
++ except SchemaMissingKeyError as e:
++ assert e.args[0] == "Missing keys: 'key'"
++ raise
++ with SE:
++ try:
++ Schema({}).validate({'n': 5})
++ except SchemaWrongKeyError as e:
++ assert e.args[0] == "Wrong keys 'n' in {'n': 5}"
++ raise
++ with SE:
++ try:
++ Schema({'key': 5}).validate({'key': 5, 'bad': 5})
++ except SchemaWrongKeyError as e:
++ assert e.args[0] in ["Wrong keys 'bad' in {'key': 5, 'bad': 5}",
++ "Wrong keys 'bad' in {'bad': 5, 'key': 5}"]
++ raise
++ with SE:
++ try:
++ Schema({}).validate({'a': 5, 'b': 5})
++ except SchemaError as e:
++ assert e.args[0] in ["Wrong keys 'a', 'b' in {'a': 5, 'b': 5}",
++ "Wrong keys 'a', 'b' in {'b': 5, 'a': 5}"]
++ raise
++
++ with SE:
++ try:
++ Schema({int: int}).validate({'': ''})
++ except SchemaUnexpectedTypeError as e:
++ assert e.args[0] in ["'' should be instance of 'int'"]
++
++
++def test_dict_keys():
++ assert Schema({str: int}).validate(
++ {'a': 1, 'b': 2}) == {'a': 1, 'b': 2}
++ with SE: Schema({str: int}).validate({1: 1, 'b': 2})
++ assert Schema({Use(str): Use(int)}).validate(
++ {1: 3.14, 3.14: 1}) == {'1': 3, '3.14': 1}
++
++
++def test_ignore_extra_keys():
++ assert Schema({'key': 5}, ignore_extra_keys=True).validate(
++ {'key': 5, 'bad': 4}) == {'key': 5}
++
++
++def test_ignore_extra_keys_validation_and_return_keys():
++ assert Schema({'key': 5, object: object}, ignore_extra_keys=True).validate(
++ {'key': 5, 'bad': 4}) == {'key': 5, 'bad': 4}
++
++
++def test_dict_optional_keys():
++ with SE: Schema({'a': 1, 'b': 2}).validate({'a': 1})
++ assert Schema({'a': 1, Optional('b'): 2}).validate({'a': 1}) == {'a': 1}
++ assert Schema({'a': 1, Optional('b'): 2}).validate(
++ {'a': 1, 'b': 2}) == {'a': 1, 'b': 2}
++ # Make sure Optionals are favored over types:
++ assert Schema({basestring: 1,
++ Optional('b'): 2}).validate({'a': 1, 'b': 2}) == {'a': 1, 'b': 2}
++
++
++def test_dict_optional_defaults():
++ # Optionals fill out their defaults:
++ assert Schema({Optional('a', default=1): 11,
++ Optional('b', default=2): 22}).validate({'a': 11}) == {'a': 11, 'b': 2}
++
++ # Optionals take precedence over types. Here, the "a" is served by the
++ # Optional:
++ assert Schema({Optional('a', default=1): 11,
++ basestring: 22}).validate({'b': 22}) == {'a': 1, 'b': 22}
++
++ with raises(TypeError):
++ Optional(And(str, Use(int)), default=7)
++
++
++def test_dict_subtypes():
++ d = defaultdict(int, key=1)
++ v = Schema({'key': 1}).validate(d)
++ assert v == d
++ assert isinstance(v, defaultdict)
++ # Please add tests for Counter and OrderedDict once support for Python2.6
++ # is dropped!
++
++
++def test_complex():
++ s = Schema({'<file>': And([Use(open)], lambda l: len(l)),
++ '<path>': os.path.exists,
++ Optional('--count'): And(int, lambda n: 0 <= n <= 5)})
++ data = s.validate({'<file>': ['./LICENSE-MIT'], '<path>': './'})
++ assert len(data) == 2
++ assert len(data['<file>']) == 1
++ assert data['<file>'][0].read().startswith('Copyright')
++ assert data['<path>'] == './'
++
++
++def test_nice_errors():
++ try:
++ Schema(int, error='should be integer').validate('x')
++ except SchemaError as e:
++ assert e.errors == ['should be integer']
++ try:
++ Schema(Use(float), error='should be a number').validate('x')
++ except SchemaError as e:
++ assert e.code == 'should be a number'
++ try:
++ Schema({Optional('i'): Use(int, error='should be a number')}).validate({'i': 'x'})
++ except SchemaError as e:
++ assert e.code == 'should be a number'
++
++
++def test_use_error_handling():
++ try:
++ Use(ve).validate('x')
++ except SchemaError as e:
++ assert e.autos == ["ve('x') raised ValueError()"]
++ assert e.errors == [None]
++ try:
++ Use(ve, error='should not raise').validate('x')
++ except SchemaError as e:
++ assert e.autos == ["ve('x') raised ValueError()"]
++ assert e.errors == ['should not raise']
++ try:
++ Use(se).validate('x')
++ except SchemaError as e:
++ assert e.autos == [None, 'first auto']
++ assert e.errors == [None, 'first error']
++ try:
++ Use(se, error='second error').validate('x')
++ except SchemaError as e:
++ assert e.autos == [None, 'first auto']
++ assert e.errors == ['second error', 'first error']
++
++
++def test_or_error_handling():
++ try:
++ Or(ve).validate('x')
++ except SchemaError as e:
++ assert e.autos[0].startswith('Or(')
++ assert e.autos[0].endswith(") did not validate 'x'")
++ assert e.autos[1] == "ve('x') raised ValueError()"
++ assert len(e.autos) == 2
++ assert e.errors == [None, None]
++ try:
++ Or(ve, error='should not raise').validate('x')
++ except SchemaError as e:
++ assert e.autos[0].startswith('Or(')
++ assert e.autos[0].endswith(") did not validate 'x'")
++ assert e.autos[1] == "ve('x') raised ValueError()"
++ assert len(e.autos) == 2
++ assert e.errors == ['should not raise', 'should not raise']
++ try:
++ Or('o').validate('x')
++ except SchemaError as e:
++ assert e.autos == ["Or('o') did not validate 'x'",
++ "'o' does not match 'x'"]
++ assert e.errors == [None, None]
++ try:
++ Or('o', error='second error').validate('x')
++ except SchemaError as e:
++ assert e.autos == ["Or('o') did not validate 'x'",
++ "'o' does not match 'x'"]
++ assert e.errors == ['second error', 'second error']
++
++
++def test_and_error_handling():
++ try:
++ And(ve).validate('x')
++ except SchemaError as e:
++ assert e.autos == ["ve('x') raised ValueError()"]
++ assert e.errors == [None]
++ try:
++ And(ve, error='should not raise').validate('x')
++ except SchemaError as e:
++ assert e.autos == ["ve('x') raised ValueError()"]
++ assert e.errors == ['should not raise']
++ try:
++ And(str, se).validate('x')
++ except SchemaError as e:
++ assert e.autos == [None, 'first auto']
++ assert e.errors == [None, 'first error']
++ try:
++ And(str, se, error='second error').validate('x')
++ except SchemaError as e:
++ assert e.autos == [None, 'first auto']
++ assert e.errors == ['second error', 'first error']
++
++
++def test_schema_error_handling():
++ try:
++ Schema(Use(ve)).validate('x')
++ except SchemaError as e:
++ assert e.autos == [None, "ve('x') raised ValueError()"]
++ assert e.errors == [None, None]
++ try:
++ Schema(Use(ve), error='should not raise').validate('x')
++ except SchemaError as e:
++ assert e.autos == [None, "ve('x') raised ValueError()"]
++ assert e.errors == ['should not raise', None]
++ try:
++ Schema(Use(se)).validate('x')
++ except SchemaError as e:
++ assert e.autos == [None, None, 'first auto']
++ assert e.errors == [None, None, 'first error']
++ try:
++ Schema(Use(se), error='second error').validate('x')
++ except SchemaError as e:
++ assert e.autos == [None, None, 'first auto']
++ assert e.errors == ['second error', None, 'first error']
++
++
++def test_use_json():
++ import json
++ gist_schema = Schema(And(Use(json.loads), # first convert from JSON
++ {Optional('description'): basestring,
++ 'public': bool,
++ 'files': {basestring: {'content': basestring}}}))
++ gist = '''{"description": "the description for this gist",
++ "public": true,
++ "files": {
++ "file1.txt": {"content": "String file contents"},
++ "other.txt": {"content": "Another file contents"}}}'''
++ assert gist_schema.validate(gist)
++
++
++def test_error_reporting():
++ s = Schema({'<files>': [Use(open, error='<files> should be readable')],
++ '<path>': And(os.path.exists, error='<path> should exist'),
++ '--count': Or(None, And(Use(int), lambda n: 0 < n < 5),
++ error='--count should be integer 0 < n < 5')},
++ error='Error:')
++ s.validate({'<files>': [], '<path>': './', '--count': 3})
++
++ try:
++ s.validate({'<files>': [], '<path>': './', '--count': '10'})
++ except SchemaError as e:
++ assert e.code == 'Error:\n--count should be integer 0 < n < 5'
++ try:
++ s.validate({'<files>': [], '<path>': './hai', '--count': '2'})
++ except SchemaError as e:
++ assert e.code == 'Error:\n<path> should exist'
++ try:
++ s.validate({'<files>': ['hai'], '<path>': './', '--count': '2'})
++ except SchemaError as e:
++ assert e.code == 'Error:\n<files> should be readable'
++
++
++def test_schema_repr(): # what about repr with `error`s?
++ schema = Schema([Or(None, And(str, Use(float)))])
++ repr_ = "Schema([Or(None, And(<type 'str'>, Use(<type 'float'>)))])"
++ # in Python 3 repr contains <class 'str'>, not <type 'str'>
++ assert repr(schema).replace('class', 'type') == repr_
++
++
++def test_validate_object():
++ schema = Schema({object: str})
++ assert schema.validate({42: 'str'}) == {42: 'str'}
++ with SE: schema.validate({42: 777})
++
++
++def test_issue_9_prioritized_key_comparison():
++ validate = Schema({'key': 42, object: 42}).validate
++ assert validate({'key': 42, 777: 42}) == {'key': 42, 777: 42}
++
++
++def test_issue_9_prioritized_key_comparison_in_dicts():
++ # http://stackoverflow.com/questions/14588098/docopt-schema-validation
++ s = Schema({'ID': Use(int, error='ID should be an int'),
++ 'FILE': Or(None, Use(open, error='FILE should be readable')),
++ Optional(str): object})
++ data = {'ID': 10, 'FILE': None, 'other': 'other', 'other2': 'other2'}
++ assert s.validate(data) == data
++ data = {'ID': 10, 'FILE': None}
++ assert s.validate(data) == data
++
++
++def test_missing_keys_exception_with_non_str_dict_keys():
++ s = Schema({And(str, Use(str.lower), 'name'): And(str, len)})
++ with SE: s.validate(dict())
++ with SE:
++ try:
++ Schema({1: 'x'}).validate(dict())
++ except SchemaMissingKeyError as e:
++ assert e.args[0] == "Missing keys: 1"
++ raise
++
++
++def test_issue_56_cant_rely_on_callables_to_have_name():
++ s = Schema(methodcaller('endswith', '.csv'))
++ assert s.validate('test.csv') == 'test.csv'
++ with SE:
++ try:
++ s.validate('test.py')
++ except SchemaError as e:
++ assert "operator.methodcaller" in e.args[0]
++ raise
++
++
++def test_exception_handling_with_bad_validators():
++ BadValidator = namedtuple("BadValidator", ["validate"])
++ s = Schema(BadValidator("haha"))
++ with SE:
++ try:
++ s.validate("test")
++ except SchemaError as e:
++ assert "TypeError" in e.args[0]
++ raise
++
++
++def test_issue_83_iterable_validation_return_type():
++ TestSetType = type("TestSetType", (set,), dict())
++ data = TestSetType(["test", "strings"])
++ s = Schema(set([str]))
++ assert isinstance(s.validate(data), TestSetType)
++
++
++def test_optional_key_convert_failed_randomly_while_with_another_optional_object():
++ """
++ In this test, created_at string "2015-10-10 00:00:00" is expected to be converted
++ to a datetime instance.
++ - it works when the schema is
++
++ s = Schema({
++ 'created_at': _datetime_validator,
++ Optional(basestring): object,
++ })
++
++ - but when wrapping the key 'created_at' with Optional, it fails randomly
++ :return:
++ """
++ import datetime
++ fmt = '%Y-%m-%d %H:%M:%S'
++ _datetime_validator = Or(None, Use(lambda i: datetime.datetime.strptime(i, fmt)))
++ # FIXME given tests enough
++ for i in range(1024):
++ s = Schema({
++ Optional('created_at'): _datetime_validator,
++ Optional('updated_at'): _datetime_validator,
++ Optional('birth'): _datetime_validator,
++ Optional(basestring): object,
++ })
++ data = {
++ 'created_at': '2015-10-10 00:00:00'
++ }
++ validated_data = s.validate(data)
++ # is expected to be converted to a datetime instance, but fails randomly
++ # (most of the time)
++ assert isinstance(validated_data['created_at'], datetime.datetime)
++ # assert isinstance(validated_data['created_at'], basestring)
diff --git a/debian/patches/series b/debian/patches/series
new file mode 100644
index 0000000..985e390
--- /dev/null
+++ b/debian/patches/series
@@ -0,0 +1 @@
+Add-upstream-testsuite.patch
diff --git a/debian/pypy-schema.docs b/debian/pypy-schema.docs
new file mode 100644
index 0000000..a1320b1
--- /dev/null
+++ b/debian/pypy-schema.docs
@@ -0,0 +1 @@
+README.rst
diff --git a/debian/python-schema.docs b/debian/python-schema.docs
new file mode 100644
index 0000000..a1320b1
--- /dev/null
+++ b/debian/python-schema.docs
@@ -0,0 +1 @@
+README.rst
diff --git a/debian/python3-schema.docs b/debian/python3-schema.docs
new file mode 100644
index 0000000..a1320b1
--- /dev/null
+++ b/debian/python3-schema.docs
@@ -0,0 +1 @@
+README.rst
diff --git a/debian/rules b/debian/rules
new file mode 100755
index 0000000..9412b6c
--- /dev/null
+++ b/debian/rules
@@ -0,0 +1,14 @@
+#! /usr/bin/make -f
+
+# Uncomment this to turn on verbose mode.
+#export DH_VERBOSE = 1
+
+export PYBUILD_NAME = schema
+export PYBUILD_BEFORE_TEST = cp {dir}/test_schema.py {dir}/LICENSE-MIT {build_dir}
+export PYBUILD_AFTER_TEST = rm {build_dir}/test_schema.py {build_dir}/LICENSE-MIT
+
+# Testing is disabled on PyPy due to missing pytest dependency.
+export PYBUILD_DISABLE = test/pypy
+
+%:
+ dh $@ --with python2,python3,pypy --buildsystem=pybuild
diff --git a/debian/source/format b/debian/source/format
new file mode 100644
index 0000000..163aaf8
--- /dev/null
+++ b/debian/source/format
@@ -0,0 +1 @@
+3.0 (quilt)
diff --git a/debian/tests/control b/debian/tests/control
new file mode 100644
index 0000000..3079479
--- /dev/null
+++ b/debian/tests/control
@@ -0,0 +1,7 @@
+Test-Command: cp -a ./test_schema.py ./LICENSE-MIT $AUTOPKGTEST_TMP
+ ; cd $AUTOPKGTEST_TMP ; py.test ./test_schema.py
+Depends: python-pytest, python-schema
+
+Test-Command: cp -a ./test_schema.py ./LICENSE-MIT $AUTOPKGTEST_TMP
+ ; cd $AUTOPKGTEST_TMP ; py.test-3 ./test_schema.py
+Depends: python3-pytest, python3-schema
diff --git a/debian/watch b/debian/watch
new file mode 100644
index 0000000..03deca5
--- /dev/null
+++ b/debian/watch
@@ -0,0 +1,3 @@
+version=3
+opts=uversionmangle=s/(rc|a|b|c)/~$1/ \
+https://pypi.debian.net/schema/schema-(.+)\.(?:zip|tgz|tbz|txz|(?:tar\.(?:gz|bz2|xz)))
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/python-modules/packages/python-schema.git
More information about the Python-modules-commits
mailing list