commit 189700d9366f65850ff31ca083f69172a366e4d4362e791d713a904ffeab7ff0 Author: Markéta Machová Date: Thu Nov 19 12:57:40 2020 +0000 Accepting request 849233 from home:jayvdb:py-submit dep of bodhi OBS-URL: https://build.opensuse.org/request/show/849233 OBS-URL: https://build.opensuse.org/package/show/devel:languages:python/python-marshmallow-enum?expand=0&rev=1 diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..9b03811 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,23 @@ +## Default LFS +*.7z filter=lfs diff=lfs merge=lfs -text +*.bsp filter=lfs diff=lfs merge=lfs -text +*.bz2 filter=lfs diff=lfs merge=lfs -text +*.gem filter=lfs diff=lfs merge=lfs -text +*.gz filter=lfs diff=lfs merge=lfs -text +*.jar filter=lfs diff=lfs merge=lfs -text +*.lz filter=lfs diff=lfs merge=lfs -text +*.lzma filter=lfs diff=lfs merge=lfs -text +*.obscpio filter=lfs diff=lfs merge=lfs -text +*.oxt filter=lfs diff=lfs merge=lfs -text +*.pdf filter=lfs diff=lfs merge=lfs -text +*.png filter=lfs diff=lfs merge=lfs -text +*.rpm filter=lfs diff=lfs merge=lfs -text +*.tbz filter=lfs diff=lfs merge=lfs -text +*.tbz2 filter=lfs diff=lfs merge=lfs -text +*.tgz filter=lfs diff=lfs merge=lfs -text +*.ttf filter=lfs diff=lfs merge=lfs -text +*.txz filter=lfs diff=lfs merge=lfs -text +*.whl filter=lfs diff=lfs merge=lfs -text +*.xz filter=lfs diff=lfs merge=lfs -text +*.zip filter=lfs diff=lfs merge=lfs -text +*.zst filter=lfs diff=lfs merge=lfs -text diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..57affb6 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +.osc diff --git a/marshmallow-enum-1.5.1.tar.gz b/marshmallow-enum-1.5.1.tar.gz new file mode 100644 index 0000000..b82a8b0 --- /dev/null +++ b/marshmallow-enum-1.5.1.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:38e697e11f45a8e64b4a1e664000897c659b60aa57bfa18d44e226a9920b6e58 +size 4013 diff --git a/python-marshmallow-enum.changes b/python-marshmallow-enum.changes new file mode 100644 index 0000000..146cdea --- /dev/null +++ b/python-marshmallow-enum.changes @@ -0,0 +1,4 @@ +------------------------------------------------------------------- +Tue Nov 17 08:15:29 AM UTC 2020 - John Vandenberg + +- Initial spec for v1.5.1 diff --git a/python-marshmallow-enum.spec b/python-marshmallow-enum.spec new file mode 100644 index 0000000..363f594 --- /dev/null +++ b/python-marshmallow-enum.spec @@ -0,0 +1,62 @@ +# +# spec file for package python-marshmallow-enum +# +# Copyright (c) 2020 SUSE LLC +# +# All modifications and additions to the file contributed by third parties +# remain the property of their copyright owners, unless otherwise agreed +# upon. The license for this file, and modifications and additions to the +# file, is the same license as for the pristine package itself (unless the +# license for the pristine package is not an Open Source License, in which +# case the license is the MIT License). An "Open Source License" is a +# license that conforms to the Open Source Definition (Version 1.9) +# published by the Open Source Initiative. + +# Please submit bugfixes or comments via https://bugs.opensuse.org/ +# + + +%{?!python_module:%define python_module() python-%{**} python3-%{**}} +%define skip_python2 1 +Name: python-marshmallow-enum +Version: 1.5.1 +Release: 0 +Summary: Enum field for Marshmallow +License: MIT +URL: https://github.com/justanr/marshmallow_enum +Source: https://files.pythonhosted.org/packages/source/m/marshmallow-enum/marshmallow-enum-%{version}.tar.gz +Source1: https://raw.githubusercontent.com/justanr/marshmallow_enum/master/tests/test_enum_field.py +BuildRequires: python-rpm-macros +BuildRequires: %{python_module setuptools} +# SECTION test requirements +BuildRequires: %{python_module marshmallow >= 2.0.0} +BuildRequires: %{python_module pytest} +# /SECTION +BuildRequires: fdupes +Requires: python-marshmallow >= 2.0.0 +BuildArch: noarch +%python_subpackages + +%description +Enum field for Marshmallow. + +%prep +%setup -q -n marshmallow-enum-%{version} +cp %{SOURCE1} . + +%build +%python_build + +%install +%python_install +%python_expand %fdupes %{buildroot}%{$python_sitelib} + +%check +%pytest + +%files %{python_files} +%doc CHANGELOG README.md +%license LICENSE +%{python_sitelib}/* + +%changelog diff --git a/test_enum_field.py b/test_enum_field.py new file mode 100644 index 0000000..7a76bcc --- /dev/null +++ b/test_enum_field.py @@ -0,0 +1,361 @@ +# -*- coding: utf-8 -*- +from __future__ import unicode_literals + +import sys +import warnings +from collections import namedtuple +from enum import Enum + +import pytest +import marshmallow +from marshmallow import Schema, ValidationError +from marshmallow.fields import List +from marshmallow_enum import EnumField + +PY2 = sys.version_info.major == 2 +MARSHMALLOW_VERSION_MAJOR = int(marshmallow.__version__.split('.')[0]) + + +class EnumTester(Enum): + one = 1 + two = 2 + three = 3 + + +SomeObj = namedtuple('SingleEnum', ['enum']) + + +class TestEnumFieldByName(object): + + def setup(self): + self.field = EnumField(EnumTester) + + def test_serialize_enum(self): + assert self.field._serialize(EnumTester.one, None, object()) == 'one' + + def test_serialize_none(self): + assert self.field._serialize(None, None, object()) is None + + def test_deserialize_enum(self): + assert self.field._deserialize('one', None, {}) == EnumTester.one + + def test_deserialize_none(self): + assert self.field._deserialize(None, None, {}) is None + + def test_deserialize_nonexistent_member(self): + with pytest.raises(ValidationError): + self.field._deserialize('fred', None, {}) + + +class TestEnumFieldValue(object): + + def test_deserialize_enum(self): + field = EnumField(EnumTester, by_value=True) + + assert field._deserialize(1, None, {}) == EnumTester.one + + def test_serialize_enum(self): + field = EnumField(EnumTester, by_value=True) + assert field._serialize(EnumTester.one, None, object()) == 1 + + def test_serialize_none(self): + field = EnumField(EnumTester, by_value=True) + assert field._serialize(None, None, object()) is None + + def test_deserialize_nonexistent_member(self): + field = EnumField(EnumTester, by_value=True) + + with pytest.raises(ValidationError): + field._deserialize(4, None, {}) + + +class TestEnumFieldAsSchemaMember(object): + + class EnumSchema(Schema): + enum = EnumField(EnumTester) + none = EnumField(EnumTester) + + def test_enum_field_load(self): + serializer = self.EnumSchema() + + data = serializer.load({'enum': 'one'}) + if MARSHMALLOW_VERSION_MAJOR < 3: + data = data.data + + assert data['enum'] == EnumTester.one + + def test_enum_field_dump(self): + serializer = self.EnumSchema() + + data = serializer.dump(SomeObj(EnumTester.one)) + if MARSHMALLOW_VERSION_MAJOR < 3: + data = data.data + + assert data['enum'] == 'one' + + +class TestEnumByValueAsSchemaMember(object): + + class EnumSchema(Schema): + enum = EnumField(EnumTester, by_value=True) + none = EnumField(EnumTester, by_value=True) + + def test_enum_field_load(self): + serializer = self.EnumSchema() + + data = serializer.load({'enum': 1}) + if MARSHMALLOW_VERSION_MAJOR < 3: + data = data.data + + assert data['enum'] == EnumTester.one + + def test_enum_field_dump(self): + serializer = self.EnumSchema() + + data = serializer.dump(SomeObj(EnumTester.one)) + if MARSHMALLOW_VERSION_MAJOR < 3: + data = data.data + + assert data['enum'] == 1 + + +class TestEnumFieldInListField(object): + + class ListEnumSchema(Schema): + enum = List(EnumField(EnumTester)) + + def test_enum_list_load(self): + serializer = self.ListEnumSchema() + + data = serializer.load({'enum': ['one', 'two']}) + if MARSHMALLOW_VERSION_MAJOR < 3: + data = data.data + + assert data['enum'] == [EnumTester.one, EnumTester.two] + + def test_enum_list_dump(self): + serializer = self.ListEnumSchema() + data = serializer.dump(SomeObj([EnumTester.one, EnumTester.two])) + + if MARSHMALLOW_VERSION_MAJOR < 3: + data = data.data + + assert data['enum'] == ['one', 'two'] + + +class TestEnumFieldByValueInListField(object): + + class ListEnumSchema(Schema): + enum = List(EnumField(EnumTester, by_value=True)) + + def test_enum_list_load(self): + serializer = self.ListEnumSchema() + data = serializer.load({'enum': [1, 2]}) + + if MARSHMALLOW_VERSION_MAJOR < 3: + data = data.data + + assert data['enum'] == [EnumTester.one, EnumTester.two] + + def test_enum_list_dump(self): + serializer = self.ListEnumSchema() + data = serializer.dump(SomeObj([EnumTester.one, EnumTester.two])) + + if MARSHMALLOW_VERSION_MAJOR < 3: + data = data.data + + assert data['enum'] == [1, 2] + + +class TestCustomErrorMessage(object): + + def test_custom_error_in_deserialize_by_value(self): + if MARSHMALLOW_VERSION_MAJOR < 3: + err_tpl = "{input} must be one of {choices}" + else: + err_tpl = "{input} must be one of {values}" + + field = EnumField(EnumTester, by_value=True, error=err_tpl) + with pytest.raises(ValidationError) as excinfo: + field._deserialize(4, None, {}) + + expected = "4 must be one of 1, 2, 3" + assert expected in str(excinfo.value) + + def test_custom_error_in_deserialize_by_name(self): + if MARSHMALLOW_VERSION_MAJOR < 3: + err_tpl = "{input} must be one of {choices}" + else: + err_tpl = "{input} must be one of {names}" + + field = EnumField(EnumTester, error=err_tpl) + with pytest.raises(ValidationError) as excinfo: + field._deserialize('four', None, {}) + expected = 'four must be one of one, two, three' + assert expected in str(excinfo) + + def test_uses_default_error_if_no_custom_provided(self): + field = EnumField(EnumTester, by_value=True) + with pytest.raises(ValidationError) as excinfo: + field._deserialize(4, None, {}) + expected = 'Invalid enum value 4' + assert expected in str(excinfo.value) + + +class TestRegressions(object): + + @pytest.mark.parametrize('bad_value', [object, object(), [], {}, 1, 3.4, False, ()]) + def test_by_name_must_be_string(self, bad_value): + + class SomeEnum(Enum): + red = 0 + yellow = 1 + green = 2 + + class SomeSchema(Schema): + if MARSHMALLOW_VERSION_MAJOR < 3: + class Meta: + strict = True + + colors = EnumField( + SomeEnum, + by_value=False, + ) + + with pytest.raises(ValidationError) as excinfo: + SomeSchema().load({'colors': bad_value}) + + assert 'must be string' in str(excinfo.value) + + @pytest.mark.skipif(PY2, reason='py2 strings are bytes') + def test_by_name_cannot_be_bytes(self): + + class SomeEnum(Enum): + a = 1 + + class SomeSchema(Schema): + if MARSHMALLOW_VERSION_MAJOR < 3: + class Meta: + strict = True + + f = EnumField(SomeEnum, by_value=False) + + with pytest.raises(ValidationError) as excinfo: + SomeSchema().load({'f': b'a'}) + + assert 'must be string' in str(excinfo.value) + + +class TestLoadDumpConfigBehavior(object): + + def test_load_and_dump_by_default_to_by_value(self): + f = EnumField(EnumTester) + assert f.load_by == EnumField.NAME + assert f.dump_by == EnumField.NAME + + def test_load_by_raises_if_not_proper_value(self): + with pytest.raises(ValueError) as excinfo: + EnumField(EnumTester, load_by='lol') + + assert 'Invalid selection' in str(excinfo.value) + + def test_dump_by_raises_if_not_proper_value(self): + with pytest.raises(ValueError) as excinfo: + EnumField(EnumTester, dump_by='lol') + + assert 'Invalid selection' in str(excinfo.value) + + def test_dumps_to_value_when_configured_to(self): + + class SomeSchema(Schema): + f = EnumField(EnumTester, dump_by=EnumField.VALUE) + + expected = {'f': 1} + actual = SomeSchema().dump({'f': EnumTester.one}) + if MARSHMALLOW_VERSION_MAJOR < 3: + actual = actual.data + + assert expected == actual + + def test_loads_to_value_when_configured_to(self): + + class SomeSchema(Schema): + f = EnumField(EnumTester, load_by=EnumField.VALUE) + + expected = {'f': EnumTester.one} + actual = SomeSchema().load({'f': 1}) + if MARSHMALLOW_VERSION_MAJOR < 3: + actual = actual.data + + assert expected == actual + + def test_load_by_value_dump_by_name(self): + + class SomeSchema(Schema): + f = EnumField(EnumTester, load_by=EnumField.VALUE, dump_by=EnumField.NAME) + + schema = SomeSchema() + + expected = {'f': 'one'} + + if MARSHMALLOW_VERSION_MAJOR < 3: + actual = schema.dump(schema.load({'f': 1}).data).data + else: + actual = schema.dump(schema.load({'f': 1})) + + assert actual == expected + + def test_load_by_name_dump_by_value(self): + + class SomeSchema(Schema): + f = EnumField(EnumTester, load_by=EnumField.NAME, dump_by=EnumField.VALUE) + + schema = SomeSchema() + expected = {'f': 1} + + if MARSHMALLOW_VERSION_MAJOR < 3: + actual = schema.dump(schema.load({'f': 'one'}).data).data + else: + actual = schema.dump(schema.load({'f': 'one'})) + + assert actual == expected + + +@pytest.mark.parametrize('format', ['{name}', '{value}', '{choices}']) +def test_old_error_format_inputs_are_deprecated(format): + with warnings.catch_warnings(record=True) as w: + warnings.simplefilter('always', DeprecationWarning) + EnumField(EnumTester, error=format) + warnings.simplefilter('default', DeprecationWarning) + + assert len(w) == 1 + assert issubclass(w[0].category, DeprecationWarning) + assert "input" in str(w[0].message) + assert "values" in str(w[0].message) + assert "names" in str(w[0].message) + + +class TestUnicodeEnumValues(object): + class UnicodeEnumTester(Enum): + a = 'aæaф' + b = 'basd' + c = 'c僀23' + + values = 'aæaф, basd, c僀23' + + def test_user_error(self): + with pytest.raises(ValidationError) as exc_info: + EnumField(self.UnicodeEnumTester, error='{values}').fail('error') + + assert exc_info.value.messages[0] == self.values + + def test_by_value_error(self): + class MyEnumField(EnumField): + default_error_messages = { + 'by_value': '{values}' + } + + with pytest.raises(ValidationError) as exc_info: + EnumField(self.UnicodeEnumTester, error='{values}').fail('by_value') + + assert exc_info.value.messages[0] == self.values