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_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 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 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_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_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 testSerializeDeserialize(self):
serialized = '{"command": "put", "details": {"platform": "fb", "cookie": "cookie1"}}'
j = Json(serialized)
self.assertEqual(serialized, j.dumps())
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_OrigConvertSetToStr(self):
j = Json()
j.st = set((1, 2))
j.toOrig()
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 test_dir_with_members(self):
prop = Json({'__members__': 1})
dir(prop)
self.assertTrue('__members__' in prop.keys())
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})))
