def testSerializeNone(self):
"""Test Serialize()."""
self.assertEqual(
'null',
util.Serialize(None, _use_json=True, _use_pickle=False))
self.assertEqual(
util.pickle.dumps(None),
util.Serialize(None, _use_json=False, _use_pickle=True))
def testSerializeControlChars(self):
"""Test Serialize()."""
input = []
output = []
for x in xrange(0, 31):
input.append(chr(x))
if x == 8:
output.append('\\b')
elif x == 9:
output.append('\\t')
elif x == 10:
output.append('\\n')
elif x == 12:
output.append('\\f')
elif x == 13:
output.append('\\r')
else:
output.append('\\u%04x' % x)
input_str = ''.join(input)
output_str = '"%s"' % ''.join(output)
serialized = util.Serialize(input_str)
self.assertEqual(
output_str,
serialized,
'%s != %s' % (self._DumpStr(output_str), self._DumpStr(serialized)))
def testSerializeUnicode(self):
"""Test Serialize()."""
ustr = u'Hello there\u2014'
ustr_js = '"Hello there\\u2014"'
# javascript uses the same notation as python to represent unicode
# characters.
self.assertEqual(ustr_js, util.Serialize(ustr))
def Serialize(self):
"""Returns a serialized string representation of the entity instance."""
d = {}
for p in self.properties():
d[p] = getattr(self, p)
if p in ['mtime', 'user']:
d[p] = str(d[p])
return util.Serialize(d)
def testGet(self, render_mock, _):
data = {'192.168.1.1': 'zerocool'}
models.KeyValueCache.MemcacheWrappedSet(
'client_exit_ip_blocks', 'text_value', util.Serialize(data))
self.testapp.get('/admin/ip_blacklist', status=httplib.OK)
args = test.GetArgFromCallHistory(render_mock, arg_index=1)
self.assertEquals(data.items(), args['list'])
def SetSerializedItem(cls, key, value):
"""Serializes a value and caches it to an entity with a given key.
Args:
key: str, key_name for the ReportsCache entity.
value: any, a value of any kind to serialize and cache.
"""
value = util.Serialize(value)
cls.MemcacheWrappedSet(key, 'blob_value', value)
def testSerializeJson(self):
"""Test Serialize()."""
self.mox.StubOutWithMock(util.json, 'dumps')
util.json.dumps('object1').AndReturn('serial1')
util.json.dumps('object2').AndRaise(TypeError)
self.mox.ReplayAll()
self.assertEqual('serial1', util.Serialize('object1'))
self.assertRaises(util.SerializeError, util.Serialize, 'object2')
self.mox.VerifyAll()
def _SetUserSettings(self, data):
"""Sets the user settings dictionary.
Args:
data: dictionary data to set to the user_settings, or None.
"""
if not data:
self.user_settings_exist = False
self._user_settings = None
else:
self._user_settings = util.Serialize(data)
self.user_settings_exist = True
def testSerializeFloat(self):
"""Test Serialize()."""
# expected behavior: we can only guarentee this level of precision
# in the unit test because of rounding errors.
#
# GAE's float is capable of 10 digits of precision, and a stock
# python2.6 reports 15 digits from sys.float_info.
input = {'foo': 103.2261}
output = '{"foo": 103.2261}'
self.assertEqual(output, util.Serialize(input))
def testSerializePickle(self):
"""Test Serialize()."""
self.mox.StubOutWithMock(util.pickle, 'dumps')
util.pickle.dumps('object1').AndReturn('serial1')
util.pickle.dumps('object2').AndRaise(util.pickle.PicklingError)
self.mox.ReplayAll()
self.assertEqual(
'serial1',
util.Serialize('object1', _use_json=False, _use_pickle=True))
self.assertRaises(util.SerializeError,
util.Serialize,
'object2',
_use_json=False,
_use_pickle=True)
self.mox.VerifyAll()
def SetSerializedItem(cls, key, value):
"""Serializes a value and caches it to an entity with a given key.
Args:
key: str, key_name for the ReportsCache entity.
value: any, a value of any kind to serialize and cache.
"""
value = util.Serialize(value)
i = 0
while value:
shard = value[:_MEMCACHE_ENTITY_SIZE_LIMIT]
if i == 0:
cls.MemcacheWrappedSet(key, 'blob_value', shard)
else:
cls.MemcacheWrappedSet('%s_shard_%s' % (key, i), 'blob_value',
shard)
i += 1
value = value[_MEMCACHE_ENTITY_SIZE_LIMIT:]
def post(self):
"""POST handler."""
if not self.IsAdminUser():
self.error(httplib.FORBIDDEN)
return
values = self.request.get_all('item_0', None)
comments = self.request.get_all('item_1', None)
if values and (not comments or len(values) != len(comments)):
self.error(httplib.BAD_REQUEST)
return
is_ip = re.compile(IP_REGEX)
if not all(map(is_ip.match, values)):
self.error(httplib.BAD_REQUEST)
self.response.out.write('Malformed IP')
return
ips = dict(zip(values, comments))
models.KeyValueCache.MemcacheWrappedSet('client_exit_ip_blocks',
'text_value',
util.Serialize(ips))
self.redirect('/admin/ip_blacklist?msg=IPs%20saved')
def post(self, group=None):
"""POST handler."""
if not self.IsAdminUser():
self.error(httplib.FORBIDDEN)
return
if group:
values = self.request.get_all('item_0', None)
members = []
is_email = re.compile(MAIL_REGEX)
for member in values:
if is_email.match(member):
members.append(member)
else:
self.error(httplib.BAD_REQUEST)
self.response.out.write('malformed email')
return
models.KeyValueCache.MemcacheWrappedSet(group, 'text_value',
util.Serialize(members))
self.redirect('/admin/acl_groups?msg=Group%20saved')
def testSerializeNone(self):
"""Test Serialize()."""
self.assertEqual('null', util.Serialize(None))
def get_value_for_datastore(self, model_instance):
"""Sends a serialized representation of self._obj to Datastore."""
if self._obj is None:
return None
else:
return db.Text(util.Serialize(self._obj))
def testSerializeJson(self):
"""Test Serialize()."""
with mock.patch.object(util.json, 'dumps', return_value='serial1'):
self.assertEqual('serial1', util.Serialize('object1'))
with mock.patch.object(util.json, 'dumps', side_effect=TypeError):
self.assertRaises(util.SerializeError, util.Serialize, 'object2')
