Update code based on the already reviewed mariadb-container

sclorg/mariadb-container#311

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

Author: phracek

test/conftest.py

@@ -31,8 +31,8 @@
 VERSION = os.getenv("VERSION")
 OS = os.getenv("TARGET").lower()
 TEST_APP = TEST_DIR / "test-app"
-VERY_LONG_DB_NAME = "very_long_database_name_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
-VERY_LONG_USER_NAME = "very_long_user_name_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+VERY_LONG_DB_NAME = "very_long_database_name_" + "x" * 40
+VERY_LONG_USER_NAME = "very_long_user_name_" + "x" * 40
 VARS = Vars(
     OS=OS,
     VERSION=VERSION,

test/test_container_basics.py

@@ -27,18 +27,28 @@ class TestMySqlBasicsContainer:
     """
 
     def setup_method(self):
-        self.s2i_db = build_s2i_app(app_path=VARS.TEST_DIR / "test-app")
-        self.s2i_db.set_new_db_type(db_type="mysql")
+        """
+        Setup the test environment.
+        """
+        self.app_image = build_s2i_app(app_path=VARS.TEST_DIR / "test-app")
+        self.app_image.set_new_db_type(db_type="mysql")
 
     def teardown_method(self):
-        self.s2i_db.cleanup()
+        """
+        Teardown the test environment.
+        """
+        self.app_image.cleanup()
 
     def test_s2i_usage(self):
         """
-        Test container creation fails with invalid combinations of arguments.
+        Test if MySQL container failed in case of invalid combinations.
+        Steps are:
+        1. Test if the container creation fails with invalid combinations of arguments
+        2. Test if the container creation succeeds with valid combinations of arguments
+        3. Test if the database connection works
         """
-        cid_config_build = "s2i_config_build"
-        self.s2i_db.assert_container_creation_fails(
+        cid_config_build = "s2i_usage_build"
+        self.app_image.assert_container_creation_fails(
             cid_file_name=cid_config_build,
             command="",
             container_args=[
@@ -48,7 +58,7 @@ def test_s2i_usage(self):
                 "-e MYSQL_ROOT_PASSWORD=pass",
             ],
         )
-        assert self.s2i_db.create_container(
+        assert self.app_image.create_container(
             cid_file_name=cid_config_build,
             container_args=[
                 "-e MYSQL_USER=config_test_user",
@@ -58,22 +68,20 @@ def test_s2i_usage(self):
                 "-e MYSQL_OPERATIONS_PASSWORD=operations_user",
             ],
         )
-        cip = self.s2i_db.get_cip(cid_file_name=cid_config_build)
-        assert cip
-        assert self.s2i_db.test_db_connection(
+        cip, cid = self.app_image.get_cip_cid(cid_file_name=cid_config_build)
+        assert cip, cid
+        assert self.app_image.test_db_connection(
             container_ip=cip, username="operations_user", password="operations_user"
         )
-        cid = self.s2i_db.get_cid(cid_file_name=cid_config_build)
-        db_configuration = PodmanCLIWrapper.podman_exec_shell_command(
-            cid_file_name=cid,
-            cmd="cat /etc/my.cnf /etc/my.cnf.d/*",
-        )
-        assert db_configuration
         PodmanCLIWrapper.call_podman_command(cmd=f"stop {cid}")
 
     def test_s2i_usage_with_mount(self):
         """
-        Test container creation fails with invalid combinations of arguments.
+        Test if the MySQL container works properly with mounted application directory.
+        Steps are:
+        1. Copy the test-app directory to a temporary directory and set proper permissions
+        2. Create a container with the mounted directory
+        3. Test if the database connection works with the operations user
         """
         data_dir = tempfile.mkdtemp(prefix="/tmp/mysql-test_data")
         shutil.copytree(VARS.TEST_DIR / "test-app", f"{data_dir}/test-app")
@@ -83,7 +91,7 @@ def test_s2i_usage_with_mount(self):
             ]
         )
         cid_s2i_test_mount = "s2i_test_mount"
-        self.s2i_db.create_container(
+        self.app_image.create_container(
             cid_file_name=cid_s2i_test_mount,
             container_args=[
                 "-e MYSQL_USER=config_test_user",
@@ -94,15 +102,13 @@ def test_s2i_usage_with_mount(self):
                 f"-v {data_dir}/test-app:/opt/app-root/src/:z",
             ],
         )
-        cip_test_mount = self.s2i_db.get_cip(cid_file_name=cid_s2i_test_mount)
-        assert cip_test_mount
-        assert self.s2i_db.test_db_connection(
-            container_ip=cip_test_mount,
+        cip, cid = self.app_image.get_cip_cid(cid_file_name=cid_s2i_test_mount)
+        assert cip, cid
+        assert self.app_image.test_db_connection(
+            container_ip=cip,
             username="operations_user",
             password="operations_pass",
             max_attempts=10,
         )
-        cid = self.s2i_db.get_cid(cid_file_name=cid_s2i_test_mount)
-        assert cid
         PodmanCLIWrapper.call_podman_command(cmd=f"stop {cid}")
         shutil.rmtree(data_dir)

test/test_container_configuration.py

@@ -52,60 +52,81 @@ def test_try_image_invalid_combinations(self, container_args):
         )
 
     @pytest.mark.parametrize(
-        "container_args",
+        "mysql_user, mysql_password, mysql_database, mysql_root_password",
         [
-            ["-e", "MYSQL_USER=user", "-e", "MYSQL_PASSWORD=pass"],
+            ["user", "pass", "", ""],
             [
-                "-e MYSQL_USER=$invalid",
-                "-e MYSQL_PASSWORD=pass",
-                "-e MYSQL_DATABASE=db",
-                "-e MYSQL_ROOT_PASSWORD=root_pass",
+                "$invalid",
+                "pass",
+                "db",
+                "root_pass",
             ],
             [
-                f"-e MYSQL_USER={VARS.VERY_LONG_USER_NAME}",
-                "-e MYSQL_PASSWORD=pass",
-                "-e MYSQL_DATABASE=db",
-                "-e MYSQL_ROOT_PASSWORD=root_pass",
+                VARS.VERY_LONG_USER_NAME,
+                "pass",
+                "db",
+                "root_pass",
             ],
             [
-                "-e MYSQL_USER=user",
-                "-e MYSQL_PASSWORD=",
-                "-e MYSQL_DATABASE=db",
-                "-e MYSQL_ROOT_PASSWORD=root_pass",
+                "user",
+                "",
+                "db",
+                "root_pass",
             ],
             [
-                "-e MYSQL_USER=user",
-                "-e MYSQL_PASSWORD=pass",
-                "-e MYSQL_DATABASE=$invalid",
-                "-e MYSQL_ROOT_PASSWORD=root_pass",
+                "user",
+                "pass",
+                "$invalid",
+                "root_pass",
             ],
             [
-                "-e MYSQL_USER=user",
-                "-e MYSQL_PASSWORD=pass",
-                f"-e MYSQL_DATABASE={VARS.VERY_LONG_DB_NAME}",
-                "-e MYSQL_ROOT_PASSWORD=root_pass",
+                "user",
+                "pass",
+                VARS.VERY_LONG_DB_NAME,
+                "root_pass",
             ],
             [
-                "-e MYSQL_USER=user",
-                "-e MYSQL_PASSWORD=pass",
-                "-e MYSQL_DATABASE=db",
-                "-e MYSQL_ROOT_PASSWORD=",
+                "user",
+                "pass",
+                "db",
+                "",
             ],
             [
-                "-e MYSQL_USER=root",
-                "-e MYSQL_PASSWORD=pass",
-                "-e MYSQL_DATABASE=db",
-                "-e MYSQL_ROOT_PASSWORD=pass",
+                "root",
+                "pass",
+                "db",
+                "pass",
             ],
         ],
     )
-    def test_invalid_configuration_tests(self, container_args):
+    def test_invalid_configuration_tests(
+        self, mysql_user, mysql_password, mysql_database, mysql_root_password
+    ):
         """
         Test invalid configuration combinations for MySQL container.
         """
         cid_config_test = "invalid_configuration_tests"
+        mysql_user_arg = f"-e MYSQL_USER={mysql_user}" if mysql_user else ""
+        mysql_password_arg = (
+            f"-e MYSQL_PASSWORD={mysql_password}" if mysql_password else ""
+        )
+        mysql_database_arg = (
+            f"-e MYSQL_DATABASE={mysql_database}" if mysql_database else ""
+        )
+        mysql_root_password_arg = (
+            f"-e MYSQL_ROOT_PASSWORD={mysql_root_password}"
+            if mysql_root_password
+            else ""
+        )
         assert self.db.assert_container_creation_fails(
-            cid_file_name=cid_config_test, container_args=container_args, command=""
+            cid_file_name=cid_config_test,
+            container_args=[
+                mysql_user_arg,
+                mysql_password_arg,
+                mysql_database_arg,
+                mysql_root_password_arg,
+            ],
+            command="",
         )
 
 
@@ -119,7 +140,6 @@ def setup_method(self):
         Setup the test environment.
         """
         self.db_config = ContainerTestLib(image_name=VARS.IMAGE_NAME)
-        self.db_config.set_new_db_type(db_type="mysql")
         self.db_api = DatabaseWrapper(image_name=VARS.IMAGE_NAME)
 
     def teardown_method(self):
@@ -131,6 +151,12 @@ def teardown_method(self):
     def test_configuration_auto_calculated_settings(self):
         """
         Test MySQL container configuration auto-calculated settings.
+        Steps are:
+        1. Create a container with the given arguments
+        2. Check if the container is created successfully
+        3. Check if the database connection works
+        4. Check if the database configurations are correct
+        5. Stop the container
         """
         cid_config_test = "auto-config_test"
         username = "config_test_user"
@@ -146,30 +172,29 @@ def test_configuration_auto_calculated_settings(self):
             ],
             docker_args="--memory=512m",
         )
-        cip = self.db_config.get_cip(cid_file_name=cid_config_test)
-        assert cip
+        cip, cid = self.db_config.get_cip_cid(cid_file_name=cid_config_test)
+        assert cip, cid
         assert self.db_config.test_db_connection(
             container_ip=cip,
             username=username,
             password=password,
             max_attempts=10,
         )
-        cid = self.db_config.get_cid(cid_file_name=cid_config_test)
         db_configuration = PodmanCLIWrapper.podman_exec_shell_command(
             cid_file_name=cid,
             cmd="cat /etc/my.cnf /etc/my.cnf.d/*",
         )
-        words = [
-            "key_buffer_size\\s*=\\s*51M",
-            "read_buffer_size\\s*=\\s*25M",
-            "innodb_buffer_pool_size\\s*=\\s*256M",
-            "innodb_log_file_size\\s*=\\s*76M",
-            "innodb_log_buffer_size\\s*=\\s*76M",
-            "authentication_policy\\s*=\\s*'caching_sha2_password,,'",
+        expected_values = [
+            r"key_buffer_size\s*=\s*51M",
+            r"read_buffer_size\s*=\s*25M",
+            r"innodb_buffer_pool_size\s*=\s*256M",
+            r"innodb_log_file_size\s*=\s*76M",
+            r"innodb_log_buffer_size\s*=\s*76M",
+            r"authentication_policy\s*=\s*'caching_sha2_password,,'",
         ]
-        for word in words:
-            assert re.search(word, db_configuration), (
-                f"Word {word} not found in {db_configuration}"
+        for value in expected_values:
+            assert re.search(value, db_configuration), (
+                f"Expected value {value} not found in {db_configuration}"
             )
         # do some real work to test replication in practice
         self.db_api.run_sql_command(
@@ -192,6 +217,7 @@ def test_configuration_auto_calculated_settings(self):
         assert "COLLATE=latin2_czech_cs" in show_table_output
         PodmanCLIWrapper.call_podman_command(cmd=f"stop {cid}")
 
+    # FIX
     def test_configuration_options_settings(self):
         """
         Test MySQL container configuration options.
@@ -218,44 +244,39 @@ def test_configuration_options_settings(self):
                 "--env MYSQL_INNODB_BUFFER_POOL_SIZE=16M",
                 "--env MYSQL_INNODB_LOG_FILE_SIZE=4M",
                 "--env MYSQL_INNODB_LOG_BUFFER_SIZE=4M",
-                "--env MYSQL_AUTHENTICATION_POLICY=sha256_password",
+                "--env MYSQL_AUTHENTICATION_POLICY=sha256_password,,",
+                "--env WORKAROUND_DOCKER_BUG_14203=",
             ],
         )
-        cip = self.db_config.get_cip(cid_file_name=cid_config_test)
-        assert cip
-        assert self.db_config.test_db_connection(
-            container_ip=cip, username=username, password=password
-        )
-        cip = self.db_config.get_cip(cid_file_name=cid_config_test)
-        assert cip
+        cip, cid = self.db_config.get_cip_cid(cid_file_name=cid_config_test)
+        assert cip, cid
         assert self.db_config.test_db_connection(
             container_ip=cip,
             username=username,
             password=password,
             max_attempts=10,
         )
-        cid = self.db_config.get_cid(cid_file_name=cid_config_test)
         db_configuration = PodmanCLIWrapper.podman_exec_shell_command(
             cid_file_name=cid,
             cmd="cat /etc/my.cnf /etc/my.cnf.d/*",
         )
-        words = [
-            "lower_case_table_names\\s*=\\s*1",
-            "general_log\\s*=\\s*1",
-            "max_connections\\s*=\\s*1337",
-            "ft_min_word_len\\s*=\\s*8",
-            "ft_max_word_len\\s*=\\s*15",
-            "max_allowed_packet\\s*=\\s*10M",
-            "table_open_cache\\s*=\\s*100",
-            "sort_buffer_size\\s*=\\s*256K",
-            "key_buffer_size\\s*=\\s*16M",
-            "read_buffer_size\\s*=\\s*16M",
-            "innodb_log_file_size\\s*=\\s*4M",
-            "innodb_log_buffer_size\\s*=\\s*4M",
-            "authentication_policy\\s*=\\s*'sha256_password'",
+        expected_values = [
+            r"lower_case_table_names\s*=\s*1",
+            r"general_log\s*=\s*1",
+            r"max_connections\s*=\s*1337",
+            r"ft_min_word_len\s*=\s*8",
+            r"ft_max_word_len\s*=\s*15",
+            r"max_allowed_packet\s*=\s*10M",
+            r"table_open_cache\s*=\s*100",
+            r"sort_buffer_size\s*=\s*256K",
+            r"key_buffer_size\s*=\s*16M",
+            r"read_buffer_size\s*=\s*16M",
+            r"innodb_log_file_size\s*=\s*4M",
+            r"innodb_log_buffer_size\s*=\s*4M",
+            r"authentication_policy\s*=\s*'sha256_password,,'",
         ]
-        for word in words:
-            assert re.search(word, db_configuration), (
-                f"Word {word} not found in {db_configuration}"
+        for value in expected_values:
+            assert re.search(value, db_configuration), (
+                f"Expected value {value} not found in {db_configuration}"
             )
         PodmanCLIWrapper.call_podman_command(cmd=f"stop {cid}")