Fixed #29501 -- Allowed dbshell to pass options to underlying tool.

4 files changed, 56 insertions, 9 deletions

diff --git a/tests/dbshell/test_mysql.py b/tests/dbshell/test_mysql.py
index 6b60e2722e..91c1a6cd50 100644
--- a/tests/dbshell/test_mysql.py
+++ b/tests/dbshell/test_mysql.py
@@ -76,5 +76,23 @@ class MySqlDbshellCommandTestCase(SimpleTestCase):
                 },
             }))
 
-    def get_command_line_arguments(self, connection_settings):
-        return DatabaseClient.settings_to_cmd_args(connection_settings)
+    def test_parameters(self):
+        self.assertEqual(
+            ['mysql', 'somedbname', '--help'],
+            self.get_command_line_arguments(
+                {
+                    'NAME': 'somedbname',
+                    'USER': None,
+                    'PASSWORD': None,
+                    'HOST': None,
+                    'PORT': None,
+                    'OPTIONS': {},
+                },
+                ['--help'],
+            ),
+        )
+
+    def get_command_line_arguments(self, connection_settings, parameters=None):
+        if parameters is None:
+            parameters = []
+        return DatabaseClient.settings_to_cmd_args(connection_settings, parameters)
diff --git a/tests/dbshell/test_oracle.py b/tests/dbshell/test_oracle.py
index 431134e3ac..41fbc07455 100644
--- a/tests/dbshell/test_oracle.py
+++ b/tests/dbshell/test_oracle.py
@@ -8,17 +8,19 @@ from django.test import SimpleTestCase
 
 @skipUnless(connection.vendor == 'oracle', 'Oracle tests')
 class OracleDbshellTests(SimpleTestCase):
-    def _run_dbshell(self, rlwrap=False):
+    def _run_dbshell(self, rlwrap=False, parameters=None):
         """Run runshell command and capture its arguments."""
         def _mock_subprocess_run(*args, **kwargs):
             self.subprocess_args = list(*args)
             return CompletedProcess(self.subprocess_args, 0)
 
+        if parameters is None:
+            parameters = []
         client = DatabaseClient(connection)
         self.subprocess_args = None
         with mock.patch('subprocess.run', new=_mock_subprocess_run):
             with mock.patch('shutil.which', return_value='/usr/bin/rlwrap' if rlwrap else None):
-                client.runshell()
+                client.runshell(parameters)
         return self.subprocess_args
 
     def test_without_rlwrap(self):
@@ -32,3 +34,9 @@ class OracleDbshellTests(SimpleTestCase):
             self._run_dbshell(rlwrap=True),
             ['/usr/bin/rlwrap', 'sqlplus', '-L', connection._connect_string()],
         )
+
+    def test_parameters(self):
+        self.assertEqual(
+            self._run_dbshell(parameters=['-HELP']),
+            ['sqlplus', '-L', connection._connect_string(), '-HELP'],
+        )
diff --git a/tests/dbshell/test_postgresql.py b/tests/dbshell/test_postgresql.py
index 7047283bb3..6de60eaef2 100644
--- a/tests/dbshell/test_postgresql.py
+++ b/tests/dbshell/test_postgresql.py
@@ -9,7 +9,7 @@ from django.test import SimpleTestCase
 
 class PostgreSqlDbshellCommandTestCase(SimpleTestCase):
 
-    def _run_it(self, dbinfo):
+    def _run_it(self, dbinfo, parameters=None):
         """
         That function invokes the runshell command, while mocking
         subprocess.run(). It returns a 2-tuple with:
@@ -21,8 +21,11 @@ class PostgreSqlDbshellCommandTestCase(SimpleTestCase):
             # PostgreSQL environment variables.
             self.pg_env = {key: env[key] for key in env if key.startswith('PG')}
             return subprocess.CompletedProcess(self.subprocess_args, 0)
+
+        if parameters is None:
+            parameters = []
         with mock.patch('subprocess.run', new=_mock_subprocess_run):
-            DatabaseClient.runshell_db(dbinfo)
+            DatabaseClient.runshell_db(dbinfo, parameters)
         return self.subprocess_args, self.pg_env
 
     def test_basic(self):
@@ -104,6 +107,12 @@ class PostgreSqlDbshellCommandTestCase(SimpleTestCase):
             )
         )
 
+    def test_parameters(self):
+        self.assertEqual(
+            self._run_it({'database': 'dbname'}, ['--help']),
+            (['psql', 'dbname', '--help'], {}),
+        )
+
     def test_sigint_handler(self):
         """SIGINT is ignored in Python and passed to psql to abort queries."""
         def _mock_subprocess_run(*args, **kwargs):
@@ -114,6 +123,6 @@ class PostgreSqlDbshellCommandTestCase(SimpleTestCase):
         # The default handler isn't SIG_IGN.
         self.assertNotEqual(sigint_handler, signal.SIG_IGN)
         with mock.patch('subprocess.run', new=_mock_subprocess_run):
-            DatabaseClient.runshell_db({})
+            DatabaseClient.runshell_db({}, [])
         # dbshell restores the original handler.
         self.assertEqual(sigint_handler, signal.getsignal(signal.SIGINT))
diff --git a/tests/dbshell/test_sqlite.py b/tests/dbshell/test_sqlite.py
index 46d09895c8..c3b2b1e28d 100644
--- a/tests/dbshell/test_sqlite.py
+++ b/tests/dbshell/test_sqlite.py
@@ -9,15 +9,17 @@ from django.test import SimpleTestCase
 
 @skipUnless(connection.vendor == 'sqlite', 'SQLite tests.')
 class SqliteDbshellCommandTestCase(SimpleTestCase):
-    def _run_dbshell(self):
+    def _run_dbshell(self, parameters=None):
         """Run runshell command and capture its arguments."""
         def _mock_subprocess_run(*args, **kwargs):
             self.subprocess_args = list(*args)
             return CompletedProcess(self.subprocess_args, 0)
 
+        if parameters is None:
+            parameters = []
         client = DatabaseClient(connection)
         with mock.patch('subprocess.run', new=_mock_subprocess_run):
-            client.runshell()
+            client.runshell(parameters)
         return self.subprocess_args
 
     def test_path_name(self):
@@ -29,3 +31,13 @@ class SqliteDbshellCommandTestCase(SimpleTestCase):
                 self._run_dbshell(),
                 ['sqlite3', 'test.db.sqlite3'],
             )
+
+    def test_parameters(self):
+        with mock.patch.dict(
+            connection.settings_dict,
+            {'NAME': Path('test.db.sqlite3')},
+        ):
+            self.assertEqual(
+                self._run_dbshell(['-help']),
+                ['sqlite3', 'test.db.sqlite3', '-help'],
+            )