Adding upstream version 1.13.0.upstream/1.13.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 492 insertions, 0 deletions

diff --git a/tests/unittests/test_render_functions.py b/tests/unittests/test_render_functions.py
new file mode 100644
index 0000000..30b328e
--- /dev/null
+++ b/tests/unittests/test_render_functions.py
@@ -0,0 +1,492 @@
+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")]
+    )