[#228] add test container metrics

Signed-off-by: a.berezin <a.berezin@yadro.com>

pytest_tests/testsuites/acl/test_eacl.py

@@ -92,7 +92,7 @@ class TestEACLContainer(ClusterTestBase):
                     cluster=self.cluster,
                 )
 
-            with reporter.step(f"Check {not_deny_role_wallet} has full access to eACL public container"):
+            with reporter.step(f"Check {not_deny_role_str} has full access to eACL public container"):
                 check_full_access_to_container(
                     not_deny_role_wallet,
                     cid,

pytest_tests/testsuites/conftest.py

@@ -23,7 +23,7 @@ from frostfs_testlib.resources.common import (
 )
 from frostfs_testlib.s3 import AwsCliClient, Boto3ClientWrapper, S3ClientWrapper, VersioningStatus
 from frostfs_testlib.shell import LocalShell, Shell
-from frostfs_testlib.steps.cli.container import DEFAULT_PLACEMENT_RULE, DEFAULT_EC_PLACEMENT_RULE
+from frostfs_testlib.steps.cli.container import DEFAULT_EC_PLACEMENT_RULE, DEFAULT_PLACEMENT_RULE
 from frostfs_testlib.steps.cli.object import get_netmap_netinfo
 from frostfs_testlib.steps.s3 import s3_helper
 from frostfs_testlib.storage import get_service_registry
@@ -210,6 +210,7 @@ def object_size(
 
     return complex_object_size
 
+
 @pytest.fixture(scope="session")
 def rep_placement_policy() -> PlacementPolicy:
     return PlacementPolicy("rep", DEFAULT_PLACEMENT_RULE)
@@ -222,10 +223,7 @@ def ec_placement_policy() -> PlacementPolicy:
 
 # By default we want all tests to be executed with both storage policies.
 # This can be overriden in choosen tests if needed.
-@pytest.fixture(
-    scope="session",
-    params=[pytest.param("rep", marks=pytest.mark.rep), pytest.param("ec", marks=pytest.mark.ec)],
-)
+@pytest.fixture(scope="session", params=[pytest.param("rep", marks=pytest.mark.rep)])
 def placement_policy(
     rep_placement_policy: PlacementPolicy, ec_placement_policy: PlacementPolicy, request: pytest.FixtureRequest
 ) -> PlacementPolicy:
@@ -234,6 +232,7 @@ def placement_policy(
 
     return ec_placement_policy
 
+
 @pytest.fixture(scope="session")
 def cluster(temp_directory: str, hosting: Hosting, client_shell: Shell) -> Cluster:
     cluster = Cluster(hosting)

pytest_tests/testsuites/metrics/test_container_metrics.py

@@ -0,0 +1,97 @@
+import math
+import re
+
+import allure
+import pytest
+from frostfs_testlib import reporter
+from frostfs_testlib.steps.cli.container import create_container, delete_container
+from frostfs_testlib.steps.cli.object import delete_object, get_object_nodes, put_object_to_random_node
+from frostfs_testlib.storage.cluster import Cluster, ClusterNode
+from frostfs_testlib.storage.dataclasses.object_size import ObjectSize
+from frostfs_testlib.storage.dataclasses.wallet import WalletInfo
+from frostfs_testlib.testing.cluster_test_base import ClusterTestBase
+from frostfs_testlib.testing.test_control import wait_for_success
+from frostfs_testlib.utils.file_utils import generate_file
+
+
+@pytest.mark.container
+class TestContainerMetrics(ClusterTestBase):
+    @wait_for_success(interval=10)
+    def check_sum_counter_metrics_in_nodes(
+        self, cluster_nodes: list[ClusterNode], cid: str, phy_exp: int, logic_exp: int, user_exp: int
+    ):
+        counter_phy = 0
+        counter_logic = 0
+        counter_user = 0
+        for cluster_node in cluster_nodes:
+            metric_result = cluster_node.metrics.storage.get_metric_container(f"container_objects_total", cid)
+            counter_phy += self.get_count_metric_type_from_stdout(metric_result.stdout, "phy")
+            counter_logic += self.get_count_metric_type_from_stdout(metric_result.stdout, "logic")
+            counter_user += self.get_count_metric_type_from_stdout(metric_result.stdout, "user")
+
+        assert counter_phy == phy_exp, f"Expected metric Phy={phy_exp}, Actual: {counter_phy} in nodes: {cluster_nodes}"
+        assert (
+            counter_logic == logic_exp
+        ), f"Expected metric logic={logic_exp}, Actual: {counter_logic} in nodes: {cluster_nodes}"
+        assert (
+            counter_user == user_exp
+        ), f"Expected metric User={user_exp}, Actual: {counter_user} in nodes: {cluster_nodes}"
+
+    @staticmethod
+    def get_count_metric_type_from_stdout(metric_result_stdout: str, metric_type: str):
+        result = re.findall(rf'type="{metric_type}"}}\s(\d+)', metric_result_stdout)
+        return sum(map(int, result))
+
+    @allure.title("Container metrics (obj_size={object_size})")
+    def test_container_metrics(
+        self, object_size: ObjectSize, max_object_size: int, default_wallet: WalletInfo, cluster: Cluster
+    ):
+        file_path = generate_file(object_size.value)
+        placement_policy = "REP 2 IN X CBF 2 SELECT 2 FROM * AS X"
+        copies = 2
+        object_chunks = 0
+        head_object = 1
+        link_object = 0
+        if object_size.value > max_object_size:
+            object_chunks = math.ceil(object_size.value / max_object_size)
+            link_object = 1
+
+        with reporter.step(f"Create container with policy {placement_policy}"):
+            cid = create_container(
+                default_wallet,
+                rule=placement_policy,
+                shell=self.shell,
+                endpoint=self.cluster.default_rpc_endpoint,
+            )
+
+        with reporter.step("Put object to random node"):
+            storage_object_id = put_object_to_random_node(
+                wallet=default_wallet,
+                path=file_path,
+                cid=cid,
+                shell=self.shell,
+                cluster=cluster,
+            )
+
+        with reporter.step("Check metric appears in node where the object is located"):
+            object_nodes = get_object_nodes(
+                cluster=cluster, cid=cid, oid=storage_object_id, alive_node=cluster.cluster_nodes[0]
+            )
+            count_metrics_exp = (object_chunks + head_object + link_object) * copies
+            self.check_sum_counter_metrics_in_nodes(
+                object_nodes, cid, phy_exp=count_metrics_exp, logic_exp=count_metrics_exp, user_exp=copies
+            )
+
+        with reporter.step("Delete file, wait until gc remove object"):
+            delete_object(default_wallet, cid, storage_object_id, self.shell, self.cluster.default_rpc_endpoint)
+            count_metrics_exp = len(object_nodes)
+            self.check_sum_counter_metrics_in_nodes(
+                object_nodes, cid, phy_exp=count_metrics_exp, logic_exp=count_metrics_exp, user_exp=0
+            )
+
+        with reporter.step("Check metrics(Phy, Logic, User) in each nodes"):
+            # Phy and Logic metrics are 4, because in rule 'CBF 2 SELECT 2 FROM', cbf2*sel2=4
+            self.check_sum_counter_metrics_in_nodes(cluster.cluster_nodes, cid, phy_exp=4, logic_exp=4, user_exp=0)
+
+        with reporter.step("Delete container"):
+            delete_container(default_wallet, cid, shell=self.shell, endpoint=self.cluster.default_rpc_endpoint)

pytest_tests/testsuites/services/s3_gate/test_s3_multipart.py

@@ -17,15 +17,23 @@ PART_SIZE = 5 * 1024 * 1024
 class TestS3GateMultipart(ClusterTestBase):
     NO_SUCH_UPLOAD = "The upload ID may be invalid, or the upload may have been aborted or completed."
 
-    @allure.title("Object Multipart API (s3_client={s3_client})")
-    @pytest.mark.parametrize("versioning_status", [VersioningStatus.ENABLED], indirect=True)
-    def test_s3_object_multipart(self, s3_client: S3ClientWrapper, bucket: str):
+    @allure.title("Object Multipart API (s3_client={s3_client}, bucket versioning = {versioning_status})")
+    @pytest.mark.parametrize("versioning_status", [VersioningStatus.ENABLED, VersioningStatus.UNDEFINED], indirect=True)
+    def test_s3_object_multipart(
+        self, s3_client: S3ClientWrapper, bucket: str, default_wallet: WalletInfo, versioning_status: str
+    ):
         parts_count = 5
         file_name_large = generate_file(PART_SIZE * parts_count)  # 5Mb - min part
         object_key = s3_helper.object_key_from_file_path(file_name_large)
         part_files = split_file(file_name_large, parts_count)
         parts = []
 
+        with reporter.step(f"Get related container_id for bucket"):
+            for cluster_node in self.cluster.cluster_nodes:
+                container_id = search_container_by_name(bucket, cluster_node)
+                if container_id:
+                    break
+
         with reporter.step("Upload first part"):
             upload_id = s3_client.create_multipart_upload(bucket, object_key)
             uploads = s3_client.list_multipart_uploads(bucket)
@@ -39,7 +47,11 @@ class TestS3GateMultipart(ClusterTestBase):
                 etag = s3_client.upload_part(bucket, object_key, upload_id, part_id, file_path)
                 parts.append((part_id, etag))
             got_parts = s3_client.list_parts(bucket, object_key, upload_id)
-            s3_client.complete_multipart_upload(bucket, object_key, upload_id, parts)
+            response = s3_client.complete_multipart_upload(bucket, object_key, upload_id, parts)
+
+            version_id = None
+            if versioning_status == VersioningStatus.ENABLED:
+                version_id = response["VersionId"]
             assert len(got_parts) == len(part_files), f"Expected {parts_count} parts, got\n{got_parts}"
 
         with reporter.step("Check upload list is empty"):
@@ -50,6 +62,21 @@ class TestS3GateMultipart(ClusterTestBase):
             got_object = s3_client.get_object(bucket, object_key)
             assert get_file_hash(got_object) == get_file_hash(file_name_large)
 
+        if version_id:
+            with reporter.step("Delete the object version"):
+                s3_client.delete_object(bucket, object_key, version_id)
+        else:
+            with reporter.step("Delete the object"):
+                s3_client.delete_object(bucket, object_key)
+
+        with reporter.step("List objects in the bucket, expect to be empty"):
+            objects_list = s3_client.list_objects(bucket)
+            assert not objects_list, f"Expected empty bucket, got {objects_list}"
+
+        with reporter.step("List objects in the container via rpc, expect to be empty"):
+            objects = list_objects(default_wallet, self.shell, container_id, self.cluster.default_rpc_endpoint)
+            assert len(objects) == 0, f"Expected no objects in container, got\n{objects}"
+
     @allure.title("Abort Multipart Upload (s3_client={s3_client})")
     @pytest.mark.parametrize("versioning_status", [VersioningStatus.ENABLED], indirect=True)
     def test_s3_abort_multipart(