Support revisions with str type for try jobs.

tests/model_test.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Unit tests for model.py."""
 
 import json
 import logging
 import os
@@ skipping 53 matching lines @@
   j = set
   # k is not a type so it's not serialized.
   k = 23
 
 
 class TypeOrDict(PersistentMixIn):
   # Accepts a Basic or a dict.
   l = (Basic, dict)
 
 
-class StrDisallowed(PersistentMixIn):
+class StrAllowed(PersistentMixIn):
   m = str
 
 
 def marshall(data):
   """JSON encodes then decodes to make sure the data has passed through JSON
   type reduction.
   """
   return json.loads(json.dumps(data))
 
 
@@ skipping 136 matching lines @@
     data = TypeOrDict(l={'foo': u'bar'})
     self._check(data, TypeOrDict, l={'foo': u'bar'})
     expected = {
       'l': {
         'foo': 'bar',
       },
       TYPE_FLAG: 'TypeOrDict',
     }
     self.assertEqual(expected, data.as_dict())
 
-  def testStrDisallowed(self):
-    self.assertRaises(TypeError, StrDisallowed)
+  def testStrAllowed(self):
+    data = StrAllowed(m='foo')
+    expected = {
+        'm': 'foo',
+        TYPE_FLAG: 'StrAllowed',
+    }
+    self.assertEqual(expected, data.as_dict())
 
 
 class Deserialize(Base):
   def testNotFound(self):
     data = { TYPE_FLAG: 'DoesNotExists' }
     self.assertRaises(KeyError, PersistentMixIn.from_dict, marshall(data))
 
   def testEmpty(self):
     data = { }
     self.assertRaises(KeyError, PersistentMixIn.from_dict, marshall(data))
@@ skipping 127 matching lines @@
   def testTypeOrDict_dict(self):
     data  = {
       'l': {
         'foo': 'bar',
       },
       TYPE_FLAG: 'TypeOrDict',
     }
     actual = PersistentMixIn.from_dict(marshall(data))
     self._check(actual, TypeOrDict, l={'foo': 'bar'})
 
-  def testStrDisallowed(self):
+  def testStrAllowed(self):
     data  = {
-      TYPE_FLAG: 'StrDisallowed',
+      'm': 'bar',
+      TYPE_FLAG: 'StrAllowed',
     }
-    self.assertRaises(TypeError, PersistentMixIn.from_dict, marshall(data))
+    actual = PersistentMixIn.from_dict(marshall(StrAllowed(m='bar')))
+    self._check(actual, StrAllowed, m='bar')
 
 
 class Mutable(object):
   def __init__(self, x):
     self.x = x
 
   @immutable
   def func_call_immutable_deep(self):
     return self.func_call_immutable()
 
@@ skipping 98 matching lines @@
     self.assertEqual(3, obj.property_y)
     self.assertEqual(3, obj.func_call_property())
     self.assertEqual(2, obj.x)
 
 
 if __name__ == '__main__':
   logging.basicConfig(
       level=logging.DEBUG if '-v' in sys.argv else logging.WARNING,
       format='%(levelname)5s %(module)15s(%(lineno)3d): %(message)s')
   unittest.main()