def test_deserialise(self):
desA = IDeserializer(schema.Object(schema=ITestObjectA))
desB = IDeserializer(schema.Object(schema=ITestObjectB))
obj = self.deserialize(desA, dict(fish=u'moo'))
self.assertEqual(obj.__class__, TestObjectA)
self.assertEqual(obj.fish, u'moo')
# We recurseivly deserialize
obj = self.deserialize(desB, dict(
title=u'A nice section',
cowtent=dict(data=u'Some nice text', contenttype='scroll/dead-sea')
))
self.assertEqual(obj.__class__, TestObjectB)
self.assertEqual(obj.title, u'A nice section')
self.assertEqual(obj.cowtent.__class__, RichTextValue)
self.assertEqual(obj.cowtent.raw, u'Some nice text')
self.assertEqual(obj.cowtent.mimeType, 'scroll/dead-sea')
# Missing values are okay
obj = self.deserialize(desB, dict(
title=u'Another section',
))
self.assertEqual(obj.__class__, TestObjectB)
self.assertEqual(obj.title, u'Another section')
self.assertEqual(obj.cowtent.__class__, RichTextValue)
self.assertEqual(obj.cowtent.raw, u'')
self.assertEqual(obj.cowtent.mimeType, 'text/html')
def test_datetime_deserializer(self):
deserializer = IDeserializer(Datetime())
value = deserializer('2015-12-31 17:59:59', None, None)
self.assertEqual(
datetime(2015, 12, 31, 17, 59, 59),
value
)
def __call__(self,
value,
filestore,
item,
disable_constraints=False,
logger=None):
field = self.field
if value in (None, ''):
return []
if isinstance(value, basestring):
value = [v for v in (v.strip() for v in value.split(';')) if v]
if field.value_type is not None:
deserializer = IDeserializer(self.field.value_type)
else:
deserializer = DefaultDeserializer(None)
value = [
deserializer(v,
filestore,
item,
disable_constraints,
logger=logger) for v in value
]
value = field._type(value)
try:
self.field.validate(value)
except Exception as e:
if not disable_constraints:
raise e
else:
if logger:
logger("%s is invalid in %s: %s" %
(self.field.__name__, item['_path'], e))
return value
def test_datetime_deserializer_for_not_required_datetime(self):
field = Datetime()
field.required = False
deserializer = IDeserializer(field)
value = deserializer('None', None, None)
self.assertEqual(None, value)
def test_deserialize_relation(self):
folder = create(Builder('folder'))
deserializer = IDeserializer(self.relation)
value = deserializer(folder, None, None)
self.assertTrue(isinstance(value, RelationValue))
self.assertEqual(folder, value.to_object)
def test_serialize(self):
desB = IDeserializer(schema.Object(schema=ITestObjectB))
serA = ISerializer(schema.Object(schema=ITestObjectA))
serB = ISerializer(schema.Object(schema=ITestObjectB))
obj = TestObjectA()
obj.fish = u"haddock"
self.assertEqual(serA(obj, None), dict(
_class="transmogrify.dexterity.tests.testconverters_object.TestObjectA",
fish=u"haddock",
))
# Recurse into attributes
filestore = {}
obj = desB(dict(
title=u'A hairy section',
cowtent=dict(data=u'Some nice text', contenttype='scroll/dead-sea'),
_class="transmogrify.dexterity.tests.testconverters_object.TestObjectB",
), filestore, None)
self.assertEqual(serB(obj, filestore), dict(
_class="transmogrify.dexterity.tests.testconverters_object.TestObjectB",
title=u'A hairy section',
cowtent=dict(
file='_field_cowtent_cowtent',
encoding='utf-8',
contenttype='scroll/dead-sea',
),
))
def test_deserialize_relation_list(self):
folder = create(Builder('folder'))
deserializer = IDeserializer(self.relation_list)
value = deserializer([folder], None, None)
self.assertEqual(1, len(value))
self.assertTrue(isinstance(value[0], RelationValue))
self.assertEqual(folder, value[0].to_object)
def test_unicode_string(self):
"""Test that a unicode value gets passed through without
additional decoding"""
rtd = IDeserializer(RichText())
rtv = rtd(u"café culture", None, None)
self.assertEqual(rtv.raw, u"café culture")
self.assertEqual(rtv.raw_encoded, "caf\xc3\xa9 culture")
self.assertEqual(rtv.outputMimeType, "text/x-html-safe")
self.assertEqual(rtv.mimeType, "text/html")
self.assertEqual(rtv.encoding, "utf-8")
def test_string(self):
"""Test default options, should be able to produce an encoded UTF-8
string of bytes"""
rtd = IDeserializer(RichText())
rtv = rtd("café culture", None, None)
self.assertEqual(rtv.raw, u"café culture")
self.assertEqual(rtv.raw_encoded, "caf\xc3\xa9 culture")
self.assertEqual(rtv.outputMimeType, "text/x-html-safe")
self.assertEqual(rtv.mimeType, "text/html")
self.assertEqual(rtv.encoding, "utf-8")
def test_setting_mime_type(self):
"""Test that RichText mime type options affect the RichTextValue"""
rtd = IDeserializer(
RichText(default_mime_type='text/xml',
output_mime_type='x-application/pony'))
rtv = rtd("café culture", None, None)
self.assertEqual(rtv.raw, u"café culture")
self.assertEqual(rtv.raw_encoded, "caf\xc3\xa9 culture")
self.assertEqual(rtv.outputMimeType, "x-application/pony")
self.assertEqual(rtv.mimeType, "text/xml")
self.assertEqual(rtv.encoding, "utf-8")
def test_dict_encoding(self):
"""Try using a dict value, ensure that we can override the MIME type"""
rtd = IDeserializer(RichText(default_mime_type='text/csv'))
rtv = rtd({
'data': "caf\xe9 culture",
'encoding': "latin-1",
}, None, None)
self.assertEqual(rtv.raw, u"café culture")
self.assertEqual(rtv.raw_encoded, "caf\xe9 culture")
self.assertEqual(rtv.outputMimeType, "text/x-html-safe")
self.assertEqual(rtv.mimeType, "text/csv")
self.assertEqual(rtv.encoding, "latin-1")
def test_dict_unicode(self):
"""Try using a dict value, ensure that a unicode string passed through
and can be decoded properly"""
rtd = IDeserializer(RichText(default_mime_type='text/csv'))
rtv = rtd({
'data': u"café culture",
'encoding': "latin-1",
}, None, None)
self.assertEqual(rtv.raw, u"café culture")
self.assertEqual(rtv.raw_encoded, "caf\xe9 culture")
self.assertEqual(rtv.outputMimeType, "text/x-html-safe")
self.assertEqual(rtv.mimeType, "text/csv")
self.assertEqual(rtv.encoding, "latin-1")
def test_dict_overrides(self):
"""Try using a dict value, ensure that we can override the MIME type,
and that the MIME type is converted to a string"""
rtd = IDeserializer(RichText(default_mime_type='text/csv'))
rtv = rtd(
{
'contenttype': u"x-application/pony",
'data': "café culture",
}, None, None)
self.assertEqual(rtv.raw, u"café culture")
self.assertEqual(rtv.raw_encoded, "caf\xc3\xa9 culture")
self.assertEqual(rtv.outputMimeType, "text/x-html-safe")
self.assertEqual(rtv.mimeType, "x-application/pony",
"Content type from dict should override default")
self.assertEqual(rtv.encoding, "utf-8")
def test_failures(self):
desA = IDeserializer(schema.Object(schema=ITestObjectA))
# Have to provide something
with self.assertRaisesRegexp(ValueError, "dict"):
desA(None, None, None)
# Dict needs to provide class
with self.assertRaisesRegexp(ValueError, "_class"):
desA(dict(), None, None)
# _class needs to implement ITestObjectA
with self.assertRaisesRegexp(ValueError, "TestObjectDeserializer"):
desA(dict(_class="transmogrify.dexterity.tests.testconverters_object.TestObjectDeserializer"), None, None)
# Extra values not allowed
with self.assertRaisesRegexp(ValueError, "fart"):
self.deserialize(desA, dict(fish=u'moo', fart="yes"))
def test_filestore(self):
"""Try using a dict with a filestore"""
rtd = IDeserializer(RichText(default_mime_type='text/csv'))
rtv = rtd({
'contenttype': "x-application/cow",
'data': "caf\xe9 culture",
'file': 'my-lovely-file',
'encoding': "latin-1",
}, {
'my-lovely-file': {'data': "greasy spoon"},
}, None)
self.assertEqual(rtv.raw, u"greasy spoon")
self.assertEqual(rtv.raw_encoded, "greasy spoon")
self.assertEqual(rtv.outputMimeType, "text/x-html-safe")
self.assertEqual(
rtv.mimeType,
"x-application/cow",
"Content type from dict should override default")
self.assertEqual(rtv.encoding, "latin-1")
def get_value_from_pipeline(self, field, item):
name = field.getName()
# setting value from the blueprint cue
value = item.get(name, _marker)
if value is _marker:
# Also try _datafield_FIELDNAME structure from jsonify
value = item.get('_datafield_%s' % name, _marker)
if value is not _marker:
# Value was given in pipeline, so set it
deserializer = IDeserializer(field)
if IRichText.providedBy(field)\
and '_content_type_%s' % name in item:
# change jsonify structure to one we understand
value = {
'contenttype': item['_content_type_%s' % name],
'data': value
}
files = item.setdefault(self.fileskey, {})
value = deserializer(value,
files,
item,
self.disable_constraints,
logger=self.log)
return value
def test_deserialize_non_int_id_relation_list(self):
deserializer = IDeserializer(self.relation_list)
value = deserializer(["foo"], None, None)
self.assertEqual(1, len(value))
self.assertEqual(["foo"], value)
def test_deserialize_none_relation_list(self):
deserializer = IDeserializer(self.relation_list)
value = deserializer(None, None, None)
self.assertEqual(0, len(value))
self.assertEqual([], value)
def test_deserialize_non_int_id_relation(self):
deserializer = IDeserializer(self.relation)
value = deserializer("bar", None, None)
self.assertEqual("bar", value)
def test_deserialize_none_relation(self):
deserializer = IDeserializer(self.relation)
value = deserializer(None, None, None)
self.assertIsNone(value)
def __call__(self,
value,
filestore,
item,
disable_constraints=False,
logger=None):
if not isinstance(value, dict):
raise ValueError('Need a dict to convert')
if not value.get('_class', None):
try:
# NB: datagridfield creates it's own Serializer, but falls
# back to this Deserializer. _class will be missing in this
# case.
from collective.z3cform.datagridfield.row import DictRow
if isinstance(self.field, DictRow):
# NB: Should be recursing into the dict and deserializing,
# but that can be fixed within datagridfield
return DefaultDeserializer(self.field)(
value,
filestore,
item,
disable_constraints=disable_constraints,
logger=logger,
)
except ImportError:
pass
raise ValueError("_class is missing")
# Import _class and create instance, if it implments what we need
klass = resolve(value['_class'])
if not self.field.schema.implementedBy(klass):
raise ValueError('%s does not implemement %s' % (
value['_class'],
self.field.schema,
))
instance = klass()
# Add each key from value to instance
for (k, v) in value.items():
if k == '_class':
continue
if not hasattr(instance, k):
raise ValueError("%s is not an object attribute" % k)
if v is None:
setattr(instance, k, None)
continue
if k in self.field.schema:
deserializer = IDeserializer(self.field.schema[k])
else:
deserializer = DefaultDeserializer(None)
setattr(
instance, k,
deserializer(
v,
filestore,
item,
disable_constraints=disable_constraints,
logger=logger,
))
if not disable_constraints:
self.field.validate(instance)
return instance
def test_date_deserializer(self):
deserializer = IDeserializer(Date())
value = deserializer('2015-12-31', None, None)
self.assertEqual(datetime.date(datetime(2015, 12, 31)), value)
value = deserializer('2015/12/31', None, None)
self.assertEqual(datetime.date(datetime(2015, 12, 31)), value)
def __iter__(self):
for item in self.previous:
pathkey = self.pathkey(*item.keys())[0]
# not enough info
if not pathkey:
yield item
continue
path = item[pathkey]
# Skip the Plone site object itself
if not path:
yield item
continue
obj = self.context.unrestrictedTraverse(path.encode().lstrip('/'),
None)
# path doesn't exist
if obj is None:
yield item
continue
if IDexterityContent.providedBy(obj):
uuid = item.get('plone.uuid')
if uuid is not None:
try:
IMutableUUID(obj).set(str(uuid))
except:
self.errored.append(item['_original_path'])
files = item.setdefault(self.fileskey, {})
# For all fields in the schema, update in roughly the same way
# z3c.form.widget.py would
for schemata in iterSchemata(obj):
for name, field in getFieldsInOrder(schemata):
if name == 'id':
continue
if field.readonly:
continue
#setting value from the blueprint cue
value = item.get(name, _marker)
if value is not _marker:
# Value was given in pipeline, so set it
deserializer = IDeserializer(field)
value = deserializer(
value,
files,
item,
self.disable_constraints,
logger=self.log,
)
field.set(field.interface(obj), value)
continue
# Get the widget's current value, if it has one then leave
# it alone
value = getMultiAdapter(
(obj, field), interfaces.IDataManager).query()
if not (value is field.missing_value
or value is interfaces.NO_VALUE):
continue
# Finally, set a default value if nothing is set so far
default = queryMultiAdapter(
(
obj,
obj.REQUEST, # request
None, # form
field,
None, # Widget
),
interfaces.IValue,
name='default')
if default is not None:
default = default.get()
if default is None:
default = getattr(field, 'default', None)
if default is None:
try:
default = field.missing_value
except AttributeError:
pass
field.set(field.interface(obj), default)
try:
notify(ObjectModifiedEvent(obj))
except:
print 'Error probably in linkintegrity transform'
yield item
