228 lines
7.9 KiB
Python
228 lines
7.9 KiB
Python
# Copyright 2016 NTT DATA
|
|
# All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
import datetime
|
|
|
|
import iso8601
|
|
from oslo_versionedobjects import exception as ovo_exc
|
|
import six
|
|
|
|
from masakari.objects import fields
|
|
from masakari import test
|
|
from masakari import utils
|
|
|
|
|
|
class FakeFieldType(fields.FieldType):
|
|
def coerce(self, obj, attr, value):
|
|
return '*%s*' % value
|
|
|
|
def to_primitive(self, obj, attr, value):
|
|
return '!%s!' % value
|
|
|
|
def from_primitive(self, obj, attr, value):
|
|
return value[1:-1]
|
|
|
|
|
|
class FakeEnum(fields.Enum):
|
|
FROG = "frog"
|
|
PLATYPUS = "platypus"
|
|
ALLIGATOR = "alligator"
|
|
|
|
ALL = (FROG, PLATYPUS, ALLIGATOR)
|
|
|
|
def __init__(self, **kwargs):
|
|
super(FakeEnum, self).__init__(valid_values=FakeEnum.ALL,
|
|
**kwargs)
|
|
|
|
|
|
class FakeEnumAlt(fields.Enum):
|
|
FROG = "frog"
|
|
PLATYPUS = "platypus"
|
|
AARDVARK = "aardvark"
|
|
|
|
ALL = (FROG, PLATYPUS, AARDVARK)
|
|
|
|
def __init__(self, **kwargs):
|
|
super(FakeEnumAlt, self).__init__(valid_values=FakeEnumAlt.ALL,
|
|
**kwargs)
|
|
|
|
|
|
class FakeEnumField(fields.BaseEnumField):
|
|
AUTO_TYPE = FakeEnum()
|
|
|
|
|
|
class FakeEnumAltField(fields.BaseEnumField):
|
|
AUTO_TYPE = FakeEnumAlt()
|
|
|
|
|
|
class TestField(test.NoDBTestCase):
|
|
def setUp(self):
|
|
super(TestField, self).setUp()
|
|
self.field = fields.Field(FakeFieldType())
|
|
self.coerce_good_values = [('foo', '*foo*')]
|
|
self.coerce_bad_values = []
|
|
self.to_primitive_values = [('foo', '!foo!')]
|
|
self.from_primitive_values = [('!foo!', 'foo')]
|
|
|
|
def test_coerce_good_values(self):
|
|
for in_val, out_val in self.coerce_good_values:
|
|
self.assertEqual(out_val, self.field.coerce('obj', 'attr', in_val))
|
|
|
|
def test_coerce_bad_values(self):
|
|
for in_val in self.coerce_bad_values:
|
|
self.assertRaises((TypeError, ValueError),
|
|
self.field.coerce, 'obj', 'attr', in_val)
|
|
|
|
def test_to_primitive(self):
|
|
for in_val, prim_val in self.to_primitive_values:
|
|
self.assertEqual(prim_val, self.field.to_primitive('obj', 'attr',
|
|
in_val))
|
|
|
|
def test_from_primitive(self):
|
|
class ObjectLikeThing(object):
|
|
_context = 'context'
|
|
|
|
for prim_val, out_val in self.from_primitive_values:
|
|
self.assertEqual(out_val,
|
|
self.field.from_primitive(ObjectLikeThing,
|
|
'attr', prim_val))
|
|
|
|
def test_stringify(self):
|
|
self.assertEqual('123', self.field.stringify(123))
|
|
|
|
|
|
class TestString(TestField):
|
|
def setUp(self):
|
|
super(TestString, self).setUp()
|
|
self.field = fields.StringField()
|
|
self.coerce_good_values = [('foo', 'foo'), (1, '1'), (True, 'True')]
|
|
if six.PY2:
|
|
self.coerce_good_values.append((int(1), '1'))
|
|
self.coerce_bad_values = [None]
|
|
self.to_primitive_values = self.coerce_good_values[0:1]
|
|
self.from_primitive_values = self.coerce_good_values[0:1]
|
|
|
|
def test_stringify(self):
|
|
self.assertEqual("'123'", self.field.stringify(123))
|
|
|
|
|
|
class TestBaseEnum(TestField):
|
|
def setUp(self):
|
|
super(TestBaseEnum, self).setUp()
|
|
self.field = FakeEnumField()
|
|
self.coerce_good_values = [('frog', 'frog'),
|
|
('platypus', 'platypus'),
|
|
('alligator', 'alligator')]
|
|
self.coerce_bad_values = ['aardvark', 'wookie']
|
|
self.to_primitive_values = self.coerce_good_values[0:1]
|
|
self.from_primitive_values = self.coerce_good_values[0:1]
|
|
|
|
def test_stringify(self):
|
|
self.assertEqual("'platypus'", self.field.stringify('platypus'))
|
|
|
|
def test_stringify_invalid(self):
|
|
self.assertRaises(ValueError, self.field.stringify, 'aardvark')
|
|
|
|
def test_fingerprint(self):
|
|
field1 = FakeEnumField()
|
|
field2 = FakeEnumAltField()
|
|
self.assertNotEqual(str(field1), str(field2))
|
|
|
|
|
|
class TestEnum(TestField):
|
|
def setUp(self):
|
|
super(TestEnum, self).setUp()
|
|
self.field = fields.EnumField(
|
|
valid_values=['foo', 'bar', 1, 1, True])
|
|
self.coerce_good_values = [('foo', 'foo'), (1, '1'), (True, 'True')]
|
|
if six.PY2:
|
|
self.coerce_good_values.append((int(1), '1'))
|
|
self.coerce_bad_values = ['boo', 2, False]
|
|
self.to_primitive_values = self.coerce_good_values[0:1]
|
|
self.from_primitive_values = self.coerce_good_values[0:1]
|
|
|
|
def test_stringify(self):
|
|
self.assertEqual("'foo'", self.field.stringify('foo'))
|
|
|
|
def test_stringify_invalid(self):
|
|
self.assertRaises(ValueError, self.field.stringify, '123')
|
|
|
|
def test_fingerprint(self):
|
|
field1 = fields.EnumField(valid_values=['foo', 'bar'])
|
|
field2 = fields.EnumField(valid_values=['foo', 'bar1'])
|
|
self.assertNotEqual(str(field1), str(field2))
|
|
|
|
def test_without_valid_values(self):
|
|
self.assertRaises(ovo_exc.EnumValidValuesInvalidError,
|
|
fields.EnumField, 1)
|
|
|
|
def test_with_empty_values(self):
|
|
self.assertRaises(ovo_exc.EnumRequiresValidValuesError,
|
|
fields.EnumField, [])
|
|
|
|
|
|
class TestDictOfStrings(TestField):
|
|
def setUp(self):
|
|
super(TestDictOfStrings, self).setUp()
|
|
self.field = fields.DictOfStringsField()
|
|
self.coerce_good_values = [({'foo': 'bar'}, {'foo': 'bar'}),
|
|
({'foo': 1}, {'foo': '1'})]
|
|
self.coerce_bad_values = [{1: 'bar'}, {'foo': None}, 'foo']
|
|
self.to_primitive_values = [({'foo': 'bar'}, {'foo': 'bar'})]
|
|
self.from_primitive_values = [({'foo': 'bar'}, {'foo': 'bar'})]
|
|
|
|
def test_stringify(self):
|
|
self.assertEqual("{key='val'}", self.field.stringify({'key': 'val'}))
|
|
|
|
|
|
class TestInteger(TestField):
|
|
def setUp(self):
|
|
super(TestInteger, self).setUp()
|
|
self.field = fields.IntegerField()
|
|
self.coerce_good_values = [(1, 1), ('1', 1)]
|
|
self.coerce_bad_values = ['foo', None]
|
|
self.to_primitive_values = self.coerce_good_values[0:1]
|
|
self.from_primitive_values = self.coerce_good_values[0:1]
|
|
|
|
|
|
class TestBoolean(TestField):
|
|
def setUp(self):
|
|
super(TestBoolean, self).setUp()
|
|
self.field = fields.BooleanField()
|
|
self.coerce_good_values = [(True, True), (False, False), (1, True),
|
|
('foo', True), (0, False), ('', False)]
|
|
self.coerce_bad_values = []
|
|
self.to_primitive_values = self.coerce_good_values[0:2]
|
|
self.from_primitive_values = self.coerce_good_values[0:2]
|
|
|
|
|
|
class TestDateTime(TestField):
|
|
def setUp(self):
|
|
super(TestDateTime, self).setUp()
|
|
self.dt = datetime.datetime(2016, 11, 5, tzinfo=iso8601.iso8601.Utc())
|
|
self.field = fields.DateTimeField()
|
|
self.coerce_good_values = [(self.dt, self.dt),
|
|
(utils.isotime(self.dt), self.dt)]
|
|
self.coerce_bad_values = [1, 'foo']
|
|
self.to_primitive_values = [(self.dt, utils.isotime(self.dt))]
|
|
self.from_primitive_values = [(utils.isotime(self.dt), self.dt)]
|
|
|
|
def test_stringify(self):
|
|
self.assertEqual(
|
|
'2016-11-05T18:00:00Z',
|
|
self.field.stringify(
|
|
datetime.datetime(2016, 11, 5, 18, 0, 0,
|
|
tzinfo=iso8601.iso8601.Utc())))
|