def test_simple_rule(): # skip this test if simplegeneric is not installed try: import simplegeneric except ImportError: return # create a Person instance p = Person('Jonathan', 'LaCour') # encode the object using the existing "default" rules result = loads(encode(p)) assert result['first_name'] == 'Jonathan' assert result['last_name'] == 'LaCour' assert len(result) == 2 # register a generic JSON rule @jsonify.when_type(Person) def jsonify_person(obj): return dict( name=obj.name ) # encode the object using our new rule result = loads(encode(p)) assert result['name'] == 'Jonathan LaCour' assert len(result) == 1
def test_detached_saobj(): s = create_session() t = s.query(Test1).get(1) # ensure it can be serialized now jsonify.encode(t) s.expunge(t) assert_raises(ValueError, lambda: jsonify.encode(t))
def test_simple_rule(): # skip this test if simplegeneric is not installed try: import simplegeneric except ImportError: return # create a Person instance p = Person('Jonathan', 'LaCour') # encode the object using the existing "default" rules result = loads(encode(p)) assert result['first_name'] == 'Jonathan' assert result['last_name'] == 'LaCour' assert len(result) == 2 # register a generic JSON rule @jsonify.when_type(Person) def jsonify_person(obj): return dict(name=obj.name) # encode the object using our new rule result = loads(encode(p)) assert result['name'] == 'Jonathan LaCour' assert len(result) == 1
def test_explicit_saobj(): s = create_session() t = s.query(Test3).get(1) encoded = jsonify.encode(t) expected = json.loads('{"id": 1, "val": "bob", "customized": true}') result = json.loads(encoded) assert result == expected, encoded
def test_saobj(): s = create_session() t = s.query(Test1).get(1) encoded = jsonify.encode(t) expected = json.loads('{"id": 1, "val": "bob"}') result = json.loads(encoded) assert result == expected, encoded
def test_simple_rule(): # create a Person instance p = Person("Jonathan", "LaCour") # encode the object using the existing "default" rules result = loads(encode(p)) assert result["first_name"] == "Jonathan" assert result["last_name"] == "LaCour" assert len(result) == 2 person_encoder = JSONEncoder(custom_encoders={Person: lambda p: dict(name=p.name)}) # encode the object using our new rule result = loads(encode(p, encoder=person_encoder)) assert result["name"] == "Jonathan LaCour" assert len(result) == 1
def render_json(template_name, template_vars, **render_params): key = render_params.pop('key', None) if key is not None: template_vars = template_vars[key] encode = JSONRenderer._get_configured_encode(render_params) return encode(template_vars)
def test_select_rows(): s = create_session() t = test2.select().execute() encoded = jsonify.encode(dict(results=t)) expected = json.loads("""{"results": {"count": -1, "rows": [{"count": 1, "rows": {"test1id": 1, "id": 1, "val": "fred"}}, {"count": 1, "rows": {"test1id": 1, "id": 2, "val": "alice"}}]}}""") result = json.loads(encoded) assert result == expected, encoded
def test_nospecificjson(): b = Baz() try: encoded = jsonify.encode(b) except TypeError as e: pass assert "is not JSON serializable" in e.message
def test_salist(): s = create_session() t = s.query(Test1).get(1) encoded = jsonify.encode(dict(results=t.test2s)) expected = json.loads('''{"results": [{"test1id": 1, "id": 1, "val": "fred"}, {"test1id": 1, "id": 2, "val": "alice"}]}''') result = json.loads(encoded) assert result == expected, encoded
def test_datetime_time_iso(): isodates_encoder = jsonify.JSONEncoder(isodates=True) d = datetime.utcnow().time() encoded = jsonify.encode({'date': d}, encoder=isodates_encoder) isoformat_without_millis = json.dumps({'date': d.isoformat()[:8]}) assert isoformat_without_millis == encoded, (isoformat_without_millis, encoded)
def test_simple_rule(): # create a Person instance p = Person('Jonathan', 'LaCour') # encode the object using the existing "default" rules result = loads(encode(p)) assert result['first_name'] == 'Jonathan' assert result['last_name'] == 'LaCour' assert len(result) == 2 person_encoder = JSONEncoder( custom_encoders={Person: lambda p: dict(name=p.name)}) # encode the object using our new rule result = loads(encode(p, encoder=person_encoder)) assert result['name'] == 'Jonathan LaCour' assert len(result) == 1
def render_jsonp(template_name, template_vars, **kwargs): pname = kwargs.get('callback_param', 'callback') callback = tg.request.GET.get(pname) if callback is None: raise HTTPBadRequest('JSONP requires a "%s" parameter with callback name' % pname) values = encode(template_vars) return '%s(%s);' % (callback, values)
def test_select_rows(): s = create_session() t = test2.select().execute() encoded = jsonify.encode(t) # this may be added back later # assert encoded == '{"count": -1, "rows": [{"count": 1, "rows": {"test1id": 1, "id": 1, "val": "fred"}},\ {"count": 1, "rows": {"test1id": 1, "id": 2, "val": "alice"}}]}', encoded
def test_objectid(): try: from bson import ObjectId except: raise SkipTest() d = ObjectId('507f1f77bcf86cd799439011') encoded = jsonify.encode({'oid':d}) assert encoded == '{"oid": "%s"}' % d, encoded
def test_select_rows_datetime(): s = create_session() t = test5.select().execute() encoded = jsonify.encode(dict(results=t), encoder=jsonify.JSONEncoder(isodates=True)) expected = """{"results": {"count": -1, "rows": [{"count": 1, "rows": {"date": "2016-12-11T10:09:08", "id": 1, "val": "sometime", "time": "21:20:19"}}]}}""" encoded = json.loads(encoded) expected = json.loads(expected) assert encoded == expected, encoded
def test_salist(): s = create_session() t = s.query(Test1).get(1) encoded = jsonify.encode(dict(results=t.test2s)) expected = json.loads( '''{"results": [{"test1id": 1, "id": 1, "val": "fred"}, {"test1id": 1, "id": 2, "val": "alice"}]}''' ) result = json.loads(encoded) assert result == expected, encoded
def test_objectid(): try: from bson import ObjectId except: raise SkipTest() d = ObjectId('507f1f77bcf86cd799439011') encoded = jsonify.encode({'oid': d}) assert encoded == '{"oid": "%s"}' % d, encoded
def test_select_rows(): s = create_session() t = test2.select().execute() encoded = jsonify.encode(dict(results=t)) expected = json.loads( """{"results": {"count": -1, "rows": [{"count": 1, "rows": {"test1id": 1, "id": 1, "val": "fred"}}, {"count": 1, "rows": {"test1id": 1, "id": 2, "val": "alice"}}]}}""" ) result = json.loads(encoded) assert result == expected, encoded
def _get_configured_encode(options): # Caching is not supported by JSON encoders options.pop('cache_expire', None) options.pop('cache_type', None) options.pop('cache_key', None) if not options: return encode else: return lambda obj: encode(obj, JSONEncoder(**options))
def test_some(self): # fields = exclude_fields(Transaction, [Transaction.user, Transaction._user_id, Transaction.expenseTagGroup_id, Transaction.incomeTagGroup_id, Transaction.expenseTagGroup, Transaction.incomeTagGroup]) transactions = DBSession.query(Transaction).options( subqueryload(Transaction.incomeTagGroup).subqueryload(TagGroup.tags), subqueryload(Transaction.expenseTagGroup).subqueryload(TagGroup.tags) ).all() transaction_json = jsonify.encode(dict(transactions=transactions)) parsed = json.loads(transaction_json) print(json.dumps(parsed, indent=2, sort_keys=True), len(transactions))
def calculate_hash(e): prop_names = [ prop.name for prop in mapper(e).properties if isinstance(prop, ming.odm.property.FieldProperty) ] for attr in ["hash", "_id", "tags"]: if attr in prop_names: prop_names.remove(attr) entity = {k: getattr(e, k) for k in prop_names} entity_string = jsonify.encode(entity).encode() return 'k' + hashlib.blake2b(entity_string, digest_size=6).hexdigest()
def test_date_iso(): isodates_encoder = jsonify.JSONEncoder(isodates=True) d = datetime.utcnow().date() encoded = jsonify.encode({'date': d}, encoder=isodates_encoder) isoformat_without_millis = json.dumps({'date': d.isoformat()}) assert isoformat_without_millis == encoded, (isoformat_without_millis, encoded) loaded_date = json.loads(encoded) assert len(loaded_date['date'].split('-')) == 3
def test_builtin_override(): # create a few date objects d1 = date(1979, 10, 12) d2 = date(2000, 1, 1) d3 = date(2012, 1, 1) # jsonify using the built in rules result1 = encode(dict(date=d1)) assert '"1979-10-12"' in result1 result2 = encode(dict(date=d2)) assert '"2000-01-01"' in result2 result3 = encode(dict(date=d3)) assert '"2012-01-01"' in result3 def jsonify_date(obj): if obj.year == 1979 and obj.month == 10 and obj.day == 12: return "Jon's Birthday!" elif obj.year == 2000 and obj.month == 1 and obj.day == 1: return "Its Y2K! Panic!" return "%d/%d/%d" % (obj.month, obj.day, obj.year) custom_date_encoder = JSONEncoder(custom_encoders={date: jsonify_date}) # jsonify using the built in rules result1 = encode(dict(date=d1), encoder=custom_date_encoder) assert '"Jon\'s Birthday!"' in result1 result2 = encode(dict(date=d2), encoder=custom_date_encoder) assert '"Its Y2K! Panic!"' in result2 result3 = encode(dict(date=d3), encoder=custom_date_encoder) assert '"1/1/2012"' in result3
def test_builtin_override(): # create a few date objects d1 = date(1979, 10, 12) d2 = date(2000, 1, 1) d3 = date(2012, 1, 1) # jsonify using the built in rules result1 = encode(dict(date=d1)) assert '"1979-10-12"' in result1 result2 = encode(dict(date=d2)) assert '"2000-01-01"' in result2 result3 = encode(dict(date=d3)) assert '"2012-01-01"' in result3 def jsonify_date(obj): if obj.year == 1979 and obj.month == 10 and obj.day == 12: return "Jon's Birthday!" elif obj.year == 2000 and obj.month == 1 and obj.day == 1: return "Its Y2K! Panic!" return '%d/%d/%d' % (obj.month, obj.day, obj.year) custom_date_encoder = JSONEncoder(custom_encoders={date: jsonify_date}) # jsonify using the built in rules result1 = encode(dict(date=d1), encoder=custom_date_encoder) assert '"Jon\'s Birthday!"' in result1 result2 = encode(dict(date=d2), encoder=custom_date_encoder) assert '"Its Y2K! Panic!"' in result2 result3 = encode(dict(date=d3), encoder=custom_date_encoder) assert '"1/1/2012"' in result3
def render_jsonp(template_name, template_vars, **render_params): key = render_params.pop('key', None) if key is not None: template_vars = template_vars[key] pname = render_params.pop('callback_param', 'callback') callback = tg.request.GET.get(pname) if callback is None: raise HTTPBadRequest('JSONP requires a "%s" parameter with callback name' % pname) encode = JSONRenderer._get_configured_encode(render_params) values = encode(template_vars) return '%s(%s);' % (callback, values)
def render_jsonp(template_name, template_vars, **render_params): key = render_params.pop('key', None) if key is not None: template_vars = template_vars[key] pname = render_params.pop('callback_param', 'callback') callback = tg.request.GET.get(pname) if callback is None: raise HTTPBadRequest( 'JSONP requires a "%s" parameter with callback name' % pname) encode = JSONRenderer._get_configured_encode(render_params) values = encode(template_vars) return '%s(%s);' % (callback, values)
def test_builtin_override(): # skip this test if simplegeneric is not installed try: import simplegeneric except ImportError: return # create a few date objects d1 = date(1979, 10, 12) d2 = date(2000, 1, 1) d3 = date(2012, 1, 1) # jsonify using the built in rules result1 = encode(dict(date=d1)) assert '"1979-10-12"' in result1 result2 = encode(dict(date=d2)) assert '"2000-01-01"' in result2 result3 = encode(dict(date=d3)) assert '"2012-01-01"' in result3 # create a custom rule @jsonify.when_type(date) def jsonify_date(obj): if obj.year == 1979 and obj.month == 10 and obj.day == 12: return "Jon's Birthday!" elif obj.year == 2000 and obj.month == 1 and obj.day == 1: return "Its Y2K! Panic!" return '%d/%d/%d' % (obj.month, obj.day, obj.year) # jsonify using the built in rules result1 = encode(dict(date=d1)) assert '"Jon\'s Birthday!"' in result1 result2 = encode(dict(date=d2)) assert '"Its Y2K! Panic!"' in result2 result3 = encode(dict(date=d3)) assert '"1/1/2012"' in result3
def test_dictionary(): d = {'a': 1, 'b': 2} encoded = jsonify.encode(d) expected = json.dumps(json.loads('{"a": 1, "b": 2}')) assert encoded == expected
def test_json_encode_generators(): encoded = jsonify.encode({'values': (v for v in [1, 2, 3])}) assert encoded == '{"values": [1, 2, 3]}', encoded
def test_string(): d = "string" encoded = jsonify.encode(d) assert encoded == '"string"'
def test_list(): d = ['a', 1, 'b', 2] encoded = jsonify.encode(d) assert encoded == '["a", 1, "b", 2]'
def test_list_iter(): d = list(range(3)) encoded = jsonify.encode_iter(d) assert ''.join(jsonify.encode_iter(d)) == jsonify.encode(d)
def test_exlicitjson(): b = Bar("bq") encoded = jsonify.encode(b) assert encoded == '"bar-bq"'
def test_datetime(): d = datetime.utcnow() encoded = jsonify.encode({'date': d}) assert str(d.year) in encoded, (str(d), encoded)
def test_exlicitjson_in_dict(): b = Bar("bq") d = {"b": b} encoded = jsonify.encode(d) assert encoded == '{"b": "bar-bq"}'
def test_datetime(): d = datetime.utcnow() encoded = jsonify.encode({'date':d}) assert str(d.year) in encoded, (str(d), encoded)
def render_json(template_name, template_vars, **kwargs): return encode(template_vars)
def test_decimal(): d = Decimal('3.14') encoded = jsonify.encode({'dec': d}) assert '3.14' in encoded
def test_exlicitjson_in_list(): b = Bar("bq") d = [b] encoded = jsonify.encode(d) assert encoded == '["bar-bq"]'
def test_list_allowed_iter(): lists_encoder = jsonify.JSONEncoder(allow_lists=True) d = ['a', 1, 'b', 2] encoded = jsonify.encode(d, lists_encoder) assert encoded == '["a", 1, "b", 2]'