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 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_nospecificjson():
    b = Baz()
    try:
        encoded = jsonify.encode(b)
    except TypeError as e:
        pass
    assert  "is not JSON serializable" in e.message 

 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_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_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_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 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_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 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_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(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 _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 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 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_datetime():
    d = datetime.utcnow()
    encoded = jsonify.encode({'date':d})
    assert str(d.year) in encoded, (str(d), encoded)