def createMarkdown(self, page_name, template_block): jsonObj = Json() fi, fname = tempfile.mkstemp() f = os.fdopen(fi, "w") f.write("A First Level Header\n====================\n") f.close() cmd = os.environ.get('VISUAL_EDITOR', 'vi') + ' ' + fname subprocess.call(cmd, shell=True) content = "" with open(fname, 'r') as f: content = f.read() os.unlink(fname) # search for the page name filename = "_content/%s_%s.md" % (page_name.replace("/", "_"), template_block) self.writeMarkdown(content, filename) markdown_block = {template_block:filename} self.writePage(jsonObj.setPageMarkdown(page_name, markdown_block)) print filename
def test_complex_nested_structure(self): prop = Json() prop.a = [(Json(), 2), [[]], [1, (2, 3), 0]] self.assertDictEqual(prop, {'a': [( {}, 2, ), [[]], [1, (2, 3), 0]]})
def test_copy(self): class MyMutableObject(object): def __init__(self): self.attribute = None foo = MyMutableObject() foo.attribute = True a = Json() a.immutable = 42 a.mutable = foo b = a.copy() # immutable object should not change b.immutable = 21 self.assertEqual(a.immutable, 42) # mutable object should change b.mutable.attribute = False self.assertEqual(a.mutable.attribute, b.mutable.attribute) # changing child of b should not affect a b.child = "new stuff" self.assertTrue(isinstance(a.child, Json))
def test_to_dict_with_tuple(self): nested = {'a': ({'a': 0}, {2: 0})} prop = Json(nested) regular = prop.toOrig() self.assertDictEqual(regular, prop) self.assertDictEqual(regular, nested) self.assertIsInstance(regular['a'], tuple) self.assertNotIsInstance(regular['a'][0], Json)
def dump(self): """Formats the time card block to be stored in a JSON document""" return { 'block': { 'date': Json.serialize_date(self.date), 'in_time': Json.serialize_date(self.start_time), 'out_time': Json.serialize_date(self.end_time) } }
def test_update_with_lists(self): org = Json() org.a = [1, 2, {'a': 'superman'}] someother = Json() someother.b = [{'b': 123}] org.update(someother) correct = {'a': [1, 2, {'a': 'superman'}], 'b': [{'b': 123}]} org.update(someother) self.assertDictEqual(org, correct) self.assertIsInstance(org.b[0], Json)
def test_to_dict(self): nested = {'a': [{'a': 0}, 2], 'b': {}, 'c': 2} prop = Json(nested) regular = prop.toOrig() self.assertDictEqual(regular, prop) self.assertDictEqual(regular, nested) self.assertNotIsInstance(regular, Json) with self.assertRaises(AttributeError): regular.a def get_attr_deep(): return regular['a'][0].a self.assertRaises(AttributeError, get_attr_deep)
def log(e, pretty=True, outfile=None): if isinstance(e, basestring) or isinstance(e, types.ListType) or isinstance(e, types.DictType): try: """ json doesn't like tuple keys """ msg = Json.pretty(e) if pretty else Json.compact(e) except: msg = str(e) else: msg = str(entry) if outfile: Cmn.cat(outfile, [msg]) else: sys.stderr.write('{1}:{1}\n'.format(Cmn.now(), msg)) return msg
def log(e, pretty=True, outfile=None): if isinstance(e, basestring) or isinstance( e, types.ListType) or isinstance(e, types.DictType): try: """ json doesn't like tuple keys """ msg = Json.pretty(e) if pretty else Json.compact(e) except: msg = str(e) else: msg = str(entry) if outfile: Cmn.cat(outfile, [msg]) else: sys.stderr.write('{1}:{1}\n'.format(Cmn.now(), msg)) return msg
def test_update(self): old = Json() old.child.a = 'old a' old.child.b = 'old b' old.foo = 'no dict' new = Json() new.child.b = 'new b' new.child.c = 'new c' new.foo.now_my_papa_is_a_dict = True old.update(new) reference = {'foo': {'now_my_papa_is_a_dict': True}, 'child': {'c': 'new c', 'b': 'new b'}} self.assertDictEqual(old, reference)
class Codec(): def __init__(self): self.json = Json() self.parity = Parity() self.kiss = Kiss() ''' Encode object to byte array ''' def encode(self, obj): return self.kiss.encode(self.parity.encode(self.json.encode(obj))) ''' Decode byte array to array of zero or more objects ''' def decode(self, data): return [ self.json.decode(self.parity.decode(frame)) for frame in self.kiss.decode(data) ]
def test_strBasics(self): self.assertEqual(json.dumps({"a": "4"}, separators=(',', ':')), str(Json({"a": "4"}))) self.assertEqual( json.dumps(dict((("a", 2), (3, 4), ("d", { "d2": 4 }))), separators=(',', ':'), sort_keys=True), str(Json((("a", 2), (3, 4), ("d", { "d2": 4 }))))) self.assertEqual( json.dumps(dict((("a", 2), (3, 4), ("d", { "d2": 4 }))), separators=(',', ':'), sort_keys=True), str(self.d))
def test_set_prop_invalid(self): prop = Json() def set_keys(): prop.keys = 2 def set_items(): prop.items = 3 self.assertRaises(AttributeError, set_keys) self.assertRaises(AttributeError, set_items) self.assertDictEqual(prop, {})
def testIteritems(self): b = self.d.iteritems().toList() self.assertEqual(self.d.iteritems().toList(), self.d.toList()) self.assertEqual(b[2][1].d2, 4) self.assertIsInstance(b[2][1], Json) self.assertIsInstance(self.d.iteritems(), stream) self.assertEqual(self.d.iteritems().toList(), [('a', 2), (3, 4), ('d', { 'd2': 4 })]) self.assertEqual(self.d.iteritems()[2][1].d2, 4) self.assertIsInstance(self.d.iteritems(), stream) self.assertEquals(self.d.iteritems().sorted().toList(), [(3, 4), ('a', 2), ('d', { 'd2': 4 })]) self.assertEqual(Json({1: 1, 2: 2, 3: 3}).itervalues().sum(), 6)
class JsonTest(unittest.TestCase): my_json = Json() def test_dumps_escape_sequences(self): data = ESCAPE_SEQUENCES result = self.my_json.dumps(data) self.assertEqual(result, json.dumps(data)) def test_loads_escape_sequences(self): data = json.dumps(ESCAPE_SEQUENCES) result = Json.loads(data) self.assertEqual(result, json.loads(data)) def test_dump_collections(self): for i in COLLECTIONS: self.assertEqual(self.my_json.dumps(i), json.dumps(i)) def test_load_collections(self): for i in COLLECTIONS: data = json.dumps(i) self.assertEqual(Json.loads(data), json.loads(data)) def test_dump_failed_collection(self): with self.assertRaises(TypeError): self.my_json.dumps(FAILED_COLLECTION) def test_load_failed_json(self): with self.assertRaises(TypeError): Json.loads(FAILED_JSON) def test_dump_boolean(self): data = BOOLEAN_NONE result = self.my_json.dumps(data) self.assertEqual(result, json.dumps(data)) def test_load_boolean(self): data = BOOLEAN_NONE result = self.my_json.loads(json.dumps(data)) self.assertEqual(result, data)
def test_update(self): old = Json() old.child.a = 'old a' old.child.b = 'old b' old.foo = 'no dict' new = Json() new.child.b = 'new b' new.child.c = 'new c' new.foo.now_my_papa_is_a_dict = True old.update(new) reference = { 'foo': { 'now_my_papa_is_a_dict': True }, 'child': { 'c': 'new c', 'b': 'new b' } } self.assertDictEqual(old, reference)
def __init__(self): self.json = Json() self.parity = Parity() self.kiss = Kiss()
def test_load_failed_json(self): with self.assertRaises(TypeError): Json.loads(FAILED_JSON)
def test_loads_escape_sequences(self): data = json.dumps(ESCAPE_SEQUENCES) result = Json.loads(data) self.assertEqual(result, json.loads(data))
def testSerializeDeserialize(self): serialized = '{"command": "put", "details": {"platform": "fb", "cookie": "cookie1"}}' j = Json(serialized) self.assertEqual(serialized, j.dumps())
def setTemplate(self, page_name, template_filename): jsonObj = Json() self.writePage(jsonObj.setPageTemplate(page_name, template_filename))
def test_delitem_nested(self): prop = Json(TEST_DICT) del prop['a']['b']['c'] self.assertDictEqual(prop, {'a': {'b': {}}})
def test_OrigConvertSetToStr(self): j = Json() j.st = set((1, 2)) j.toOrig()
def testJsonList(self): jlist = Json({'a': [1, 2, {'b': [{'c': 3}, {'d': 4}]}]}) self.assertEqual(jlist.a[2], {'b': [{'c': 3}, {'d': 4}]}) self.assertEqual(jlist.a[2].b[1].d, 4)
def test_tuple_key(self): prop = Json() prop[(1, 2)] = 2 self.assertDictEqual(prop, {(1, 2): 2}) self.assertEqual(prop[(1, 2)], 2)
def testSpecialKeys(self): d = Json((("__init__", 2), (3, 4), ("d", {"d2": 4}))) self.assertEqual(d["__init__"], 2) self.assertNotEquals(d.__init__, 2) self.assertIsInstance(d.__init__, types.MethodType)
def testUpdateItems(self): d = Json((("a", 2), (3, 4), ("d", {"d2": 4}))) d.d.d2 = 3 self.assertEqual(d.d.d2, 3)
def test_dir_with_members(self): prop = Json({'__members__': 1}) dir(prop) self.assertTrue('__members__' in prop.keys())
def test_delattr_nested(self): prop = Json(TEST_DICT) del prop.a.b.c self.assertDictEqual(prop, {'a': {'b': {}}})
def test_delattr(self): prop = Json({'a': 2}) del prop.a self.assertDictEqual(prop, {})
def test_delitem(self): prop = Json({'a': 2}) del prop['a'] self.assertDictEqual(prop, {})
def test_delitem_delattr(self): prop = Json(TEST_DICT) del prop.a['b'] self.assertDictEqual(prop, {'a': {}})
def test_set_one_level_property(self): prop = Json() prop.a = TEST_VAL self.assertDictEqual(prop, {'a': TEST_VAL})
class JsonTestCase(unittest.TestCase): def setUp(self): self.d = Json((("a", 2), (3, 4), ("d", {"d2": 4}))) def testConstructor(self): self.assertEqual(Json('{"a":2,"4":"5"}'), {"a": 2, "4": "5"}) def testBase(self): self.assertEqual(self.d.a, 2) self.assertEqual(self.d["a"], 2) self.assertEqual(self.d.b.c, {}) self.assertEqual(self.d.d.d2, 4) self.assertIsInstance(self.d.keys(), slist) self.assertIsInstance(self.d.iterkeys(), stream) self.assertIsInstance(self.d.itervalues(), stream) def test_strReturnsSortedMap(self): self.assertEqual('{"4":3,"a":"4"}', str(Json({"a": "4", 4: 3}))) def test_strBasics(self): self.assertEqual(json.dumps({"a": "4"}, separators=(',', ':')), str(Json({"a": "4"}))) self.assertEqual(json.dumps(dict((("a", 2), (3, 4), ("d", {"d2": 4}))), separators=(',', ':'), sort_keys=True), str(Json((("a", 2), (3, 4), ("d", {"d2": 4}))))) self.assertEqual(json.dumps(dict((("a", 2), (3, 4), ("d", {"d2": 4}))), separators=(',', ':'), sort_keys=True), str(self.d)) def testUpdateItems(self): d = Json((("a", 2), (3, 4), ("d", {"d2": 4}))) d.d.d2 = 3 self.assertEqual(d.d.d2, 3) def testSpecialKeys(self): d = Json((("__init__", 2), (3, 4), ("d", {"d2": 4}))) self.assertEqual(d["__init__"], 2) self.assertNotEquals(d.__init__, 2) self.assertIsInstance(d.__init__, types.MethodType) def testIteritems(self): b = self.d.iteritems().toList() self.assertEqual(self.d.iteritems().toList(), self.d.toList()) self.assertEqual(b[2][1].d2, 4) self.assertIsInstance(b[2][1], Json) self.assertIsInstance(self.d.iteritems(), stream) self.assertEqual(self.d.iteritems().toList(), [('a', 2), (3, 4), ('d', {'d2': 4})]) self.assertEqual(self.d.iteritems()[2][1].d2, 4) self.assertIsInstance(self.d.iteritems(), stream) self.assertEquals(self.d.iteritems().sorted().toList(), [(3, 4), ('a', 2), ('d', {'d2': 4})]) self.assertEqual(Json({1: 1, 2: 2, 3: 3}).itervalues().sum(), 6) def testJsonList(self): jlist = Json({'a': [1, 2, {'b': [{'c': 3}, {'d': 4}]}]}) self.assertEqual(jlist.a[2], {'b': [{'c': 3}, {'d': 4}]}) self.assertEqual(jlist.a[2].b[1].d, 4) def testJsonSetValues(self): self.d.c = "set" self.assertEqual(self.d.c, "set") def test_OrigConvertSetToStr(self): j = Json() j.st = set((1, 2)) j.toOrig() def testSerializeDeserialize(self): serialized = '{"command": "put", "details": {"platform": "fb", "cookie": "cookie1"}}' j = Json(serialized) self.assertEqual(serialized, j.dumps())
def setUp(self): self.d = Json((("a", 2), (3, 4), ("d", {"d2": 4})))
def test_load_collections(self): for i in COLLECTIONS: data = json.dumps(i) self.assertEqual(Json.loads(data), json.loads(data))
def test_complex_nested_structure(self): prop = Json() prop.a = [(Json(), 2), [[]], [1, (2, 3), 0]] self.assertDictEqual(prop, {'a': [({}, 2,), [[]], [1, (2, 3), 0]]})
def createRootPage(self, page_name): jsonObj = Json() self.writePage(jsonObj.createRootPage(page_name))
def toJson(self): from Json import Json return Json(self)
def test_strReturnsSortedMap(self): self.assertEqual('{"4":3,"a":"4"}', str(Json({"a": "4", 4: 3})))