Some refactoring caugh by real testing.

Don not call the function twice

Signed-off-by: Petr "Stone" Hracek <phracek@redhat.com>

Author: phracek

test/test_container_basics.py

@@ -1,6 +1,9 @@
+import shutil
+
 from pathlib import Path
 
 from container_ci_suite.container_lib import ContainerTestLib
+from container_ci_suite.utils import ContainerTestLibUtils
 
 from conftest import VARS, create_postgresql_temp_file
 
@@ -23,15 +26,21 @@ class TestPostgreSQLBasicsContainer:
     """
 
     def setup_method(self):
+        """
+        Setup the test environment.
+        """
         self.app_image = build_s2i_app(app_path=VARS.TEST_DIR / "test-app")
         self.app_image.db_lib.db_type = "postgresql"
 
     def teardown_method(self):
+        """
+        Teardown the test environment.
+        """
         self.app_image.cleanup()
 
     def test_s2i_usage(self):
         """
-        Test container creation fails with invalid combinations of arguments.
+        Test container creation based on s2i technology.
         """
         cid_config_build = "s2i_config_build"
         psql_password = "password"
@@ -70,14 +79,16 @@ def test_s2i_usage(self):
             password=psql_backup_password,
             database="backup",
         )
-        tmp_file = create_postgresql_temp_file()
         backup_user_script = (
             VARS.TEST_DIR / "test-app" / "postgresql-init" / "backup_user.sh"
         )
-        with open(backup_user_script, "r") as f:
-            backup_user_script_content = f.read()
-        with open(tmp_file, "w") as f:
-            f.write(backup_user_script_content)
+        tmp_file = create_postgresql_temp_file()
+        shutil.copy(backup_user_script, tmp_file)
+        ContainerTestLibUtils.commands_to_run(
+            commands_to_run=[
+                f"setfacl -m u:26:rw- {tmp_file}",
+            ]
+        )
         cid_s2i_test_mount = "s2i_test_mount"
         mount_point = "/opt/app-root/src/postgresql-init/add_backup_user.sh"
         assert self.app_image.create_container(

test/test_container_configuration.py

@@ -18,6 +18,7 @@ def setup_method(self):
         """
         self.db = ContainerTestLib(image_name=VARS.IMAGE_NAME, db_type="postgresql")
         self.db_api = DatabaseWrapper(image_name=VARS.IMAGE_NAME, db_type="postgresql")
+        self.volume_dir = create_postgresql_volume_dir()
 
     def teardown_method(self):
         """
@@ -142,16 +143,10 @@ def test_invalid_configuration_tests(
                 "-e POSTGRESQL_ADMIN_PASSWORD=",
             ],
             [
-                "-e POSTGRESQL_USER=user",
-                "-e POSTGRESQL_PASSWORD=pass",
-                "-e POSTGRESQL_DATABASE=db",
-                "-e POSTGRESQL_ADMIN_PASSWORD=",
-            ],
-            [
-                "-e POSTGRESQL_USER=",
-                "-e POSTGRESQL_PASSWORD=",
-                "-e POSTGRESQL_DATABASE=",
-                '-e POSTGRESQL_ADMIN_PASSWORD="The @password"',
+                "",
+                "",
+                "",
+                '-e POSTGRESQL_ADMIN_PASSWORD="the @password"',
             ],
             [
                 '-e POSTGRESQL_USER="the user"',
@@ -185,13 +180,21 @@ def test_configuration_hook(self):
         """
         Test container creation fails with no arguments.
         """
-        cid_file_name = "test_pg_hook"
-        volume_dir = create_postgresql_volume_dir()
+        self.shared_buffer_test("32MB")
+        self.shared_buffer_test("113MB")
+        self.shared_buffer_test("111MB")
+
+    def shared_buffer_test(self, shared_buffer_value):
+        """
+        Test shared buffer configuration.
+        """
+        cid_file_name = f"test_pg_hook_{shared_buffer_value}"
         docker_args = [
             "-e POSTGRESQL_ADMIN_PASSWORD=password",
-            "-e POSTGRESQL_SHARED_BUFFERS=32MB",
-            f"-v {volume_dir}:/opt/app-root/src:Z",
+            f"-e POSTGRESQL_SHARED_BUFFERS={shared_buffer_value}",
+            f"-v {self.volume_dir}:/opt/app-root/src:Z",
         ]
+
         assert self.db.create_container(
             cid_file_name=cid_file_name,
             docker_args=docker_args,
@@ -208,52 +211,6 @@ def test_configuration_hook(self):
             cid_file_name=cid,
             cmd='psql -tA -c "SHOW shared_buffers;"',
         )
-        assert "32MB" in output, f"Shared buffers should be 32MB, but is {output}"
-        # Check that POSTGRESQL_SHARED_BUFFERS has effect.
-        docker_args = [
-            "-e POSTGRESQL_ADMIN_PASSWORD=password",
-            "-e POSTGRESQL_SHARED_BUFFERS=113MB",
-        ]
-        cid_file_name2 = "test_pg_hook_2"
-        assert self.db.create_container(
-            cid_file_name=cid_file_name2,
-            docker_args=docker_args,
-            command="",
+        assert shared_buffer_value in output, (
+            f"Shared buffers should be {shared_buffer_value}, but is {output}"
         )
-        cid = self.db.get_cid(cid_file_name=cid_file_name2)
-        assert cid
-        cip = self.db.get_cip(cid_file_name=cid_file_name2)
-        assert cip
-        assert self.db_api.wait_for_database(
-            container_id=cid, command="/usr/libexec/check-container"
-        )
-        output = PodmanCLIWrapper.podman_exec_shell_command(
-            cid_file_name=cid,
-            cmd='psql -tA -c "SHOW shared_buffers;"',
-        )
-        assert "113MB" in output, f"Shared buffers should be 113MB, but is {output}"
-        # Check that volume has priority over POSTGRESQL_SHARED_BUFFERS.
-        cid_file_name3 = "test_pg_hook_3"
-        docker_args = [
-            "-e POSTGRESQL_ADMIN_PASSWORD=password",
-            "-e POSTGRESQL_SHARED_BUFFERS=113MB",
-            f"-v {volume_dir}:/opt/app-root/src:Z",
-        ]
-        assert self.db.create_container(
-            cid_file_name=cid_file_name3,
-            docker_args=docker_args,
-            command="",
-        )
-        cid = self.db.get_cid(cid_file_name=cid_file_name3)
-        assert cid
-        cip = self.db.get_cip(cid_file_name=cid_file_name3)
-        assert cip
-        assert self.db_api.wait_for_database(
-            container_id=cid, command="/usr/libexec/check-container"
-        )
-        output = PodmanCLIWrapper.podman_exec_shell_command(
-            cid_file_name=cid,
-            cmd='psql -tA -c "SHOW shared_buffers;"',
-        )
-
-        assert "113MB" in output, f"Shared buffers should be 113MB, but is {output}"

test/test_container_general.py

@@ -33,10 +33,10 @@ def teardown_method(self):
         [
             ("", "user", "pass", "", "", "no_admin"),
             ("", "user1", "pass1", "", "r00t", "admin"),
-            # ("", "", "", "postgres", "r00t", "only_admin"),
+            ("", "", "", "postgres", "r00t", "only_admin"),
             ("-u 12345", "user2", "pass", "", "", "no_admin_altuid"),
             ("-u 12345", "user3", "pass1", "", "r00t", "admin_altuid"),
-            # ("-u 12345", "", "", "postgres", "r00t", "only_admin_altuid"),
+            ("-u 12345", "", "", "postgres", "r00t", "only_admin_altuid"),
         ],
     )
     def test_run(
@@ -60,28 +60,24 @@ def test_run(
             POSTGRESQL_SHARED_BUFFERS = "64MB"
         expected_success = False
         expected_admin_success = False
+        psql_user_arg = ""
+        psql_pwd_arg = ""
+        db_name_arg = ""
+        admin_root_password_arg = ""
         if psql_user != "":
             psql_user_arg = f"-e POSTGRESQL_USER={psql_user}"
             expected_success = True
-        else:
-            psql_user_arg = ""
         if psql_password:  # empty password is allowed
             psql_pwd_arg = f"-e POSTGRESQL_PASSWORD={psql_password}"
-        else:
-            psql_pwd_arg = ""
-        if psql_database:
-            db_name = psql_database
-        else:
-            db_name = "db"
+        if psql_user and psql_password:
+            db_name_arg = "-e POSTGRESQL_DATABASE=db"
         if root_password == "r00t":
             admin_root_password_arg = f"-e POSTGRESQL_ADMIN_PASSWORD={root_password}"
             expected_admin_success = True
-        else:
-            admin_root_password_arg = ""
         docker_all_args = [
             psql_user_arg,
             psql_pwd_arg,
-            f"-e POSTGRESQL_DATABASE={db_name}",
+            db_name_arg,
             admin_root_password_arg,
             f"-e POSTGRESQL_MAX_CONNECTIONS={POSTGRESQL_MAX_CONNECTIONS}",
             f"-e POSTGRESQL_MAX_PREPARED_TRANSACTIONS={POSTGRESQL_MAX_PREPARED_TRANSACTIONS}",
@@ -115,30 +111,29 @@ def test_run(
             cmd="psql --version",
         )
         assert VARS.VERSION in output
-        self.db_image.db_lib.assert_login_access(
-            container_ip=cip,
-            username=psql_user,
-            password=psql_password,
-            expected_success=expected_success,
-        )
-        self.db_image.db_lib.assert_login_access(
-            container_ip=cip,
-            username=psql_user,
-            password=f"{psql_password}_foo",
-            expected_success=False,
-        )
-        self.db_image.db_lib.assert_login_access(
-            container_ip=cip,
-            username="postgres",
-            password=root_password,
-            expected_success=expected_admin_success,
-        )
-        self.db_image.db_lib.assert_login_access(
-            container_ip=cip,
-            username="postgres",
-            password=f"{root_password}_foo",
-            expected_success=False,
-        )
+        access_output = True
+        if psql_database == "":
+            psql_database = "db"
+        for user, pwd, ret_value in [
+            (psql_user, psql_password, expected_success),
+            (psql_user, f"{psql_password}_foo", False),
+            ("postgres", root_password, expected_admin_success),
+            ("postgres", f"{root_password}_foo", False),
+        ]:
+            test_assert = self.db_image.db_lib.assert_login_access(
+                container_ip=cip,
+                username=user,
+                password=pwd,
+                expected_success=ret_value,
+                database=psql_database,
+            )
+            if not test_assert:
+                print(
+                    f"Login access failed for {user}:{pwd} with expected success {ret_value}"
+                )
+                access_output = False
+                break
+        assert access_output, "Login access failed for above results"
         assert self.db_image.db_lib.assert_local_access(container_id=cid)
         output = PodmanCLIWrapper.podman_exec_shell_command(
             cid_file_name=cid,
@@ -154,24 +149,30 @@ def test_run(
             assert re.search(word, output), f"Word {word} not found in {output}"
         # test_postgresql
         if test_name == "admin":
-            psql_user = "postgres"
-            psql_password = root_password
-            psql_database = "postgres"
             output = self.db_api.run_sql_command(
                 container_ip=cip,
-                username=psql_user,
-                password=psql_password,
+                username="postgres",
+                password=root_password,
                 container_id=VARS.IMAGE_NAME,
-                database=db_name,
+                database="postgres",
                 sql_cmd="-At -c 'CREATE EXTENSION \"uuid-ossp\";'",
                 expected_output="CREATE EXTENSION",
             )
+        if psql_password == "":
+            psql_password = root_password
+
+        self.database_test(cip, psql_user, psql_password, psql_database)
+
+    def database_test(self, cip, psql_user, psql_password, psql_database):
+        """
+        Test PostgreSQL database creation.
+        """
         output = self.db_api.run_sql_command(
             container_ip=cip,
             username=psql_user,
             password=psql_password,
             container_id=VARS.IMAGE_NAME,
-            database=db_name,
+            database=psql_database,
             sql_cmd='-At -c "CREATE TABLE tbl (a integer, b integer);"',
             expected_output="CREATE TABLE",
         )
@@ -181,7 +182,7 @@ def test_run(
             username=psql_user,
             password=psql_password,
             container_id=VARS.IMAGE_NAME,
-            database=db_name,
+            database=psql_database,
             sql_cmd=[
                 '-At -c "INSERT INTO tbl VALUES (1, 2);"',
                 '-At -c "INSERT INTO tbl VALUES (3, 4);"',
@@ -194,7 +195,7 @@ def test_run(
             username=psql_user,
             password=psql_password,
             container_id=VARS.IMAGE_NAME,
-            database=db_name,
+            database=psql_database,
             sql_cmd='-At -c "SELECT * FROM tbl;"',
         )
         words = [
@@ -209,7 +210,7 @@ def test_run(
             username=psql_user,
             password=psql_password,
             container_id=VARS.IMAGE_NAME,
-            database=db_name,
+            database=psql_database,
             sql_cmd='-At -c "DROP TABLE tbl;"',
             expected_output="DROP TABLE",
         )

test/test_container_password.py

@@ -64,13 +64,13 @@ def test_password_change(self):
         )
         cid1 = self.pwd_change.get_cid(cid_file_name=cid_file_name1)
         assert cid1
-        self.pwd_change.db_lib.assert_login_access(
+        assert self.pwd_change.db_lib.assert_login_access(
             container_ip=cip1,
             username=username,
             password=password,
             expected_success=True,
         )
-        self.pwd_change.db_lib.assert_login_access(
+        assert self.pwd_change.db_lib.assert_login_access(
             container_ip=cip1,
             username="postgres",
             password=admin_password,
@@ -135,36 +135,26 @@ def test_password_change(self):
         )
         cip_new = self.pwd_change.get_cip(cid_file_name=cid_file_name_new)
         assert cip_new
+
         assert self.pwd_change.test_db_connection(
             container_ip=cip_new,
             username=username,
             password=new_password,
             max_attempts=10,
         )
-        self.pwd_change.db_lib.assert_login_access(
-            container_ip=cip_new,
-            username=username,
-            password=new_password,
-            expected_success=True,
-        )
-        self.pwd_change.db_lib.assert_login_access(
-            container_ip=cip_new,
-            username=username,
-            password=password,
-            expected_success=False,
-        )
-        self.pwd_change.db_lib.assert_login_access(
-            container_ip=cip_new,
-            username="postgres",
-            password=new_admin_password,
-            expected_success=True,
-        )
-        self.pwd_change.db_lib.assert_login_access(
-            container_ip=cip_new,
-            username="postgres",
-            password=admin_password,
-            expected_success=False,
-        )
+        for user, pwd, ret_value in [
+            (username, new_password, True),
+            (username, password, False),
+            ("postgres", new_admin_password, True),
+            ("postgres", "admin_password", False),
+        ]:
+            assert self.pwd_change.db_lib.assert_login_access(
+                container_ip=cip_new,
+                username=user,
+                password=pwd,
+                expected_success=ret_value,
+            )
+
         output = self.dw_api.run_sql_command(
             container_ip=cip_new,
             username=username,