dbcli/iredis
1
0
Fork 0
Code Issues Activity
iredis/tests/unittests/test_render_functions.py
Daniel Baumann db5ed8b1cc
Merging upstream version 1.9.4. 
Signed-off-by: Daniel Baumann <daniel@debian.org>
2025-02-09 17:04:04 +01:00

492 lines
15 KiB
Python
Raw Blame History

import os
import time
from prompt_toolkit.formatted_text import FormattedText
from iredis import renders
from iredis.config import config
from iredis.completers import IRedisCompleter
def strip_formatted_text(formatted_text):
return "".join(text[1] for text in formatted_text)
def test_render_simple_string_raw_using_raw_render():
assert renders.OutputRender.render_raw(b"OK") == b"OK"
assert renders.OutputRender.render_raw(b"BUMPED 1") == b"BUMPED 1"
assert renders.OutputRender.render_raw(b"STILL 1") == b"STILL 1"
def test_render_simple_string():
assert renders.OutputRender.render_simple_string(b"OK") == FormattedText(
[("class:success", "OK")]
)
assert renders.OutputRender.render_simple_string(b"BUMPED 1") == FormattedText(
[("class:success", "BUMPED 1")]
)
assert renders.OutputRender.render_simple_string(b"STILL 1") == FormattedText(
[("class:success", "STILL 1")]
)
def test_render_list_index():
raw = ["hello", "world", "foo"]
out = renders._render_list([item.encode() for item in raw], raw)
out = strip_formatted_text(out)
assert isinstance(out, str)
assert "3)" in out
assert "1)" in out
assert "4)" not in out
def test_render_list_index_const_width():
raw = ["hello"] * 100
out = renders._render_list([item.encode() for item in raw], raw)
out = strip_formatted_text(out)
assert isinstance(out, str)
assert " 1)" in out
assert "\n100)" in out
raw = ["hello"] * 1000
out = renders._render_list([item.encode() for item in raw], raw)
out = strip_formatted_text(out)
assert " 1)" in out
assert "\n 999)" in out
assert "\n1000)" in out
raw = ["hello"] * 10
out = renders._render_list([item.encode() for item in raw], raw)
out = strip_formatted_text(out)
assert " 1)" in out
assert "\n 9)" in out
assert "\n10)" in out
def test_render_list_using_raw_render():
raw = ["hello", "world", "foo"]
out = renders.OutputRender.render_raw([item.encode() for item in raw])
assert b"hello\nworld\nfoo" == out
def test_render_list_with_nil_init():
raw = [b"hello", None, b"world"]
out = renders.OutputRender.render_list(raw)
out = strip_formatted_text(out)
assert out == '1) "hello"\n2) (nil)\n3) "world"'
def test_render_list_with_nil_init_while_config_raw():
raw = [b"hello", None, b"world"]
out = renders.OutputRender.render_raw(raw)
assert out == b"hello\n\nworld"
def test_render_list_with_empty_list_raw():
raw = []
out = renders.OutputRender.render_raw(raw)
assert out == b""
def test_render_list_with_empty_list():
raw = []
out = renders.OutputRender.render_list(raw)
out = strip_formatted_text(out)
assert out == "(empty list or set)"
def test_ensure_str_bytes():
assert renders.ensure_str(b"hello world") == r"hello world"
assert renders.ensure_str(b"hello'world") == r"hello'world"
assert renders.ensure_str("你好".encode()) == r"\xe4\xbd\xa0\xe5\xa5\xbd"
def test_double_quotes():
assert renders.double_quotes('hello"world') == r'"hello\"world"'
assert renders.double_quotes('"hello\\world"') == '"\\"hello\\world\\""'
assert renders.double_quotes("'") == '"\'"'
assert renders.double_quotes("\\") == '"\\"'
assert renders.double_quotes('"') == '"\\""'
def test_render_int():
config.raw = False
assert renders.OutputRender.render_int(12) == FormattedText(
[("class:type", "(integer) "), ("", "12")]
)
def test_render_int_raw():
assert renders.OutputRender.render_raw(12) == b"12"
def test_render_list_or_string():
assert renders.OutputRender.render_list_or_string("") == '""'
assert renders.OutputRender.render_list_or_string("foo") == '"foo"'
assert renders.OutputRender.render_list_or_string(
[b"foo", b"bar"]
) == FormattedText(
[
("", "1)"),
("", " "),
("class:string", '"foo"'),
("", "\n"),
("", "2)"),
("", " "),
("class:string", '"bar"'),
]
)
def test_render_list_or_string_nil_and_empty_list():
assert renders.OutputRender.render_list_or_string(None) == FormattedText(
[("class:type", "(nil)")]
)
assert renders.OutputRender.render_list_or_string([]) == FormattedText(
[("class:type", "(empty list or set)")]
)
def test_render_raw_nil_and_empty_list():
assert renders.OutputRender.render_raw(None) == b""
assert renders.OutputRender.render_raw([]) == b""
def test_list_or_string():
config.raw = False
assert renders.OutputRender.render_string_or_int(b"10.1") == '"10.1"'
assert renders.OutputRender.render_string_or_int(3) == FormattedText(
[("class:type", "(integer) "), ("", "3")]
)
def test_command_keys():
completer = IRedisCompleter()
completer.key_completer.words = []
config.raw = False
rendered = renders.OutputRender.command_keys([b"cat", b"dog", b"banana"])
completer.update_completer_for_response("KEYS", None, [b"cat", b"dog", b"banana"])
assert rendered == FormattedText(
[
("", "1)"),
("", " "),
("class:key", '"cat"'),
("", "\n"),
("", "2)"),
("", " "),
("class:key", '"dog"'),
("", "\n"),
("", "3)"),
("", " "),
("class:key", '"banana"'),
]
)
assert completer.key_completer.words == ["banana", "dog", "cat"]
def test_command_scan():
completer = IRedisCompleter()
completer.key_completer.words = []
config.raw = False
rendered = renders.OutputRender.command_scan(
[b"44", [b"a", b"key:__rand_int__", b"dest", b" a"]]
)
completer.update_completer_for_response(
"SCAN", ("0",), [b"44", [b"a", b"key:__rand_int__", b"dest", b" a"]]
)
assert rendered == FormattedText(
[
("class:type", "(cursor) "),
("class:integer", "44"),
("", "\n"),
("", "1)"),
("", " "),
("class:key", '"a"'),
("", "\n"),
("", "2)"),
("", " "),
("class:key", '"key:__rand_int__"'),
("", "\n"),
("", "3)"),
("", " "),
("class:key", '"dest"'),
("", "\n"),
("", "4)"),
("", " "),
("class:key", '" a"'),
]
)
assert completer.key_completer.words == [" a", "dest", "key:__rand_int__", "a"]
def test_command_sscan():
completer = IRedisCompleter()
completer.member_completer.words = []
rendered = renders.OutputRender.command_sscan(
[b"44", [b"a", b"member:__rand_int__", b"dest", b" a"]]
)
completer.update_completer_for_response(
"SSCAN", (0), [b"44", [b"a", b"member:__rand_int__", b"dest", b" a"]]
)
assert rendered == FormattedText(
[
("class:type", "(cursor) "),
("class:integer", "44"),
("", "\n"),
("", "1)"),
("", " "),
("class:member", '"a"'),
("", "\n"),
("", "2)"),
("", " "),
("class:member", '"member:__rand_int__"'),
("", "\n"),
("", "3)"),
("", " "),
("class:member", '"dest"'),
("", "\n"),
("", "4)"),
("", " "),
("class:member", '" a"'),
]
)
assert completer.member_completer.words == [
" a",
"dest",
"member:__rand_int__",
"a",
]
def test_command_sscan_config_raw():
completer = IRedisCompleter()
completer.member_completer.words = []
rendered = renders.OutputRender.render_raw(
[b"44", [b"a", b"member:__rand_int__", b"dest", b" a"]]
)
completer.update_completer_for_response(
"SSCAN", (0), [b"44", [b"a", b"member:__rand_int__", b"dest", b" a"]]
)
assert rendered == b"44\na\nmember:__rand_int__\ndest\n a"
assert completer.member_completer.words == [
" a",
"dest",
"member:__rand_int__",
"a",
]
def test_render_members():
completer = IRedisCompleter()
completer.member_completer.words = []
config.withscores = True
resp = [b"duck", b"667", b"camel", b"708"]
rendered = renders.OutputRender.render_members(resp)
completer.update_completer_for_response("ZRANGE", ("foo", "0", "-1"), resp)
assert rendered == FormattedText(
[
("", "1)"),
("", " "),
("class:integer", "667 "),
("class:member", '"duck"'),
("", "\n"),
("", "2)"),
("", " "),
("class:integer", "708 "),
("class:member", '"camel"'),
]
)
assert completer.member_completer.words == ["camel", "duck"]
def test_render_members_config_raw():
completer = IRedisCompleter()
completer.member_completer.words = []
config.withscores = True
resp = [b"duck", b"667", b"camel", b"708"]
rendered = renders.OutputRender.render_raw(resp)
completer.update_completer_for_response("ZRANGE", (), resp)
assert rendered == b"duck\n667\ncamel\n708"
assert completer.member_completer.words == ["camel", "duck"]
def test_render_unixtime_config_raw():
# fake the timezone and reload
os.environ["TZ"] = "Asia/Shanghai"
time.tzset()
rendered = renders.OutputRender.render_unixtime(1570469891)
assert rendered == FormattedText(
[
("class:type", "(integer) "),
("", "1570469891"),
("", "\n"),
("class:type", "(local time)"),
("", " "),
("", "2019-10-08 01:38:11"),
]
)
def test_render_unixtime():
rendered = renders.OutputRender.render_raw(1570469891)
assert rendered == b"1570469891"
def test_bulk_string_reply():
assert renders.OutputRender.render_bulk_string(b"'\"") == '''"'\\""'''
def test_bulk_string_reply_raw():
assert renders.OutputRender.render_raw(b"hello") == b"hello"
def test_render_bulk_string_decoded():
EXPECTED_RENDER = """# Server\nredis_version:5.0.5\nredis_git_sha1:00000000\nredis_git_dirty:0\nredis_build_id:31cd6e21ec924b46""" # noqa
_input = b"# Server\r\nredis_version:5.0.5\r\nredis_git_sha1:00000000\r\nredis_git_dirty:0\r\nredis_build_id:31cd6e21ec924b46" # noqa
assert renders.OutputRender.render_bulk_string_decode(_input) == EXPECTED_RENDER
def test_render_bulk_string_decoded_with_decoded_utf8():
EXPECTED_RENDER = """# Server\nredis_version:5.0.5\nredis_git_sha1:00000000\nredis_git_dirty:0\nredis_build_id:31cd6e21ec924b46""" # noqa
_input = "# Server\r\nredis_version:5.0.5\r\nredis_git_sha1:00000000\r\nredis_git_dirty:0\r\nredis_build_id:31cd6e21ec924b46" # noqa
assert renders.OutputRender.render_bulk_string_decode(_input) == EXPECTED_RENDER
def test_render_time():
value = [b"1571305643", b"765481"]
assert renders.OutputRender.render_time(value) == FormattedText(
[
("class:type", "(unix timestamp) "),
("", "1571305643"),
("", "\n"),
("class:type", "(millisecond) "),
("", "765481"),
("", "\n"),
("class:type", "(convert to local timezone) "),
("", "2019-10-17 17:47:23.765481"),
]
)
assert renders.OutputRender.render_raw(value) == b"1571305643\n765481"
def test_render_nested_pairs():
text = [
b"peak.allocated",
10160336,
b"lua.caches",
0,
b"db.0",
[b"overhead.hashtable.main", 648, b"overhead.hashtable.expires", 32],
b"db.1",
[b"overhead.hashtable.main", 112, b"overhead.hashtable.expires", 32],
b"fragmentation",
b"0.062980629503726959",
b"fragmentation.bytes",
-9445680,
]
assert renders.OutputRender.render_raw(text) == (
b"peak.allocated\n10160336\nlua.caches\n0\ndb.0\noverhead.hashtable.main\n64"
b"8\noverhead.hashtable.expires\n32\ndb.1\noverhead.hashtable.main\n112\nove"
b"rhead.hashtable.expires\n32\nfragmentation\n0.062980629503726959\nfragmentat"
b"ion.bytes\n-9445680"
)
assert renders.OutputRender.render_nested_pair(text) == FormattedText(
[
("class:string", "peak.allocated: "),
("class:value", "10160336"),
("", "\n"),
("class:string", "lua.caches: "),
("class:value", "0"),
("", "\n"),
("class:string", "db.0: "),
("", "\n"),
("class:string", " overhead.hashtable.main: "),
("class:value", "648"),
("", "\n"),
("class:string", " overhead.hashtable.expires: "),
("class:value", "32"),
("", "\n"),
("class:string", "db.1: "),
("", "\n"),
("class:string", " overhead.hashtable.main: "),
("class:value", "112"),
("", "\n"),
("class:string", " overhead.hashtable.expires: "),
("class:value", "32"),
("", "\n"),
("class:string", "fragmentation: "),
("class:value", "0.062980629503726959"),
("", "\n"),
("class:string", "fragmentation.bytes: "),
("class:value", "-9445680"),
]
)
def test_render_nested_list():
text = [[b"get", 2, [b"readonly", b"fast"], 1, 1, 1]]
assert renders.OutputRender.render_list(text) == FormattedText(
[
("", "1)"),
("", " "),
("", "1)"),
("", " "),
("class:string", '"get"'),
("", "\n"),
("", " "),
("", "2)"),
("", " "),
("class:string", '"2"'),
("", "\n"),
("", " "),
("", "3)"),
("", " "),
("", "1)"),
("", " "),
("class:string", '"readonly"'),
("", "\n"),
("", " "),
("", "2)"),
("", " "),
("class:string", '"fast"'),
("", "\n"),
("", " "),
("", "4)"),
("", " "),
("class:string", '"1"'),
("", "\n"),
("", " "),
("", "5)"),
("", " "),
("class:string", '"1"'),
("", "\n"),
("", " "),
("", "6)"),
("", " "),
("class:string", '"1"'),
]
)
def test_render_bytes(config):
assert renders.OutputRender.render_bytes(b"bytes\n") == b"bytes"
def test_render_bytes_raw(config):
assert renders.OutputRender.render_raw(b"bytes\n") == b"bytes\n"
def test_render_help(config):
assert renders.OutputRender.render_help([b"foo", b"bar"]) == FormattedText(
[("class:string", "foo\nbar")]
)
View git blame Copy permalink