openstack/deb-python-wsme
Code Issues Proposed changes

Adapt tests and fix remaining issues with the list/dict handling changes

Browse Source
This commit is contained in:
Christophe de Vienne
2012-06-27 16:36:15 +02:00
parent 740868ed82
commit 2665d3a0c9
7 changed files with 49 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
wsme/protocols/commons.py
View File

@@ -3,7 +3,8 @@ import re
from simplegeneric import generic
from wsme.types import iscomplex, list_attributes, Unset, UserType
from wsme.types import iscomplex, list_attributes, Unset
from wsme.types import UserType, ArrayType, DictType
from wsme.utils import parse_isodate, parse_isotime, parse_isodatetime
@@ -59,11 +60,12 @@ def from_params(datatype, params, path, hit_paths):
return Unset
@from_params.when_type(list)
@from_params.when_type(ArrayType)
def array_from_params(datatype, params, path, hit_paths):
if path in params:
return [
from_param(datatype[0], value) for value in params.getall(path)]
from_param(datatype.item_type, value)
for value in params.getall(path)]
else:
indexes = set()
r = re.compile('^%s\[(?P<index>\d+)\]' % re.escape(path))
@@ -79,27 +81,26 @@ def array_from_params(datatype, params, path, hit_paths):
indexes = list(indexes)
indexes.sort()
return [from_params(datatype[0], params,
return [from_params(datatype.item_type, params,
'%s[%s]' % (path, index), hit_paths)
for index in indexes]
@from_params.when_type(dict)
@from_params.when_type(DictType)
def dict_from_params(datatype, params, path, hit_paths):
keys = set()
key_datatype, value_datatype = list(datatype.items())[0]
r = re.compile('^%s\[(?P<key>[a-zA-Z0-9_\.]+)\]' % re.escape(path))
for p in params.keys():
m = r.match(p)
if m:
keys.add(from_param(key_datatype, m.group('key')))
keys.add(from_param(datatype.key_type, m.group('key')))
if not keys:
return Unset
return dict((
(key, from_params(value_datatype,
(key, from_params(datatype.value_type,
params, '%s[%s]' % (path, key), hit_paths))
for key in keys))

20
wsme/protocols/restjson.py
View File

@@ -53,20 +53,20 @@ def bytes_tojson(datatype, value):
return value.decode('ascii')
@tojson.when_type(list)
@tojson.when_type(wsme.types.ArrayType)
def array_tojson(datatype, value):
if value is None:
return None
return [tojson(datatype[0], item) for item in value]
return [tojson(datatype.item_type, item) for item in value]
@tojson.when_type(dict)
@tojson.when_type(wsme.types.DictType)
def dict_tojson(datatype, value):
if value is None:
return None
key_type, value_type = list(datatype.items())[0]
return dict((
(tojson(key_type, item[0]), tojson(value_type, item[1]))
(tojson(datatype.key_type, item[0]),
tojson(datatype.value_type, item[1]))
for item in value.items()
))
@@ -131,20 +131,20 @@ def fromjson(datatype, value):
return value
@fromjson.when_type(list)
@fromjson.when_type(wsme.types.ArrayType)
def array_fromjson(datatype, value):
if value is None:
return None
return [fromjson(datatype[0], item) for item in value]
return [fromjson(datatype.item_type, item) for item in value]
@fromjson.when_type(dict)
@fromjson.when_type(wsme.types.DictType)
def dict_fromjson(datatype, value):
if value is None:
return None
key_type, value_type = list(datatype.items())[0]
return dict((
(fromjson(key_type, item[0]), fromjson(value_type, item[1]))
(fromjson(datatype.key_type, item[0]),
fromjson(datatype.value_type, item[1]))
for item in value.items()))

25
wsme/protocols/restxml.py
View File

@@ -103,27 +103,26 @@ def fromxml(datatype, element):
return datatype(element.text)
@toxml.when_type(list)
@toxml.when_type(wsme.types.ArrayType)
def array_toxml(datatype, key, value):
el = et.Element(key)
if value is None:
el.set('nil', 'true')
else:
for item in value:
el.append(toxml(datatype[0], 'item', item))
el.append(toxml(datatype.item_type, 'item', item))
return el
@toxml.when_type(dict)
@toxml.when_type(wsme.types.DictType)
def dict_toxml(datatype, key, value):
el = et.Element(key)
if value is None:
el.set('nil', 'true')
else:
key_type, value_type = list(datatype.items())[0]
for item in value.items():
key = toxml(key_type, 'key', item[0])
value = toxml(value_type, 'value', item[1])
key = toxml(datatype.key_type, 'key', item[0])
value = toxml(datatype.value_type, 'value', item[1])
node = et.Element('item')
node.append(key)
node.append(value)
@@ -171,21 +170,23 @@ def datetime_toxml(datatype, key, value):
return el
@fromxml.when_type(list)
@fromxml.when_type(wsme.types.ArrayType)
def array_fromxml(datatype, element):
if element.get('nil') == 'true':
return None
return [fromxml(datatype[0], item) for item in element.findall('item')]
return [
fromxml(datatype.item_type, item)
for item in element.findall('item')
]
@fromxml.when_type(dict)
@fromxml.when_type(wsme.types.DictType)
def dict_fromxml(datatype, element):
if element.get('nil') == 'true':
return None
key_type, value_type = list(datatype.items())[0]
return dict((
(fromxml(key_type, item.find('key')),
fromxml(value_type, item.find('value')))
(fromxml(datatype.key_type, item.find('key')),
fromxml(datatype.value_type, item.find('value')))
for item in element.findall('item')))

1
wsme/tests/protocol.py
View File

@@ -300,6 +300,7 @@ class ProtocolTestCase(unittest.TestCase):
def setUp(self):
if self.__class__.__name__ != 'ProtocolTestCase':
self.root = WSTestRoot()
self.root.getapi()
self.root.addprotocol(self.protocol, **self.protocol_options)
self.app = TestApp(wsme.wsgi.adapt(self.root))

2
wsme/tests/test_api.py
View File

@@ -74,6 +74,8 @@ class TestController(unittest.TestCase):
def setcplx(self, obj):
pass
MyWS.add._wsme_definition.resolve_types(wsme.types.registry)
MyWS.setcplx._wsme_definition.resolve_types(wsme.types.registry)
args = MyWS.add._wsme_definition.arguments
assert args[0].name == 'a'

14
wsme/tests/test_protocols_commons.py
View File

@@ -5,7 +5,7 @@ import unittest
from wsme.protocols.commons import from_param, from_params
from wsme.types import UserType, Unset
from wsme.types import UserType, Unset, ArrayType, DictType
class MyUserType(UserType):
@@ -36,15 +36,15 @@ class TestProtocolsCommons(unittest.TestCase):
def getall(self, path):
return ['1', '2']
p = params({'a': []})
assert from_params([int], p, 'a', set()) == [1, 2]
assert from_params(ArrayType(int), p, 'a', set()) == [1, 2]
def test_from_params_empty_array(self):
assert from_params([int], {}, 'a', set()) is Unset
assert from_params(ArrayType(int), {}, 'a', set()) is Unset
def test_from_params_dict(self):
assert from_params({int: str}, {
'a[2]': 'a2', 'a[3]': 'a3'}, 'a', set()) == \
{2: 'a2', 3: 'a3'}
value = from_params(DictType(int, str), {
'a[2]': 'a2', 'a[3]': 'a3'}, 'a', set())
assert value == {2: 'a2', 3: 'a3'}, value
def test_from_params_dict_unset(self):
assert from_params({int: str}, {}, 'a', set()) is Unset
assert from_params(DictType(int, str), {}, 'a', set()) is Unset

9
wsme/types.py
View File

@@ -455,13 +455,18 @@ class Registry(object):
def resolve_type(self, type_):
if isinstance(type_, six.string_types):
return self.lookup(type_)
type_ = self.register(type_)
if isinstance(type_, list):
type_ = ArrayType(type_[0])
if isinstance(type_, dict):
type_ = DictType(type_.keys()[0], type_.values()[0])
if isinstance(type_, ArrayType):
type_ = ArrayType(self.resolve_type(type_.item_type))
if isinstance(type_, DictType):
elif isinstance(type_, DictType):
type_ = DictType(
type_.key_type,
self.resolve_type(type_.value_type))
else:
type_ = self.register(type_)
return type_
# Default type registry