Adding upstream version 3.1.0.upstream/3.1.0

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

10 files changed, 757 insertions, 0 deletions

diff --git a/tests/features/steps/__init__.py b/tests/features/steps/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/features/steps/__init__.py
diff --git a/tests/features/steps/auto_vertical.py b/tests/features/steps/auto_vertical.py
new file mode 100644
index 0000000..1643ea5
--- /dev/null
+++ b/tests/features/steps/auto_vertical.py
@@ -0,0 +1,99 @@
+from textwrap import dedent
+from behave import then, when
+import wrappers
+
+
+@when("we run dbcli with {arg}")
+def step_run_cli_with_arg(context, arg):
+    wrappers.run_cli(context, run_args=arg.split("="))
+
+
+@when("we execute a small query")
+def step_execute_small_query(context):
+    context.cli.sendline("select 1")
+
+
+@when("we execute a large query")
+def step_execute_large_query(context):
+    context.cli.sendline("select {}".format(",".join([str(n) for n in range(1, 50)])))
+
+
+@then("we see small results in horizontal format")
+def step_see_small_results(context):
+    wrappers.expect_pager(
+        context,
+        dedent(
+            """\
+        +------------+\r
+        | ?column?   |\r
+        |------------|\r
+        | 1          |\r
+        +------------+\r
+        SELECT 1\r
+        """
+        ),
+        timeout=5,
+    )
+
+
+@then("we see large results in vertical format")
+def step_see_large_results(context):
+    wrappers.expect_pager(
+        context,
+        dedent(
+            """\
+        -[ RECORD 1 ]-------------------------\r
+        ?column? | 1\r
+        ?column? | 2\r
+        ?column? | 3\r
+        ?column? | 4\r
+        ?column? | 5\r
+        ?column? | 6\r
+        ?column? | 7\r
+        ?column? | 8\r
+        ?column? | 9\r
+        ?column? | 10\r
+        ?column? | 11\r
+        ?column? | 12\r
+        ?column? | 13\r
+        ?column? | 14\r
+        ?column? | 15\r
+        ?column? | 16\r
+        ?column? | 17\r
+        ?column? | 18\r
+        ?column? | 19\r
+        ?column? | 20\r
+        ?column? | 21\r
+        ?column? | 22\r
+        ?column? | 23\r
+        ?column? | 24\r
+        ?column? | 25\r
+        ?column? | 26\r
+        ?column? | 27\r
+        ?column? | 28\r
+        ?column? | 29\r
+        ?column? | 30\r
+        ?column? | 31\r
+        ?column? | 32\r
+        ?column? | 33\r
+        ?column? | 34\r
+        ?column? | 35\r
+        ?column? | 36\r
+        ?column? | 37\r
+        ?column? | 38\r
+        ?column? | 39\r
+        ?column? | 40\r
+        ?column? | 41\r
+        ?column? | 42\r
+        ?column? | 43\r
+        ?column? | 44\r
+        ?column? | 45\r
+        ?column? | 46\r
+        ?column? | 47\r
+        ?column? | 48\r
+        ?column? | 49\r
+        SELECT 1\r
+        """
+        ),
+        timeout=5,
+    )
diff --git a/tests/features/steps/basic_commands.py b/tests/features/steps/basic_commands.py
new file mode 100644
index 0000000..1069662
--- /dev/null
+++ b/tests/features/steps/basic_commands.py
@@ -0,0 +1,147 @@
+"""
+Steps for behavioral style tests are defined in this module.
+Each step is defined by the string decorating it.
+This string is used to call the step in "*.feature" file.
+"""
+
+import pexpect
+import subprocess
+import tempfile
+
+from behave import when, then
+from textwrap import dedent
+import wrappers
+
+
+@when("we list databases")
+def step_list_databases(context):
+    cmd = ["pgcli", "--list"]
+    context.cmd_output = subprocess.check_output(cmd, cwd=context.package_root)
+
+
+@then("we see list of databases")
+def step_see_list_databases(context):
+    assert b"List of databases" in context.cmd_output
+    assert b"postgres" in context.cmd_output
+    context.cmd_output = None
+
+
+@when("we run dbcli")
+def step_run_cli(context):
+    wrappers.run_cli(context)
+
+
+@when("we launch dbcli using {arg}")
+def step_run_cli_using_arg(context, arg):
+    prompt_check = False
+    currentdb = None
+    if arg == "--username":
+        arg = "--username={}".format(context.conf["user"])
+    if arg == "--user":
+        arg = "--user={}".format(context.conf["user"])
+    if arg == "--port":
+        arg = "--port={}".format(context.conf["port"])
+    if arg == "--password":
+        arg = "--password"
+        prompt_check = False
+    # This uses the mock_pg_service.conf file in fixtures folder.
+    if arg == "dsn_password":
+        arg = "service=mock_postgres --password"
+        prompt_check = False
+        currentdb = "postgres"
+    wrappers.run_cli(
+        context, run_args=[arg], prompt_check=prompt_check, currentdb=currentdb
+    )
+
+
+@when("we wait for prompt")
+def step_wait_prompt(context):
+    wrappers.wait_prompt(context)
+
+
+@when('we send "ctrl + d"')
+def step_ctrl_d(context):
+    """
+    Send Ctrl + D to hopefully exit.
+    """
+    # turn off pager before exiting
+    context.cli.sendline("\pset pager off")
+    wrappers.wait_prompt(context)
+    context.cli.sendcontrol("d")
+    context.cli.expect(pexpect.EOF, timeout=15)
+    context.exit_sent = True
+
+
+@when('we send "\?" command')
+def step_send_help(context):
+    """
+    Send \? to see help.
+    """
+    context.cli.sendline("\?")
+
+
+@when("we send partial select command")
+def step_send_partial_select_command(context):
+    """
+    Send `SELECT a` to see completion.
+    """
+    context.cli.sendline("SELECT a")
+
+
+@then("we see error message")
+def step_see_error_message(context):
+    wrappers.expect_exact(context, 'column "a" does not exist', timeout=2)
+
+
+@when("we send source command")
+def step_send_source_command(context):
+    context.tmpfile_sql_help = tempfile.NamedTemporaryFile(prefix="pgcli_")
+    context.tmpfile_sql_help.write(b"\?")
+    context.tmpfile_sql_help.flush()
+    context.cli.sendline("\i {0}".format(context.tmpfile_sql_help.name))
+    wrappers.expect_exact(context, context.conf["pager_boundary"] + "\r\n", timeout=5)
+
+
+@when("we run query to check application_name")
+def step_check_application_name(context):
+    context.cli.sendline(
+        "SELECT 'found' FROM pg_stat_activity WHERE application_name = 'pgcli' HAVING COUNT(*) > 0;"
+    )
+
+
+@then("we see found")
+def step_see_found(context):
+    wrappers.expect_exact(
+        context,
+        context.conf["pager_boundary"]
+        + "\r"
+        + dedent(
+            """
+            +------------+\r
+            | ?column?   |\r
+            |------------|\r
+            | found      |\r
+            +------------+\r
+            SELECT 1\r
+        """
+        )
+        + context.conf["pager_boundary"],
+        timeout=5,
+    )
+
+
+@then("we confirm the destructive warning")
+def step_confirm_destructive_command(context):
+    """Confirm destructive command."""
+    wrappers.expect_exact(
+        context,
+        "You're about to run a destructive command.\r\nDo you want to proceed? (y/n):",
+        timeout=2,
+    )
+    context.cli.sendline("y")
+
+
+@then("we send password")
+def step_send_password(context):
+    wrappers.expect_exact(context, "Password for", timeout=5)
+    context.cli.sendline(context.conf["pass"] or "DOES NOT MATTER")
diff --git a/tests/features/steps/crud_database.py b/tests/features/steps/crud_database.py
new file mode 100644
index 0000000..3fd8b7a
--- /dev/null
+++ b/tests/features/steps/crud_database.py
@@ -0,0 +1,93 @@
+"""
+Steps for behavioral style tests are defined in this module.
+Each step is defined by the string decorating it.
+This string is used to call the step in "*.feature" file.
+"""
+import pexpect
+
+from behave import when, then
+import wrappers
+
+
+@when("we create database")
+def step_db_create(context):
+    """
+    Send create database.
+    """
+    context.cli.sendline("create database {0};".format(context.conf["dbname_tmp"]))
+
+    context.response = {"database_name": context.conf["dbname_tmp"]}
+
+
+@when("we drop database")
+def step_db_drop(context):
+    """
+    Send drop database.
+    """
+    context.cli.sendline("drop database {0};".format(context.conf["dbname_tmp"]))
+
+
+@when("we connect to test database")
+def step_db_connect_test(context):
+    """
+    Send connect to database.
+    """
+    db_name = context.conf["dbname"]
+    context.cli.sendline("\\connect {0}".format(db_name))
+
+
+@when("we connect to dbserver")
+def step_db_connect_dbserver(context):
+    """
+    Send connect to database.
+    """
+    context.cli.sendline("\\connect postgres")
+    context.currentdb = "postgres"
+
+
+@then("dbcli exits")
+def step_wait_exit(context):
+    """
+    Make sure the cli exits.
+    """
+    wrappers.expect_exact(context, pexpect.EOF, timeout=5)
+
+
+@then("we see dbcli prompt")
+def step_see_prompt(context):
+    """
+    Wait to see the prompt.
+    """
+    db_name = getattr(context, "currentdb", context.conf["dbname"])
+    wrappers.expect_exact(context, "{0}> ".format(db_name), timeout=5)
+    context.atprompt = True
+
+
+@then("we see help output")
+def step_see_help(context):
+    for expected_line in context.fixture_data["help_commands.txt"]:
+        wrappers.expect_exact(context, expected_line, timeout=2)
+
+
+@then("we see database created")
+def step_see_db_created(context):
+    """
+    Wait to see create database output.
+    """
+    wrappers.expect_pager(context, "CREATE DATABASE\r\n", timeout=5)
+
+
+@then("we see database dropped")
+def step_see_db_dropped(context):
+    """
+    Wait to see drop database output.
+    """
+    wrappers.expect_pager(context, "DROP DATABASE\r\n", timeout=2)
+
+
+@then("we see database connected")
+def step_see_db_connected(context):
+    """
+    Wait to see drop database output.
+    """
+    wrappers.expect_exact(context, "You are now connected to database", timeout=2)
diff --git a/tests/features/steps/crud_table.py b/tests/features/steps/crud_table.py
new file mode 100644
index 0000000..0375883
--- /dev/null
+++ b/tests/features/steps/crud_table.py
@@ -0,0 +1,118 @@
+"""
+Steps for behavioral style tests are defined in this module.
+Each step is defined by the string decorating it.
+This string is used to call the step in "*.feature" file.
+"""
+
+from behave import when, then
+from textwrap import dedent
+import wrappers
+
+
+@when("we create table")
+def step_create_table(context):
+    """
+    Send create table.
+    """
+    context.cli.sendline("create table a(x text);")
+
+
+@when("we insert into table")
+def step_insert_into_table(context):
+    """
+    Send insert into table.
+    """
+    context.cli.sendline("""insert into a(x) values('xxx');""")
+
+
+@when("we update table")
+def step_update_table(context):
+    """
+    Send insert into table.
+    """
+    context.cli.sendline("""update a set x = 'yyy' where x = 'xxx';""")
+
+
+@when("we select from table")
+def step_select_from_table(context):
+    """
+    Send select from table.
+    """
+    context.cli.sendline("select * from a;")
+
+
+@when("we delete from table")
+def step_delete_from_table(context):
+    """
+    Send deete from table.
+    """
+    context.cli.sendline("""delete from a where x = 'yyy';""")
+
+
+@when("we drop table")
+def step_drop_table(context):
+    """
+    Send drop table.
+    """
+    context.cli.sendline("drop table a;")
+
+
+@then("we see table created")
+def step_see_table_created(context):
+    """
+    Wait to see create table output.
+    """
+    wrappers.expect_pager(context, "CREATE TABLE\r\n", timeout=2)
+
+
+@then("we see record inserted")
+def step_see_record_inserted(context):
+    """
+    Wait to see insert output.
+    """
+    wrappers.expect_pager(context, "INSERT 0 1\r\n", timeout=2)
+
+
+@then("we see record updated")
+def step_see_record_updated(context):
+    """
+    Wait to see update output.
+    """
+    wrappers.expect_pager(context, "UPDATE 1\r\n", timeout=2)
+
+
+@then("we see data selected")
+def step_see_data_selected(context):
+    """
+    Wait to see select output.
+    """
+    wrappers.expect_pager(
+        context,
+        dedent(
+            """\
+            +-----+\r
+            | x   |\r
+            |-----|\r
+            | yyy |\r
+            +-----+\r
+            SELECT 1\r
+        """
+        ),
+        timeout=1,
+    )
+
+
+@then("we see record deleted")
+def step_see_data_deleted(context):
+    """
+    Wait to see delete output.
+    """
+    wrappers.expect_pager(context, "DELETE 1\r\n", timeout=2)
+
+
+@then("we see table dropped")
+def step_see_table_dropped(context):
+    """
+    Wait to see drop output.
+    """
+    wrappers.expect_pager(context, "DROP TABLE\r\n", timeout=2)
diff --git a/tests/features/steps/expanded.py b/tests/features/steps/expanded.py
new file mode 100644
index 0000000..f34fcf0
--- /dev/null
+++ b/tests/features/steps/expanded.py
@@ -0,0 +1,70 @@
+"""Steps for behavioral style tests are defined in this module.
+
+Each step is defined by the string decorating it. This string is used
+to call the step in "*.feature" file.
+
+"""
+
+from behave import when, then
+from textwrap import dedent
+import wrappers
+
+
+@when("we prepare the test data")
+def step_prepare_data(context):
+    """Create table, insert a record."""
+    context.cli.sendline("drop table if exists a;")
+    wrappers.expect_exact(
+        context,
+        "You're about to run a destructive command.\r\nDo you want to proceed? (y/n):",
+        timeout=2,
+    )
+    context.cli.sendline("y")
+
+    wrappers.wait_prompt(context)
+    context.cli.sendline("create table a(x integer, y real, z numeric(10, 4));")
+    wrappers.expect_pager(context, "CREATE TABLE\r\n", timeout=2)
+    context.cli.sendline("""insert into a(x, y, z) values(1, 1.0, 1.0);""")
+    wrappers.expect_pager(context, "INSERT 0 1\r\n", timeout=2)
+
+
+@when("we set expanded {mode}")
+def step_set_expanded(context, mode):
+    """Set expanded to mode."""
+    context.cli.sendline("\\" + "x {}".format(mode))
+    wrappers.expect_exact(context, "Expanded display is", timeout=2)
+    wrappers.wait_prompt(context)
+
+
+@then("we see {which} data selected")
+def step_see_data(context, which):
+    """Select data from expanded test table."""
+    if which == "expanded":
+        wrappers.expect_pager(
+            context,
+            dedent(
+                """\
+                -[ RECORD 1 ]-------------------------\r
+                x | 1\r
+                y | 1.0\r
+                z | 1.0000\r
+                SELECT 1\r
+            """
+            ),
+            timeout=1,
+        )
+    else:
+        wrappers.expect_pager(
+            context,
+            dedent(
+                """\
+                +-----+-----+--------+\r
+                | x   | y   | z      |\r
+                |-----+-----+--------|\r
+                | 1   | 1.0 | 1.0000 |\r
+                +-----+-----+--------+\r
+                SELECT 1\r
+            """
+            ),
+            timeout=1,
+        )
diff --git a/tests/features/steps/iocommands.py b/tests/features/steps/iocommands.py
new file mode 100644
index 0000000..613aeb2
--- /dev/null
+++ b/tests/features/steps/iocommands.py
@@ -0,0 +1,80 @@
+import os
+import os.path
+
+from behave import when, then
+import wrappers
+
+
+@when("we start external editor providing a file name")
+def step_edit_file(context):
+    """Edit file with external editor."""
+    context.editor_file_name = os.path.join(
+        context.package_root, "test_file_{0}.sql".format(context.conf["vi"])
+    )
+    if os.path.exists(context.editor_file_name):
+        os.remove(context.editor_file_name)
+    context.cli.sendline("\e {0}".format(os.path.basename(context.editor_file_name)))
+    wrappers.expect_exact(
+        context, 'Entering Ex mode.  Type "visual" to go to Normal mode.', timeout=2
+    )
+    wrappers.expect_exact(context, ":", timeout=2)
+
+
+@when("we type sql in the editor")
+def step_edit_type_sql(context):
+    context.cli.sendline("i")
+    context.cli.sendline("select * from abc")
+    context.cli.sendline(".")
+    wrappers.expect_exact(context, ":", timeout=2)
+
+
+@when("we exit the editor")
+def step_edit_quit(context):
+    context.cli.sendline("x")
+    wrappers.expect_exact(context, "written", timeout=2)
+
+
+@then("we see the sql in prompt")
+def step_edit_done_sql(context):
+    for match in "select * from abc".split(" "):
+        wrappers.expect_exact(context, match, timeout=1)
+    # Cleanup the command line.
+    context.cli.sendcontrol("c")
+    # Cleanup the edited file.
+    if context.editor_file_name and os.path.exists(context.editor_file_name):
+        os.remove(context.editor_file_name)
+    context.atprompt = True
+
+
+@when("we tee output")
+def step_tee_ouptut(context):
+    context.tee_file_name = os.path.join(
+        context.package_root, "tee_file_{0}.sql".format(context.conf["vi"])
+    )
+    if os.path.exists(context.tee_file_name):
+        os.remove(context.tee_file_name)
+    context.cli.sendline("\o {0}".format(os.path.basename(context.tee_file_name)))
+    wrappers.expect_exact(context, context.conf["pager_boundary"] + "\r\n", timeout=5)
+    wrappers.expect_exact(context, "Writing to file", timeout=5)
+    wrappers.expect_exact(context, context.conf["pager_boundary"] + "\r\n", timeout=5)
+    wrappers.expect_exact(context, "Time", timeout=5)
+
+
+@when('we query "select 123456"')
+def step_query_select_123456(context):
+    context.cli.sendline("select 123456")
+
+
+@when("we stop teeing output")
+def step_notee_output(context):
+    context.cli.sendline("\o")
+    wrappers.expect_exact(context, "Time", timeout=5)
+
+
+@then("we see 123456 in tee output")
+def step_see_123456_in_ouput(context):
+    with open(context.tee_file_name) as f:
+        assert "123456" in f.read()
+    if os.path.exists(context.tee_file_name):
+        os.remove(context.tee_file_name)
+    context.atprompt = True
diff --git a/tests/features/steps/named_queries.py b/tests/features/steps/named_queries.py
new file mode 100644
index 0000000..3f52859
--- /dev/null
+++ b/tests/features/steps/named_queries.py
@@ -0,0 +1,57 @@
+"""
+Steps for behavioral style tests are defined in this module.
+Each step is defined by the string decorating it.
+This string is used to call the step in "*.feature" file.
+"""
+
+from behave import when, then
+import wrappers
+
+
+@when("we save a named query")
+def step_save_named_query(context):
+    """
+    Send \ns command
+    """
+    context.cli.sendline("\\ns foo SELECT 12345")
+
+
+@when("we use a named query")
+def step_use_named_query(context):
+    """
+    Send \n command
+    """
+    context.cli.sendline("\\n foo")
+
+
+@when("we delete a named query")
+def step_delete_named_query(context):
+    """
+    Send \nd command
+    """
+    context.cli.sendline("\\nd foo")
+
+
+@then("we see the named query saved")
+def step_see_named_query_saved(context):
+    """
+    Wait to see query saved.
+    """
+    wrappers.expect_exact(context, "Saved.", timeout=2)
+
+
+@then("we see the named query executed")
+def step_see_named_query_executed(context):
+    """
+    Wait to see select output.
+    """
+    wrappers.expect_exact(context, "12345", timeout=1)
+    wrappers.expect_exact(context, "SELECT 1", timeout=1)
+
+
+@then("we see the named query deleted")
+def step_see_named_query_deleted(context):
+    """
+    Wait to see query deleted.
+    """
+    wrappers.expect_pager(context, "foo: Deleted\r\n", timeout=1)
diff --git a/tests/features/steps/specials.py b/tests/features/steps/specials.py
new file mode 100644
index 0000000..813292c
--- /dev/null
+++ b/tests/features/steps/specials.py
@@ -0,0 +1,26 @@
+"""
+Steps for behavioral style tests are defined in this module.
+Each step is defined by the string decorating it.
+This string is used to call the step in "*.feature" file.
+"""
+
+from behave import when, then
+import wrappers
+
+
+@when("we refresh completions")
+def step_refresh_completions(context):
+    """
+    Send refresh command.
+    """
+    context.cli.sendline("\\refresh")
+
+
+@then("we see completions refresh started")
+def step_see_refresh_started(context):
+    """
+    Wait to see refresh output.
+    """
+    wrappers.expect_pager(
+        context, "Auto-completion refresh started in the background.\r\n", timeout=2
+    )
diff --git a/tests/features/steps/wrappers.py b/tests/features/steps/wrappers.py
new file mode 100644
index 0000000..e0f5a20
--- /dev/null
+++ b/tests/features/steps/wrappers.py
@@ -0,0 +1,67 @@
+import re
+import pexpect
+from pgcli.main import COLOR_CODE_REGEX
+import textwrap
+
+try:
+    from StringIO import StringIO
+except ImportError:
+    from io import StringIO
+
+
+def expect_exact(context, expected, timeout):
+    timedout = False
+    try:
+        context.cli.expect_exact(expected, timeout=timeout)
+    except pexpect.TIMEOUT:
+        timedout = True
+    if timedout:
+        # Strip color codes out of the output.
+        actual = re.sub(r"\x1b\[([0-9A-Za-z;?])+[m|K]?", "", context.cli.before)
+        raise Exception(
+            textwrap.dedent(
+                """\
+                Expected:
+                ---
+                {0!r}
+                ---
+                Actual:
+                ---
+                {1!r}
+                ---
+                Full log:
+                ---
+                {2!r}
+                ---
+            """
+            ).format(expected, actual, context.logfile.getvalue())
+        )
+
+
+def expect_pager(context, expected, timeout):
+    expect_exact(
+        context,
+        "{0}\r\n{1}{0}\r\n".format(context.conf["pager_boundary"], expected),
+        timeout=timeout,
+    )
+
+
+def run_cli(context, run_args=None, prompt_check=True, currentdb=None):
+    """Run the process using pexpect."""
+    run_args = run_args or []
+    cli_cmd = context.conf.get("cli_command")
+    cmd_parts = [cli_cmd] + run_args
+    cmd = " ".join(cmd_parts)
+    context.cli = pexpect.spawnu(cmd, cwd=context.package_root)
+    context.logfile = StringIO()
+    context.cli.logfile = context.logfile
+    context.exit_sent = False
+    context.currentdb = currentdb or context.conf["dbname"]
+    context.cli.sendline("\pset pager always")
+    if prompt_check:
+        wait_prompt(context)
+
+
+def wait_prompt(context):
+    """Make sure prompt is displayed."""
+    expect_exact(context, "{0}> ".format(context.conf["dbname"]), timeout=5)