def testEncodeSymbols(self):
s = '\u273f\u2661\u273f' # ✿♡✿
encoded = hyperjson.dumps(s)
encoded_json = json.dumps(s)
# NOTE: Python's json module escapes the unicode codepoints
# While hyperjson converts them to actual utf8 characters
# This should be fine because
# - JSON supports utf8 (https://stackoverflow.com/a/594881/270334)
# - encoding and consecutive decoding yields the input
# self.assertEqual(len(encoded), len(s) * 6 + 2) # 6 characters + quotes
#self.assertEqual(encoded, encoded_json)
decoded = hyperjson.loads(encoded)
self.assertEqual(s, decoded)
if six.PY3:
encoded = hyperjson.dumps(s, ensure_ascii=False)
else:
encoded = hyperjson.dumps(s, ensure_ascii=False).decode("utf-8")
# json outputs an unicode object
encoded_json = json.dumps(s, ensure_ascii=False)
self.assertEqual(len(encoded), len(s) + 2) # original length + quotes
self.assertEqual(encoded, encoded_json)
decoded = hyperjson.loads(encoded)
self.assertEqual(s, decoded)
def test_encodeUnicode4BytesUTF8(self):
input = "\xf0\x91\x80\xb0TRAILINGNORMAL"
enc = hyperjson.dumps(input)
dec = hyperjson.loads(enc)
self.assertEqual(enc, json_unicode(input))
self.assertEqual(dec, hyperjson.loads(enc))
def testEncodeUnicodeBMP(self):
s = '\U0001f42e\U0001f42e\U0001F42D\U0001F42D' # 🐮🐮🐭🐭
encoded = hyperjson.dumps(s)
encoded_json = hyperjson.dumps(s)
if len(s) == 4:
self.assertEqual(len(encoded), len(s) * 12 + 2)
else:
self.assertEqual(len(encoded), len(s) * 6 + 2)
self.assertEqual(encoded, encoded_json)
decoded = hyperjson.loads(encoded)
self.assertEqual(s, decoded)
# hyperjson outputs an UTF-8 encoded str object
if six.PY3:
encoded = hyperjson.dumps(s, ensure_ascii=False)
else:
encoded = hyperjson.dumps(s, ensure_ascii=False).decode("utf-8")
# json outputs an unicode object
encoded_json = hyperjson.dumps(s, ensure_ascii=False)
self.assertEqual(len(encoded), len(s) + 2) # original length + quotes
self.assertEqual(encoded, encoded_json)
decoded = hyperjson.loads(encoded)
self.assertEqual(s, decoded)
def testEncodeUnicodeBMP(self):
s = '\U0001f42e\U0001f42e\U0001F42D\U0001F42D' # 🐮🐮🐭🐭
encoded = hyperjson.dumps(s)
encoded_json = json.dumps(s)
self.assertEqual(json.loads(json.dumps(s)), s)
self.assertEqual(hyperjson.loads(hyperjson.dumps(s)), s)
# Ignore length comparison because the output format
# of hyperjson and json is slightly different
# (code points in the case of json, utf8 in the case of hyperjson)
# Loading the serialized object back to Python works, though
# so that should not be an issue.
# Also see testEncodeSymbols
# if len(s) == 4:
# self.assertEqual(len(encoded), len(s) * 12 + 2)
# else:
# self.assertEqual(len(encoded), len(s) * 6 + 2)
#self.assertEqual(encoded, encoded_json)
decoded = hyperjson.loads(encoded)
self.assertEqual(s, decoded)
# hyperjson outputs an UTF-8 encoded str object
if six.PY3:
encoded = hyperjson.dumps(s, ensure_ascii=False)
else:
encoded = hyperjson.dumps(s, ensure_ascii=False).decode("utf-8")
# json outputs an unicode object
encoded_json = hyperjson.dumps(s, ensure_ascii=False)
self.assertEqual(len(encoded), len(s) + 2) # original length + quotes
self.assertEqual(encoded, encoded_json)
decoded = hyperjson.loads(encoded)
self.assertEqual(s, decoded)
def test_encodeArrayInArray(self):
input = [[[[]]]]
output = hyperjson.dumps(input)
self.assertEqual(input, hyperjson.loads(output))
self.assertEqual(output, hyperjson.dumps(input))
self.assertEqual(input, hyperjson.loads(output))
def test_encodeLongUnsignedConversion(self):
input = 18446744073709551615
output = hyperjson.dumps(input)
self.assertEqual(input, hyperjson.loads(output))
self.assertEqual(output, hyperjson.dumps(input))
self.assertEqual(input, hyperjson.loads(output))
def test_special_floats():
assert math.isnan(json.loads("NaN"))
assert math.isnan(hyperjson.loads("NaN"))
assert math.isinf(json.loads("Infinity"))
assert math.isinf(hyperjson.loads("Infinity"))
assert math.isinf(json.loads("-Infinity"))
assert math.isinf(hyperjson.loads("-Infinity"))
def test_encodeUnicodeSurrogatePair(self):
input = "\xf0\x90\x8d\x86"
enc = hyperjson.dumps(input)
dec = hyperjson.loads(enc)
self.assertEqual(enc, json_unicode(input))
self.assertEqual(dec, hyperjson.loads(enc))
def test_encodeUnicode4BytesUTF8Highest(self):
input = "\xf3\xbf\xbf\xbfTRAILINGNORMAL"
enc = hyperjson.dumps(input)
dec = hyperjson.loads(enc)
self.assertEqual(enc, json_unicode(input))
self.assertEqual(dec, hyperjson.loads(enc))
def test_doubleLongIssue(self):
sut = {'a': -4342969734183514}
encoded = hyperjson.dumps(sut)
decoded = hyperjson.loads(encoded)
self.assertEqual(sut, decoded)
encoded = hyperjson.dumps(sut)
decoded = hyperjson.loads(encoded)
self.assertEqual(sut, decoded)
def test_doubleLongDecimalIssue(self):
sut = {'a': -12345678901234.56789012}
encoded = hyperjson.dumps(sut)
decoded = hyperjson.loads(encoded)
self.assertEqual(sut, decoded)
encoded = hyperjson.dumps(sut)
decoded = hyperjson.loads(encoded)
self.assertEqual(sut, decoded)
def test_encodeListLongConversion(self):
input = [
9223372036854775807, 9223372036854775807, 9223372036854775807,
9223372036854775807, 9223372036854775807, 9223372036854775807
]
output = hyperjson.dumps(input)
self.assertEqual(input, hyperjson.loads(output))
self.assertEqual(input, hyperjson.loads(output))
def test_encodeToUTF8(self):
input = b"\xe6\x97\xa5\xd1\x88"
if six.PY3:
input = input.decode('utf-8')
enc = hyperjson.dumps(input, ensure_ascii=False)
dec = hyperjson.loads(enc)
self.assertEqual(enc, hyperjson.dumps(input, ensure_ascii=False))
self.assertEqual(dec, hyperjson.loads(enc))
def test_decodeBigEscape(self):
for x in range(10):
if six.PY3:
base = '\u00e5'.encode('utf-8')
quote = "\"".encode()
else:
base = "\xc3\xa5"
quote = "\""
input = quote + (base * 1024 * 1024 * 2) + quote
hyperjson.loads(input)
def test_encodeNullCharacter(self):
input = "31337 \x00 1337"
output = hyperjson.dumps(input)
self.assertEqual(input, hyperjson.loads(output))
self.assertEqual(output, hyperjson.dumps(input))
self.assertEqual(input, hyperjson.loads(output))
input = "\x00"
output = hyperjson.dumps(input)
self.assertEqual(input, hyperjson.loads(output))
self.assertEqual(output, hyperjson.dumps(input))
self.assertEqual(input, hyperjson.loads(output))
self.assertEqual('" \\u0000\\r\\n "',
hyperjson.dumps(" \u0000\r\n "))
async def register_students(ans: SimpleBotEvent):
with logger.contextualize(user_id=ans.object.object.message.from_id):
payload = hyperjson.loads(ans.object.object.message.payload)
data = []
raw_html = requests.get(payload["students"])
soup = BeautifulSoup(raw_html.text, "html.parser")
students_ids = list(map(int, soup.find_all("pre")[1].text.split(",")))
students = await api.users.get(user_ids=students_ids)
student_last_id = Student.select().order_by(Student.id.desc()).get().id
for student in students.response:
student_last_id += 1
data.append(
{
"id": student_last_id,
"first_name": student.first_name,
"second_name": student.last_name,
"vk_id": student.id,
"group_id": payload["group"],
"academic_status": 1,
},
)
query = Student.insert_many(data).execute()
await ans.answer(
f"{len(query)} студент(ов) зарегистрировано",
keyboard=kbs.preferences.configure_chat(payload["chat_id"]),
)
async def select_active_group(ans: SimpleBotEvent):
payload = hyperjson.loads(ans.object.object.message.payload)
db.shortcuts.update_admin_storage(
db.students.get_system_id_of_student(ans.object.object.message.from_id),
active_group=payload["group_id"],
)
await open_preferences(ans)
def test_encodeDecimal(self):
sut = decimal.Decimal("1337.1337")
encoded = hyperjson.dumps(sut)
print(encoded)
decoded = hyperjson.loads(encoded)
print(decoded)
self.assertEqual(decoded, 1337.1337)
async def delete_chat(ans: SimpleBotEvent):
with logger.contextualize(user_id=ans.object.object.message.from_id):
payload = hyperjson.loads(ans.object.object.message.payload)
db.chats.delete_chat(payload["chat"])
chats = db.chats.get_list_of_chats_by_group(
db.admin.get_active_group(
db.students.get_system_id_of_student(ans.object.object.message.from_id),
),
)
try:
chat_id = chats[0].id
except IndexError:
chat_id = None
db.shortcuts.update_admin_storage(
db.students.get_system_id_of_student(ans.object.object.message.from_id),
current_chat_id=chat_id,
)
await ans.answer(
"Чат удален",
keyboard=await kbs.preferences.connected_chats(
db.students.get_system_id_of_student(
ans.object.object.message.from_id,
),
),
)
async def select_student(ans: SimpleBotEvent):
with logger.contextualize(user_id=ans.object.object.message.from_id):
payload = hyperjson.loads(ans.object.object.message.payload)
student_id = payload["student_id"]
letter = payload["letter"]
name = payload["name"]
if student_id in db.shortcuts.get_list_of_calling_students(
db.students.get_system_id_of_student(
ans.object.object.message.peer_id), ):
db.shortcuts.pop_student_from_calling_list(
db.students.get_system_id_of_student(
ans.object.object.message.peer_id),
student_id,
)
label = "удален из списка призыва"
else:
db.shortcuts.add_student_to_calling_list(
db.students.get_system_id_of_student(
ans.object.object.message.peer_id),
student_id,
)
label = "добавлен в список призыва"
await ans.answer(
f"{name} {label}",
keyboard=kbs.call.CallNavigator(
db.students.get_system_id_of_student(
ans.object.object.message.peer_id), ).render().students(
letter),
)
def test_docs():
assert hyperjson.dumps([{
"key": "value"
}, 81, True]) == '[{"key":"value"},81,true]'
assert hyperjson.loads("""[{"key": "value"}, 81, true]""") == [{
u'key':
u'value'
}, 81, True]
async def save_chat_debtors(ans: SimpleBotEvent):
payload = hyperjson.loads(ans.object.object.message.payload)
db.shortcuts.update_admin_storage(
db.students.get_system_id_of_student(
ans.object.object.message.from_id),
current_chat_id=payload["chat_id"],
)
await call_debtors(ans)
async def select_half(ans: SimpleBotEvent):
with logger.contextualize(user_id=ans.object.object.message.from_id):
payload = hyperjson.loads(ans.object.object.message.payload)
await ans.answer(
"Выберите призываемых студентов",
keyboard=kbs.call.CallNavigator(
db.students.get_system_id_of_student(
ans.object.object.message.peer_id), ).render().submenu(
payload["half"]),
)
async def select_half(ans: SimpleBotEvent):
with logger.contextualize(user_id=ans.object.object.message.from_id):
payload = hyperjson.loads(ans.object.object.message.payload)
await ans.answer(
"Выберите студента",
keyboard=kbs.contacts.ContactsNavigator(
db.students.get_system_id_of_student(
ans.object.object.message.from_id, ), ).render().submenu(
payload.get("half"), ),
)
async def select_half(ans: SimpleBotEvent):
with logger.contextualize(user_id=ans.object.object.message.from_id):
payload = hyperjson.loads(ans.object.object.message.payload)
await ans.answer(
"Выберите студента, сдавшего деньги",
keyboard=kbs.finances.IncomeNavigator(
db.students.get_system_id_of_student(
ans.object.object.message.from_id), ).render().submenu(
payload["half"]),
)
async def select_student(ans: SimpleBotEvent):
with logger.contextualize(user_id=ans.object.object.message.from_id):
payload = hyperjson.loads(ans.object.object.message.payload)
db.shortcuts.update_admin_storage(
db.students.get_system_id_of_student(
ans.object.object.message.from_id, ),
selected_students=str(payload["student_id"]),
state_id=db.bot.get_id_of_state("enter_donate_sum"),
)
await ans.answer("Введите сумму дохода", keyboard=kbs.common.empty())
async def select_letter(ans: SimpleBotEvent):
with logger.contextualize(user_id=ans.object.object.message.from_id):
payload = hyperjson.loads(ans.object.object.message.payload)
letter = payload.get("value")
await ans.answer(
f"Список студентов на букву {letter}",
keyboard=kbs.contacts.ContactsNavigator(
db.students.get_system_id_of_student(
ans.object.object.message.peer_id), ).render().students(
letter),
)
def test_decodeNumberWith32bitSignBit(self):
# Test that numbers that fit within 32 bits but would have the
# sign bit set (2**31 <= x < 2**32) are decoded properly.
docs = (
'{"id": 3590016419}',
'{"id": %s}' % 2**31,
'{"id": %s}' % 2**32,
'{"id": %s}' % ((2**32) - 1),
)
results = (3590016419, 2**31, 2**32, 2**32 - 1)
for doc, result in zip(docs, results):
self.assertEqual(hyperjson.loads(doc)['id'], result)
def testEncodeSymbols(self):
s = '\u273f\u2661\u273f' # ✿♡✿
encoded = hyperjson.dumps(s)
encoded_json = hyperjson.dumps(s)
self.assertEqual(len(encoded), len(s) * 6 + 2) # 6 characters + quotes
self.assertEqual(encoded, encoded_json)
decoded = hyperjson.loads(encoded)
self.assertEqual(s, decoded)
# hyperjson outputs an UTF-8 encoded str object
if six.PY3:
encoded = hyperjson.dumps(s, ensure_ascii=False)
else:
encoded = hyperjson.dumps(s, ensure_ascii=False).decode("utf-8")
# json outputs an unicode object
encoded_json = hyperjson.dumps(s, ensure_ascii=False)
self.assertEqual(len(encoded), len(s) + 2) # original length + quotes
self.assertEqual(encoded, encoded_json)
decoded = hyperjson.loads(encoded)
self.assertEqual(s, decoded)
def test_object_with_complex_json(self):
# If __json__ returns a string, then that string
# will be used as a raw JSON snippet in the object.
obj = {u'foo': [u'bar', u'baz']}
class JSONTest:
def __json__(self):
return hyperjson.dumps(obj)
d = {u'key': JSONTest()}
output = hyperjson.dumps(d)
dec = hyperjson.loads(output)
self.assertEqual(dec, {u'key': obj})
