[#293] Integrate allure-validator into pre-commit hook

Signed-off-by: Kirill Sosnovskikh <k.sosnovskikh@yadro.com>

.devenv.hosting.yaml

@@ -1,108 +0,0 @@
-hosts:
-- address: localhost
-  attributes:
-    sudo_shell: false
-  plugin_name: docker
-  healthcheck_plugin_name: basic
-  attributes:
-    skip_readiness_check: True
-    force_transactions: True
-  services:
-  - name: frostfs-storage_01
-    attributes:
-      container_name: s01
-      config_path: /etc/frostfs/storage/config.yml
-      wallet_path: ../frostfs-dev-env/services/storage/wallet01.json
-      local_wallet_config_path: ./TemporaryDir/empty-password.yml
-      local_wallet_path: ../frostfs-dev-env/services/storage/wallet01.json
-      wallet_password: ""
-      volume_name: storage_storage_s01
-      endpoint_data0: s01.frostfs.devenv:8080
-      control_endpoint: s01.frostfs.devenv:8081
-      un_locode: "RU MOW"
-  - name: frostfs-storage_02
-    attributes:
-      container_name: s02
-      config_path: /etc/frostfs/storage/config.yml
-      wallet_path: ../frostfs-dev-env/services/storage/wallet02.json
-      local_wallet_config_path: ./TemporaryDir/empty-password.yml
-      local_wallet_path: ../frostfs-dev-env/services/storage/wallet02.json
-      wallet_password: ""
-      volume_name: storage_storage_s02
-      endpoint_data0: s02.frostfs.devenv:8080
-      control_endpoint: s02.frostfs.devenv:8081
-      un_locode: "RU LED"
-  - name: frostfs-storage_03
-    attributes:
-      container_name: s03
-      config_path: /etc/frostfs/storage/config.yml
-      wallet_path: ../frostfs-dev-env/services/storage/wallet03.json
-      local_wallet_config_path: ./TemporaryDir/empty-password.yml
-      local_wallet_path: ../frostfs-dev-env/services/storage/wallet03.json
-      wallet_password: ""
-      volume_name: storage_storage_s03
-      endpoint_data0: s03.frostfs.devenv:8080
-      control_endpoint: s03.frostfs.devenv:8081
-      un_locode: "SE STO"
-  - name: frostfs-storage_04
-    attributes:
-      container_name: s04
-      config_path: /etc/frostfs/storage/config.yml
-      wallet_path: ../frostfs-dev-env/services/storage/wallet04.json
-      local_wallet_config_path: ./TemporaryDir/empty-password.yml
-      local_wallet_path: ../frostfs-dev-env/services/storage/wallet04.json
-      wallet_password: ""
-      volume_name: storage_storage_s04
-      endpoint_data0: s04.frostfs.devenv:8080
-      control_endpoint: s04.frostfs.devenv:8081
-      un_locode: "FI HEL"
-  - name: frostfs-s3_01
-    attributes:
-      container_name: s3_gate
-      config_path: ../frostfs-dev-env/services/s3_gate/.s3.env
-      wallet_path: ../frostfs-dev-env/services/s3_gate/wallet.json
-      local_wallet_config_path: ./TemporaryDir/password-s3.yml
-      local_wallet_path: ../frostfs-dev-env/services/s3_gate/wallet.json
-      wallet_password: "s3"
-      endpoint_data0: https://s3.frostfs.devenv:8080
-  - name: frostfs-http_01
-    attributes:
-      container_name: http_gate
-      config_path: ../frostfs-dev-env/services/http_gate/.http.env
-      wallet_path: ../frostfs-dev-env/services/http_gate/wallet.json
-      local_wallet_config_path: ./TemporaryDir/password-other.yml
-      local_wallet_path: ../frostfs-dev-env/services/http_gate/wallet.json
-      wallet_password: "one"
-      endpoint_data0: http://http.frostfs.devenv
-  - name: frostfs-ir_01
-    attributes:
-      container_name: ir01
-      config_path: ../frostfs-dev-env/services/ir/.ir.env
-      wallet_path: ../frostfs-dev-env/services/ir/az.json
-      local_wallet_config_path: ./TemporaryDir/password-other.yml
-      local_wallet_path: ../frostfs-dev-env/services/ir/az.json
-      wallet_password: "one"
-  - name: neo-go_01
-    attributes:
-      container_name: morph_chain
-      config_path: ../frostfs-dev-env/services/morph_chain/protocol.privnet.yml
-      wallet_path: ../frostfs-dev-env/services/morph_chain/node-wallet.json
-      local_wallet_config_path: ./TemporaryDir/password-other.yml
-      local_wallet_path: ../frostfs-dev-env/services/morph_chain/node-wallet.json
-      wallet_password: "one"
-      endpoint_internal0: http://morph-chain.frostfs.devenv:30333
-  - name: main-chain_01
-    attributes:
-      container_name: main_chain
-      config_path: ../frostfs-dev-env/services/chain/protocol.privnet.yml
-      wallet_path: ../frostfs-dev-env/services/chain/node-wallet.json
-      local_wallet_config_path: ./TemporaryDir/password-other.yml
-      local_wallet_path: ../frostfs-dev-env/services/chain/node-wallet.json
-      wallet_password: "one"
-      endpoint_internal0: http://main-chain.frostfs.devenv:30333
-  - name: coredns_01
-    attributes:
-        container_name: coredns
-  clis:
-  - name: frostfs-cli
-    exec_path: frostfs-cli

.pre-commit-config.yaml

@@ -9,6 +9,12 @@ repos:
     hooks:
       - id: isort
         name: isort (python)
+  - repo: https://git.frostfs.info/TrueCloudLab/allure-validator
+    rev:  1.0.1
+    hooks:
+      - id: allure-validator
+        args: ["pytest_tests/"]
+        pass_filenames: false
 
 ci:
   autofix_prs: false

pytest.ini

@@ -19,6 +19,7 @@ markers =
     grpc_api: standard gRPC API tests
     grpc_control: tests related to using frostfs-cli control commands
     grpc_object_lock: gRPC lock tests
+    grpc_without_user: gRPC without user tests
     http_gate: HTTP gate contract
     http_put: HTTP gate test cases with PUT call
     s3_gate: All S3 gate tests
@@ -67,3 +68,4 @@ markers =
     ec_replication: replication EC
     static_session_container: tests for a static session in a container
     shard: shard management tests
+    session_logs: check logs messages

pytest_tests/helpers/object_access.py

@@ -2,7 +2,7 @@ from typing import Optional
 
 from frostfs_testlib import reporter
 from frostfs_testlib.resources.cli import CLI_DEFAULT_TIMEOUT
-from frostfs_testlib.resources.error_patterns import OBJECT_ACCESS_DENIED
+from frostfs_testlib.resources.error_patterns import OBJECT_ACCESS_DENIED, OBJECT_NOT_FOUND
 from frostfs_testlib.shell import Shell
 from frostfs_testlib.steps.cli.object import (
     delete_object,
@@ -20,6 +20,10 @@ from frostfs_testlib.utils.file_utils import get_file_hash
 
 OPERATION_ERROR_TYPE = RuntimeError
 
+# TODO: Revert to just OBJECT_ACCESS_DENIED when the issue is fixed
+# https://git.frostfs.info/TrueCloudLab/frostfs-node/issues/1297
+OBJECT_NO_ACCESS = rf"(?:{OBJECT_NOT_FOUND}|{OBJECT_ACCESS_DENIED})"
+
 
 def can_get_object(
     wallet: WalletInfo,
@@ -43,9 +47,7 @@ def can_get_object(
                 cluster=cluster,
             )
         except OPERATION_ERROR_TYPE as err:
-            assert string_utils.is_str_match_pattern(
-                err, OBJECT_ACCESS_DENIED
-            ), f"Expected {err} to match {OBJECT_ACCESS_DENIED}"
+            assert string_utils.is_str_match_pattern(err, OBJECT_NO_ACCESS), f"Expected {err} to match {OBJECT_NO_ACCESS}"
             return False
         assert get_file_hash(file_name) == get_file_hash(got_file_path)
     return True
@@ -74,9 +76,7 @@ def can_put_object(
                 cluster=cluster,
             )
         except OPERATION_ERROR_TYPE as err:
-            assert string_utils.is_str_match_pattern(
-                err, OBJECT_ACCESS_DENIED
-            ), f"Expected {err} to match {OBJECT_ACCESS_DENIED}"
+            assert string_utils.is_str_match_pattern(err, OBJECT_ACCESS_DENIED), f"Expected {err} to match {OBJECT_ACCESS_DENIED}"
             return False
     return True
 
@@ -102,9 +102,7 @@ def can_delete_object(
                 endpoint=endpoint,
             )
         except OPERATION_ERROR_TYPE as err:
-            assert string_utils.is_str_match_pattern(
-                err, OBJECT_ACCESS_DENIED
-            ), f"Expected {err} to match {OBJECT_ACCESS_DENIED}"
+            assert string_utils.is_str_match_pattern(err, OBJECT_NO_ACCESS), f"Expected {err} to match {OBJECT_NO_ACCESS}"
             return False
     return True
 
@@ -132,9 +130,7 @@ def can_get_head_object(
                 timeout=timeout,
             )
         except OPERATION_ERROR_TYPE as err:
-            assert string_utils.is_str_match_pattern(
-                err, OBJECT_ACCESS_DENIED
-            ), f"Expected {err} to match {OBJECT_ACCESS_DENIED}"
+            assert string_utils.is_str_match_pattern(err, OBJECT_NO_ACCESS), f"Expected {err} to match {OBJECT_NO_ACCESS}"
             return False
     return True
 
@@ -163,9 +159,7 @@ def can_get_range_of_object(
                 timeout=timeout,
             )
         except OPERATION_ERROR_TYPE as err:
-            assert string_utils.is_str_match_pattern(
-                err, OBJECT_ACCESS_DENIED
-            ), f"Expected {err} to match {OBJECT_ACCESS_DENIED}"
+            assert string_utils.is_str_match_pattern(err, OBJECT_NO_ACCESS), f"Expected {err} to match {OBJECT_NO_ACCESS}"
             return False
     return True
 
@@ -194,9 +188,7 @@ def can_get_range_hash_of_object(
                 timeout=timeout,
             )
         except OPERATION_ERROR_TYPE as err:
-            assert string_utils.is_str_match_pattern(
-                err, OBJECT_ACCESS_DENIED
-            ), f"Expected {err} to match {OBJECT_ACCESS_DENIED}"
+            assert string_utils.is_str_match_pattern(err, OBJECT_NO_ACCESS), f"Expected {err} to match {OBJECT_NO_ACCESS}"
             return False
     return True
 
@@ -223,9 +215,7 @@ def can_search_object(
                 timeout=timeout,
             )
         except OPERATION_ERROR_TYPE as err:
-            assert string_utils.is_str_match_pattern(
-                err, OBJECT_ACCESS_DENIED
-            ), f"Expected {err} to match {OBJECT_ACCESS_DENIED}"
+            assert string_utils.is_str_match_pattern(err, OBJECT_NO_ACCESS), f"Expected {err} to match {OBJECT_NO_ACCESS}"
             return False
         if oid:
             return oid in oids

pytest_tests/resources/common.py

@@ -3,4 +3,3 @@ import os
 TEST_CYCLES_COUNT = int(os.getenv("TEST_CYCLES_COUNT", "1"))
 
 DEVENV_PATH = os.getenv("DEVENV_PATH", os.path.join("..", "frostfs-dev-env"))
-HOSTING_CONFIG_FILE = os.getenv("HOSTING_CONFIG_FILE", ".devenv.hosting.yaml")

pytest_tests/resources/files/policy.json

@@ -1,5 +1,6 @@
 {
     "rep-3": "REP 3",
     "rep-1": "REP 1",
-    "complex": "REP 1 IN X CBF 1 SELECT 1 FROM * AS X"
+    "complex": "REP 1 IN X CBF 1 SELECT 1 FROM * AS X",
+    "ec3.1": "EC 3.1 CBF 1 SELECT 4 FROM *"
 }

pytest_tests/testsuites/access/ape/test_ape_filters.py

@@ -21,8 +21,7 @@ from pytest_tests.helpers.container_access import (
     assert_full_access_to_container,
     assert_no_access_to_container,
 )
-
-OBJECT_NO_ACCESS = f"(?:{OBJECT_NOT_FOUND}|{OBJECT_ACCESS_DENIED})"
+from pytest_tests.helpers.object_access import OBJECT_NO_ACCESS
 
 
 @pytest.mark.ape
@@ -58,7 +57,7 @@ class TestApeFilters(ClusterTestBase):
         return cid, objects_with_header, objects_with_other_header, objects_without_header, file_path
 
     @pytest.fixture(scope="function")
-    def container_with_objects(self, default_wallet: WalletInfo, file_path: TestFile, frostfs_cli: FrostfsCli, cluster: Cluster):
+    def private_container(self, default_wallet: WalletInfo, frostfs_cli: FrostfsCli, cluster: Cluster):
         with reporter.step("Create private container"):
             cid = create_container(default_wallet, self.shell, self.cluster.default_rpc_endpoint, basic_acl="0")
 
@@ -77,9 +76,14 @@ class TestApeFilters(ClusterTestBase):
         with reporter.step("Wait for one block"):
             self.wait_for_blocks()
 
-        objects_with_header, objects_with_other_header, objects_without_header = self._fill_container(default_wallet, file_path, cid)
+        return cid
 
-        return cid, objects_with_header, objects_with_other_header, objects_without_header, file_path
+    @pytest.fixture(scope="function")
+    def container_with_objects(self, private_container: str, default_wallet: WalletInfo, file_path: TestFile):
+        objects_with_header, objects_with_other_header, objects_without_header = self._fill_container(
+            default_wallet, file_path, private_container
+        )
+        return private_container, objects_with_header, objects_with_other_header, objects_without_header, file_path
 
     @reporter.step("Add objects to container")
     def _fill_container(self, wallet: WalletInfo, test_file: TestFile, cid: str):
@@ -102,6 +106,7 @@ class TestApeFilters(ClusterTestBase):
     @pytest.mark.sanity
     @allure.title("Operations with request filter (match_type={match_type}, obj_size={object_size})")
     @pytest.mark.parametrize("match_type", [ape.MatchType.EQUAL, ape.MatchType.NOT_EQUAL])
+    @pytest.mark.skip("https://git.frostfs.info/TrueCloudLab/frostfs-node/issues/1243")
     def test_ape_filters_request(
         self,
         frostfs_cli: FrostfsCli,
@@ -120,7 +125,7 @@ class TestApeFilters(ClusterTestBase):
         endpoint = self.cluster.default_rpc_endpoint
 
         with reporter.step("Deny all operations for others via APE with request condition"):
-            request_condition = ape.Condition('"check_key"', '"check_value"', ape.ConditionType.REQUEST, match_type)
+            request_condition = ape.Condition('"frostfs:xheader/check_key"', '"check_value"', ape.ConditionType.REQUEST, match_type)
             role_condition = ape.Condition.by_role(ape.Role.OTHERS)
             deny_rule = ape.Rule(ape.Verb.DENY, ALL_OBJECT_OPERATIONS, [request_condition, role_condition])
 
@@ -157,6 +162,7 @@ class TestApeFilters(ClusterTestBase):
 
     @allure.title("Operations with deny user headers filter (match_type={match_type}, obj_size={object_size})")
     @pytest.mark.parametrize("match_type", [ape.MatchType.EQUAL, ape.MatchType.NOT_EQUAL])
+    @pytest.mark.skip("https://git.frostfs.info/TrueCloudLab/frostfs-node/issues/1300")
     def test_ape_deny_filters_object(
         self,
         frostfs_cli: FrostfsCli,
@@ -168,15 +174,15 @@ class TestApeFilters(ClusterTestBase):
         # TODO: Refactor this to be fixtures, not test logic
         (
             cid,
-            objects_with_header,
-            objects_with_other_header,
-            objs_without_header,
+            objects_with_attributes,
+            objects_with_other_attributes,
+            objs_without_attributes,
             file_path,
         ) = public_container_with_objects
         endpoint = self.cluster.default_rpc_endpoint
 
-        allow_objects = objects_with_other_header if match_type == ape.MatchType.EQUAL else objects_with_header
-        deny_objects = objects_with_header if match_type == ape.MatchType.EQUAL else objects_with_other_header
+        allow_objects = objects_with_other_attributes if match_type == ape.MatchType.EQUAL else objects_with_attributes
+        deny_objects = objects_with_attributes if match_type == ape.MatchType.EQUAL else objects_with_other_attributes
 
         # When there is no attribute on the object, it's the same as "", and "" is not equal to "<some_value>"
         # So it's the same as deny_objects
@@ -192,10 +198,23 @@ class TestApeFilters(ClusterTestBase):
                 ape.ObjectOperations.DELETE: False,  # Denied by restricted PUT
             },
         }
+        allowed_access = {
+            ape.MatchType.EQUAL: FULL_ACCESS,
+            ape.MatchType.NOT_EQUAL: {
+                ape.ObjectOperations.PUT: False,  # because currently we are put without attributes
+                ape.ObjectOperations.GET: True,
+                ape.ObjectOperations.HEAD: True,
+                ape.ObjectOperations.GET_RANGE: True,
+                ape.ObjectOperations.GET_RANGE_HASH: True,
+                ape.ObjectOperations.SEARCH: True,
+                ape.ObjectOperations.DELETE: False,  # Because delete needs to put a tombstone without attributes
+            },
+        }
         # End of refactor
 
         with reporter.step("Deny operations for others via APE with resource condition"):
             resource_condition = ape.Condition('"check_key"', '"check_value"', ape.ConditionType.RESOURCE, match_type)
+            not_a_tombstone_condition = ape.Condition.by_object_type("TOMBSTONE", ape.ConditionType.RESOURCE, ape.MatchType.NOT_EQUAL)
             role_condition = ape.Condition.by_role(ape.Role.OTHERS)
             deny_rule = ape.Rule(ape.Verb.DENY, self.RESOURCE_OPERATIONS, [resource_condition, role_condition])
 
@@ -222,7 +241,7 @@ class TestApeFilters(ClusterTestBase):
                     no_attributes_access[match_type],
                     other_wallet,
                     cid,
-                    objs_without_header.pop(),
+                    objs_without_attributes.pop(),
                     file_path,
                     self.shell,
                     self.cluster,
@@ -230,7 +249,9 @@ class TestApeFilters(ClusterTestBase):
                 )
 
             with reporter.step("Check others have full access to objects without deny attribute"):
-                assert_full_access_to_container(other_wallet, cid, allow_objects.pop(), file_path, self.shell, self.cluster, xhdr=xhdr)
+                assert_access_to_container(
+                    allowed_access[match_type], other_wallet, cid, allow_objects.pop(), file_path, self.shell, self.cluster, xhdr=xhdr
+                )
 
             with reporter.step("Check others have no access to objects with deny attribute"):
                 with pytest.raises(Exception, match=OBJECT_NO_ACCESS):
@@ -268,23 +289,25 @@ class TestApeFilters(ClusterTestBase):
         # TODO: Refactor this to be fixtures, not test logic!
         (
             cid,
-            objects_with_header,
-            objects_with_other_header,
-            objects_without_header,
+            objects_with_attributes,
+            objects_with_other_attributes,
+            objects_without_attributes,
             file_path,
         ) = container_with_objects
         endpoint = self.cluster.default_rpc_endpoint
 
         if match_type == ape.MatchType.EQUAL:
-            allow_objects = objects_with_header
-            deny_objects = objects_with_other_header
+            allow_objects = objects_with_attributes
+            deny_objects = objects_with_other_attributes
             allow_attribute = self.HEADER
             deny_attribute = self.OTHER_HEADER
+            no_attributes_match_context = pytest.raises(Exception, match=OBJECT_NO_ACCESS)
         else:
-            allow_objects = objects_with_other_header
-            deny_objects = objects_with_header
+            allow_objects = objects_with_other_attributes
+            deny_objects = objects_with_attributes
             allow_attribute = self.OTHER_HEADER
             deny_attribute = self.HEADER
+            no_attributes_match_context = expect_not_raises()
         # End of refactor block
 
         with reporter.step("Allow operations for others except few operations by resource condition via APE"):
@@ -297,15 +320,15 @@ class TestApeFilters(ClusterTestBase):
         with reporter.step("Wait for one block"):
             self.wait_for_blocks()
 
-        with reporter.step("Check others cannot get and put objects without attributes"):
-            oid = objects_without_header.pop()
-            with pytest.raises(Exception, match=OBJECT_ACCESS_DENIED):
+        with reporter.step("Check GET, PUT and HEAD operations with objects without attributes for OTHERS role"):
+            oid = objects_without_attributes.pop()
+            with no_attributes_match_context:
                 assert head_object(other_wallet, cid, oid, self.shell, endpoint)
 
-            with pytest.raises(Exception, match=OBJECT_ACCESS_DENIED):
+            with no_attributes_match_context:
                 assert get_object_from_random_node(other_wallet, cid, oid, self.shell, self.cluster)
 
-            with pytest.raises(Exception, match=OBJECT_ACCESS_DENIED):
+            with no_attributes_match_context:
                 assert put_object_to_random_node(other_wallet, file_path, cid, self.shell, self.cluster)
 
         with reporter.step("Create bearer token with everything allowed for others role"):
@@ -314,7 +337,7 @@ class TestApeFilters(ClusterTestBase):
             bearer = create_bearer_token(frostfs_cli, temp_directory, cid, rule, endpoint)
 
         with reporter.step("Check others can get and put objects without attributes and using bearer token"):
-            oid = objects_without_header[0]
+            oid = objects_without_attributes[0]
             with expect_not_raises():
                 head_object(other_wallet, cid, oid, self.shell, endpoint, bearer)
 
@@ -337,13 +360,13 @@ class TestApeFilters(ClusterTestBase):
 
         with reporter.step("Check others cannot get and put objects without attributes matching the filter"):
             oid = deny_objects[0]
-            with pytest.raises(Exception, match=OBJECT_ACCESS_DENIED):
+            with pytest.raises(Exception, match=OBJECT_NO_ACCESS):
                 head_object(other_wallet, cid, oid, self.shell, endpoint)
 
-            with pytest.raises(Exception, match=OBJECT_ACCESS_DENIED):
-                assert get_object_from_random_node(other_wallet, cid, oid, file_path, self.shell, self.cluster)
+            with pytest.raises(Exception, match=OBJECT_NO_ACCESS):
+                assert get_object_from_random_node(other_wallet, cid, oid, self.shell, self.cluster)
 
-            with pytest.raises(Exception, match=OBJECT_ACCESS_DENIED):
+            with pytest.raises(Exception, match=OBJECT_NO_ACCESS):
                 assert put_object_to_random_node(other_wallet, file_path, cid, self.shell, self.cluster, attributes=deny_attribute)
 
         with reporter.step("Check others can get and put objects without attributes matching the filter with bearer token"):
@@ -356,3 +379,57 @@ class TestApeFilters(ClusterTestBase):
 
             with expect_not_raises():
                 put_object_to_random_node(other_wallet, file_path, cid, self.shell, self.cluster, bearer, attributes=allow_attribute)
+
+    @allure.title("PUT and GET object using bearer with objectID in filter (obj_size={object_size}, match_type=NOT_EQUAL)")
+    def test_ape_filter_object_id_not_equals(
+        self,
+        frostfs_cli: FrostfsCli,
+        default_wallet: WalletInfo,
+        other_wallet: WalletInfo,
+        private_container: str,
+        temp_directory: str,
+        file_path: TestFile,
+    ):
+        with reporter.step("Put object to container"):
+            oid = put_object_to_random_node(default_wallet, file_path, private_container, self.shell, self.cluster)
+
+        with reporter.step("Create bearer token with objectID filter"):
+            role_condition = ape.Condition.by_role(ape.Role.OTHERS)
+            object_condition = ape.Condition.by_object_id(oid, ape.ConditionType.RESOURCE, ape.MatchType.NOT_EQUAL)
+            rule = ape.Rule(ape.Verb.ALLOW, ALL_OBJECT_OPERATIONS, [role_condition, object_condition])
+            bearer = create_bearer_token(frostfs_cli, temp_directory, private_container, rule, self.cluster.default_rpc_endpoint)
+
+        with reporter.step("Others should be able to put object using bearer token"):
+            with expect_not_raises():
+                put_object_to_random_node(other_wallet, file_path, private_container, self.shell, self.cluster, bearer)
+
+        with reporter.step("Others should not be able to get object matching the filter"):
+            with pytest.raises(Exception, match=OBJECT_NO_ACCESS):
+                get_object_from_random_node(other_wallet, private_container, oid, self.shell, self.cluster, bearer)
+
+    @allure.title("PUT and GET object using bearer with objectID in filter (obj_size={object_size}, match_type=EQUAL)")
+    def test_ape_filter_object_id_equals(
+        self,
+        frostfs_cli: FrostfsCli,
+        default_wallet: WalletInfo,
+        other_wallet: WalletInfo,
+        private_container: str,
+        temp_directory: str,
+        file_path: TestFile,
+    ):
+        with reporter.step("Put object to container"):
+            oid = put_object_to_random_node(default_wallet, file_path, private_container, self.shell, self.cluster)
+
+        with reporter.step("Create bearer token with objectID filter"):
+            role_condition = ape.Condition.by_role(ape.Role.OTHERS)
+            object_condition = ape.Condition.by_object_id(oid, ape.ConditionType.RESOURCE, ape.MatchType.EQUAL)
+            rule = ape.Rule(ape.Verb.ALLOW, ALL_OBJECT_OPERATIONS, [role_condition, object_condition])
+            bearer = create_bearer_token(frostfs_cli, temp_directory, private_container, rule, self.cluster.default_rpc_endpoint)
+
+        with reporter.step("Others should not be able to put object using bearer token"):
+            with pytest.raises(Exception, match=OBJECT_NO_ACCESS):
+                put_object_to_random_node(other_wallet, file_path, private_container, self.shell, self.cluster, bearer)
+
+        with reporter.step("Others should be able to get object matching the filter"):
+            with expect_not_raises():
+                get_object_from_random_node(other_wallet, private_container, oid, self.shell, self.cluster, bearer)

pytest_tests/testsuites/conftest.py

@@ -3,26 +3,23 @@ import os
 import random
 import shutil
 from datetime import datetime, timedelta, timezone
-from importlib.metadata import entry_points
 from typing import Optional
 
 import allure
 import pytest
-import yaml
 from dateutil import parser
 from frostfs_testlib import plugins, reporter
 from frostfs_testlib.cli import FrostfsCli
 from frostfs_testlib.credentials.interfaces import CredentialsProvider, User
 from frostfs_testlib.healthcheck.interfaces import Healthcheck
 from frostfs_testlib.hosting import Hosting
-from frostfs_testlib.reporter import AllureHandler, StepsLogger
+from frostfs_testlib.resources import optionals
 from frostfs_testlib.resources.common import ASSETS_DIR, COMPLEX_OBJECT_CHUNKS_COUNT, COMPLEX_OBJECT_TAIL_SIZE, SIMPLE_OBJECT_SIZE
 from frostfs_testlib.s3 import AwsCliClient, Boto3ClientWrapper, S3ClientWrapper, VersioningStatus
 from frostfs_testlib.shell import LocalShell, Shell
 from frostfs_testlib.steps.cli.container import DEFAULT_EC_PLACEMENT_RULE, DEFAULT_PLACEMENT_RULE, FROSTFS_CLI_EXEC
 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
 from frostfs_testlib.storage.cluster import Cluster, ClusterNode
 from frostfs_testlib.storage.controllers.cluster_state_controller import ClusterStateController
 from frostfs_testlib.storage.dataclasses.frostfs_services import StorageNode
@@ -31,11 +28,11 @@ from frostfs_testlib.storage.dataclasses.policy import PlacementPolicy
 from frostfs_testlib.storage.dataclasses.wallet import WalletInfo
 from frostfs_testlib.testing.cluster_test_base import ClusterTestBase
 from frostfs_testlib.testing.parallel import parallel
-from frostfs_testlib.testing.test_control import wait_for_success
+from frostfs_testlib.testing.test_control import run_optionally, wait_for_success
 from frostfs_testlib.utils import env_utils, string_utils, version_utils
 from frostfs_testlib.utils.file_utils import TestFile, generate_file
 
-from pytest_tests.resources.common import HOSTING_CONFIG_FILE, TEST_CYCLES_COUNT
+from pytest_tests.resources.common import TEST_CYCLES_COUNT
 
 logger = logging.getLogger("NeoLogger")
 
@@ -116,38 +113,11 @@ def pytest_generate_tests(metafunc: pytest.Metafunc):
     )
 
 
-@pytest.fixture(scope="session")
-def configure_testlib():
-    reporter.get_reporter().register_handler(AllureHandler())
-    reporter.get_reporter().register_handler(StepsLogger())
-
-    logging.getLogger("paramiko").setLevel(logging.INFO)
-
-    # Register Services for cluster
-    registry = get_service_registry()
-    services = entry_points(group="frostfs.testlib.services")
-    for svc in services:
-        registry.register_service(svc.name, svc.load())
-
-    yield
-
-
 @pytest.fixture(scope="session")
 def client_shell(configure_testlib) -> Shell:
     yield LocalShell()
 
 
-@pytest.fixture(scope="session")
-def hosting(configure_testlib) -> Hosting:
-    with open(HOSTING_CONFIG_FILE, "r") as file:
-        hosting_config = yaml.full_load(file)
-
-    hosting_instance = Hosting()
-    hosting_instance.configure(hosting_config)
-
-    yield hosting_instance
-
-
 @pytest.fixture(scope="session")
 def require_multiple_hosts(hosting: Hosting):
     """Designates tests that require environment with multiple hosts.
@@ -378,6 +348,7 @@ def two_buckets(buckets_pool: list[str], s3_client: S3ClientWrapper) -> list[str
 
 @allure.title("[Autouse/Session] Collect binary versions")
 @pytest.fixture(scope="session", autouse=True)
+@run_optionally(optionals.OPTIONAL_AUTOUSE_FIXTURES_ENABLED)
 def collect_binary_versions(hosting: Hosting, client_shell: Shell, request: pytest.FixtureRequest):
     environment_dir = request.config.getoption("--alluredir")
     if not environment_dir:
@@ -423,6 +394,7 @@ def session_start_time(configure_testlib):
 
 @allure.title("[Autouse/Session] After deploy healthcheck")
 @pytest.fixture(scope="session", autouse=True)
+@run_optionally(optionals.OPTIONAL_AUTOUSE_FIXTURES_ENABLED)
 def after_deploy_healthcheck(cluster: Cluster):
     with reporter.step("Wait for cluster readiness after deploy"):
         parallel(readiness_on_node, cluster.cluster_nodes)

pytest_tests/testsuites/container/test_container.py

@@ -19,12 +19,10 @@ from pytest_tests.helpers.utility import placement_policy_from_container
 @pytest.mark.container
 @pytest.mark.sanity
 class TestContainer(ClusterTestBase):
+    @allure.title("Create container (name={name})")
     @pytest.mark.parametrize("name", ["", "test-container"], ids=["No name", "Set particular name"])
     @pytest.mark.smoke
     def test_container_creation(self, default_wallet: WalletInfo, name: str):
-        scenario_title = "with name" if name else "without name"
-        allure.dynamic.title(f"Create container {scenario_title}")
-
         wallet = default_wallet
 
         placement_rule = "REP 2 IN X CBF 1 SELECT 2 FROM * AS X"
@@ -59,9 +57,7 @@ class TestContainer(ClusterTestBase):
         with reporter.step("Check container has correct information"):
             expected_policy = placement_rule.casefold()
             actual_policy = placement_policy_from_container(container_info)
-            assert (
-                actual_policy == expected_policy
-            ), f"Expected policy\n{expected_policy} but got policy\n{actual_policy}"
+            assert actual_policy == expected_policy, f"Expected policy\n{expected_policy} but got policy\n{actual_policy}"
 
             for info in info_to_check:
                 expected_info = info.casefold()
@@ -112,10 +108,6 @@ class TestContainer(ClusterTestBase):
 
             with reporter.step("Delete containers and check they were deleted"):
                 for cid in cids:
-                    delete_container(
-                        wallet, cid, shell=self.shell, endpoint=self.cluster.default_rpc_endpoint, await_mode=True
-                    )
-                    containers_list = list_containers(
-                        wallet, shell=self.shell, endpoint=self.cluster.default_rpc_endpoint
-                    )
+                    delete_container(wallet, cid, shell=self.shell, endpoint=self.cluster.default_rpc_endpoint, await_mode=True)
+                    containers_list = list_containers(wallet, shell=self.shell, endpoint=self.cluster.default_rpc_endpoint)
                     assert cid not in containers_list, "Container not deleted"

pytest_tests/testsuites/failovers/test_failover_server.py

@@ -1,5 +1,6 @@
 import itertools
 import logging
+import os
 import random
 
 import allure
@@ -15,7 +16,7 @@ from frostfs_testlib.storage.dataclasses.object_size import ObjectSize
 from frostfs_testlib.storage.dataclasses.storage_object_info import StorageObjectInfo
 from frostfs_testlib.storage.dataclasses.wallet import WalletInfo
 from frostfs_testlib.testing.cluster_test_base import ClusterTestBase
-from frostfs_testlib.testing.parallel import parallel
+from frostfs_testlib.testing.parallel import parallel, parallel_workers_limit
 from frostfs_testlib.testing.test_control import wait_for_success
 from frostfs_testlib.utils.file_utils import get_file_hash
 from pytest import FixtureRequest
@@ -55,8 +56,7 @@ class TestFailoverServer(ClusterTestBase):
         )
 
         containers = [
-            StorageContainer(StorageContainerInfo(result.result(), default_wallet), self.shell, self.cluster)
-            for result in results
+            StorageContainer(StorageContainerInfo(result.result(), default_wallet), self.shell, self.cluster) for result in results
         ]
 
         return containers
@@ -102,9 +102,7 @@ class TestFailoverServer(ClusterTestBase):
 
     @allure.title("[Test] Create objects and get nodes with object")
     @pytest.fixture()
-    def object_and_nodes(
-        self, simple_object_size: ObjectSize, container: StorageContainer
-    ) -> tuple[StorageObjectInfo, list[ClusterNode]]:
+    def object_and_nodes(self, simple_object_size: ObjectSize, container: StorageContainer) -> tuple[StorageObjectInfo, list[ClusterNode]]:
         object_info = container.generate_object(simple_object_size.value)
         object_nodes = get_object_nodes(self.cluster, object_info.cid, object_info.oid, self.cluster.cluster_nodes[0])
         return object_info, object_nodes
@@ -124,7 +122,9 @@ class TestFailoverServer(ClusterTestBase):
 
     @reporter.step("Verify objects")
     def verify_objects(self, nodes: list[StorageNode], storage_objects: list[StorageObjectInfo]) -> None:
-        parallel(self._verify_object, storage_objects * len(nodes), node=itertools.cycle(nodes))
+        workers_count = os.environ.get("PARALLEL_CUSTOM_LIMIT", 50)
+        with parallel_workers_limit(int(workers_count)):
+            parallel(self._verify_object, storage_objects * len(nodes), node=itertools.cycle(nodes))
 
     @allure.title("Full shutdown node")
     @pytest.mark.parametrize("containers, storage_objects", [(5, 10)], indirect=True)
@@ -200,9 +200,7 @@ class TestFailoverServer(ClusterTestBase):
         simple_file: str,
     ):
         object_info, object_nodes = object_and_nodes
-        endpoint_without_object = list(set(self.cluster.cluster_nodes) - set(object_nodes))[
-            0
-        ].storage_node.get_rpc_endpoint()
+        endpoint_without_object = list(set(self.cluster.cluster_nodes) - set(object_nodes))[0].storage_node.get_rpc_endpoint()
         endpoint_with_object = object_nodes[0].storage_node.get_rpc_endpoint()
 
         with reporter.step("Stop all nodes with object except first one"):

pytest_tests/testsuites/failovers/test_frostfs_failover_network.py

@@ -1,5 +1,4 @@
 import logging
-import os
 import random
 from time import sleep
 
@@ -9,13 +8,7 @@ from frostfs_testlib import reporter
 from frostfs_testlib.healthcheck.interfaces import Healthcheck
 from frostfs_testlib.resources.wellknown_acl import EACL_PUBLIC_READ_WRITE, PUBLIC_ACL
 from frostfs_testlib.steps.cli.container import create_container
-from frostfs_testlib.steps.cli.object import (
-    get_object,
-    get_object_nodes,
-    neo_go_query_height,
-    put_object,
-    put_object_to_random_node,
-)
+from frostfs_testlib.steps.cli.object import get_object, get_object_nodes, neo_go_query_height, put_object, put_object_to_random_node
 from frostfs_testlib.steps.storage_object import delete_objects
 from frostfs_testlib.storage.cluster import ClusterNode
 from frostfs_testlib.storage.controllers import ClusterStateController
@@ -32,7 +25,6 @@ STORAGE_NODE_COMMUNICATION_PORT = "8080"
 STORAGE_NODE_COMMUNICATION_PORT_TLS = "8082"
 PORTS_TO_BLOCK = [STORAGE_NODE_COMMUNICATION_PORT, STORAGE_NODE_COMMUNICATION_PORT_TLS]
 blocked_nodes: list[ClusterNode] = []
-file_wait_delete = []
 
 OBJECT_ATTRIBUTES = [
     None,
@@ -63,14 +55,6 @@ class TestFailoverNetwork(ClusterTestBase):
         yield
         cluster_state_controller.restore_interfaces()
 
-    @pytest.fixture()
-    @allure.title("Delete file after test")
-    def delete_file_after_test(self) -> None:
-        yield
-        for path in file_wait_delete:
-            os.remove(path)
-        file_wait_delete.clear()
-
     @pytest.fixture()
     def storage_objects(
         self,
@@ -113,9 +97,7 @@ class TestFailoverNetwork(ClusterTestBase):
 
             storage_objects.append(storage_object)
 
-        yield storage_objects
-
-        delete_objects(storage_objects, self.shell, self.cluster)
+        return storage_objects
 
     @allure.title("Block Storage node traffic")
     def test_block_storage_node_traffic(
@@ -174,9 +156,7 @@ class TestFailoverNetwork(ClusterTestBase):
                     assert node.storage_node not in new_nodes
 
                 with reporter.step("Check object data is not corrupted"):
-                    got_file_path = get_object(
-                        wallet, cid, oid, endpoint=new_nodes[0].get_rpc_endpoint(), shell=self.shell
-                    )
+                    got_file_path = get_object(wallet, cid, oid, endpoint=new_nodes[0].get_rpc_endpoint(), shell=self.shell)
                     assert get_file_hash(source_file_path) == get_file_hash(got_file_path)
 
         with reporter.step(f"Unblock incoming traffic"):
@@ -184,9 +164,7 @@ class TestFailoverNetwork(ClusterTestBase):
                 with reporter.step(f"Unblock at host {node}"):
                     cluster_state_controller.restore_traffic(node=node)
                     block_node = [
-                        cluster_node
-                        for cluster_node in self.cluster.cluster_nodes
-                        if cluster_node.storage_node == node.storage_node
+                        cluster_node for cluster_node in self.cluster.cluster_nodes if cluster_node.storage_node == node.storage_node
                     ]
                     blocked_nodes.remove(*block_node)
                     sleep(wakeup_node_timeout)
@@ -204,7 +182,6 @@ class TestFailoverNetwork(ClusterTestBase):
         cluster_state_controller: ClusterStateController,
         default_wallet: WalletInfo,
         restore_down_interfaces: None,
-        delete_file_after_test: None,
         storage_objects: list[StorageObjectInfo],
     ):
         storage_object = storage_objects[0]
@@ -231,7 +208,7 @@ class TestFailoverNetwork(ClusterTestBase):
             self.tick_epochs(1, alive_node=nodes_without_an_object[0].storage_node, wait_block=2)
 
         with reporter.step("Get object for target nodes to data interfaces, expect false"):
-            with pytest.raises(RuntimeError, match="return code: 1"):
+            with pytest.raises(RuntimeError, match="can't create API client: can't init SDK client: gRPC dial: context deadline exceeded"):
                 get_object(
                     wallet=default_wallet,
                     cid=storage_object.cid,
@@ -248,7 +225,6 @@ class TestFailoverNetwork(ClusterTestBase):
                 shell=self.shell,
                 endpoint=nodes_without_an_object[0].storage_node.get_rpc_endpoint(),
             )
-            file_wait_delete.append(input_file)
 
         with reporter.step("Restore interface and tick 1 epoch, wait 2 block"):
             cluster_state_controller.restore_interfaces()
@@ -261,7 +237,6 @@ class TestFailoverNetwork(ClusterTestBase):
         cluster_state_controller: ClusterStateController,
         default_wallet: WalletInfo,
         restore_down_interfaces: None,
-        delete_file_after_test: None,
         storage_objects: list[StorageObjectInfo],
         simple_object_size: ObjectSize,
     ):
@@ -289,7 +264,7 @@ class TestFailoverNetwork(ClusterTestBase):
             self.tick_epochs(1, alive_node=nodes_without_an_object[0].storage_node, wait_block=2)
 
         with reporter.step("Get object others node, expect false"):
-            with pytest.raises(RuntimeError, match="return code: 1"):
+            with pytest.raises(RuntimeError, match="rpc error"):
                 get_object(
                     wallet=default_wallet,
                     cid=storage_object.cid,
@@ -299,7 +274,7 @@ class TestFailoverNetwork(ClusterTestBase):
                 )
 
         with reporter.step("Put object, others node, expect false"):
-            with pytest.raises(RuntimeError, match="return code: 1"):
+            with pytest.raises(RuntimeError, match="rpc error"):
                 put_object(
                     wallet=default_wallet,
                     path=storage_object.file_path,
@@ -316,7 +291,6 @@ class TestFailoverNetwork(ClusterTestBase):
                 shell=self.shell,
                 endpoint=nodes_with_object[0].storage_node.get_rpc_endpoint(),
             )
-            file_wait_delete.append(input_file)
 
         with reporter.step(f"Put object nodes with object, expect true"):
             temp_file_path = generate_file(simple_object_size.value)
@@ -327,7 +301,7 @@ class TestFailoverNetwork(ClusterTestBase):
                 shell=self.shell,
                 endpoint=nodes_with_object[0].storage_node.get_rpc_endpoint(),
             )
-            file_wait_delete.append(temp_file_path)
+
         with reporter.step("Restore interface and tick 1 epoch, wait 2 block"):
             cluster_state_controller.restore_interfaces()
             self.tick_epochs(1, alive_node=nodes_without_an_object[0].storage_node, wait_block=2)
@@ -345,7 +319,6 @@ class TestFailoverNetwork(ClusterTestBase):
         cluster_state_controller: ClusterStateController,
         default_wallet: WalletInfo,
         simple_object_size: ObjectSize,
-        delete_file_after_test: None,
         restore_down_interfaces: None,
         block_interface: Interfaces,
         other_interface: Interfaces,
@@ -367,7 +340,6 @@ class TestFailoverNetwork(ClusterTestBase):
 
         with reporter.step("Put object"):
             file_path = generate_file(simple_object_size.value)
-            file_wait_delete.append(file_path)
 
             oid = put_object(
                 wallet=default_wallet,
@@ -385,7 +357,6 @@ class TestFailoverNetwork(ClusterTestBase):
                 shell=self.shell,
                 endpoint=f"{cluster_nodes[0].get_data_interface(other_interface.value)[0]}:8080",
             )
-            file_wait_delete.append(file_get_path)
 
         with reporter.step("Restore interfaces all nodes"):
             cluster_state_controller.restore_interfaces()
@@ -401,7 +372,6 @@ class TestFailoverNetwork(ClusterTestBase):
         cluster_state_controller: ClusterStateController,
         default_wallet: WalletInfo,
         simple_object_size: ObjectSize,
-        delete_file_after_test: None,
         restore_down_interfaces: None,
         interface: Interfaces,
     ):
@@ -430,7 +400,6 @@ class TestFailoverNetwork(ClusterTestBase):
 
         with reporter.step(f"Put object, after down {interface}"):
             file_path = generate_file(simple_object_size.value)
-            file_wait_delete.append(file_path)
 
             oid = put_object(
                 wallet=default_wallet,
@@ -448,7 +417,6 @@ class TestFailoverNetwork(ClusterTestBase):
                 shell=self.shell,
                 endpoint=self.cluster.default_rpc_endpoint,
             )
-            file_wait_delete.append(file_get_path)
 
         now_block = {}
 

pytest_tests/testsuites/metrics/test_container_metrics.py

@@ -1,11 +1,12 @@
 import math
+import time
 
 import allure
 import pytest
 from frostfs_testlib import reporter
-from frostfs_testlib.steps.cli.container import create_container
-from frostfs_testlib.steps.cli.object import delete_object, put_object_to_random_node
-from frostfs_testlib.steps.metrics import check_metrics_counter
+from frostfs_testlib.steps.cli.container import create_container, search_nodes_with_container
+from frostfs_testlib.steps.cli.object import delete_object, head_object, put_object_to_random_node
+from frostfs_testlib.steps.metrics import check_metrics_counter, get_metrics_value
 from frostfs_testlib.steps.storage_policy import get_nodes_with_object
 from frostfs_testlib.storage.cluster import Cluster
 from frostfs_testlib.storage.dataclasses.object_size import ObjectSize
@@ -16,23 +17,29 @@ from frostfs_testlib.utils.file_utils import generate_file
 
 @pytest.mark.container
 class TestContainerMetrics(ClusterTestBase):
-    @allure.title("Container metrics (obj_size={object_size})")
+    @allure.title("Container metrics (obj_size={object_size},policy={policy})")
+    @pytest.mark.parametrize("placement_policy, policy", [("REP 2 IN X CBF 2 SELECT 2 FROM * AS X", "REP"), ("EC 1.1 CBF 1", "EC")])
     def test_container_metrics(
-        self, object_size: ObjectSize, max_object_size: int, default_wallet: WalletInfo, cluster: Cluster
+        self,
+        object_size: ObjectSize,
+        max_object_size: int,
+        default_wallet: WalletInfo,
+        cluster: Cluster,
+        placement_policy: str,
+        policy: str,
     ):
         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
+        copies = 2 if policy == "REP" else 1
+        object_chunks = 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, self.shell, cluster.default_rpc_endpoint, placement_policy)
 
+        if object_size.value > max_object_size:
+            object_chunks = math.ceil(object_size.value / max_object_size)
+            link_object = len(search_nodes_with_container(default_wallet, cid, self.shell, cluster.default_rpc_endpoint, cluster))
+
         with reporter.step("Put object to random node"):
             oid = put_object_to_random_node(
                 wallet=default_wallet,
@@ -44,44 +51,72 @@ class TestContainerMetrics(ClusterTestBase):
 
         with reporter.step("Get object nodes"):
             object_storage_nodes = get_nodes_with_object(cid, oid, self.shell, cluster.storage_nodes)
-            object_nodes = [
-                cluster_node
-                for cluster_node in cluster.cluster_nodes
-                if cluster_node.storage_node in object_storage_nodes
-            ]
+            object_nodes = [cluster_node for cluster_node in cluster.cluster_nodes if cluster_node.storage_node in object_storage_nodes]
 
         with reporter.step("Check metric appears in node where the object is located"):
-            count_metrics = (object_chunks + head_object + link_object) * copies
-            check_metrics_counter(
-                object_nodes, counter_exp=count_metrics, command="container_objects_total", cid=cid, type="phy"
-            )
-            check_metrics_counter(
-                object_nodes, counter_exp=count_metrics, command="container_objects_total", cid=cid, type="logic"
-            )
-            check_metrics_counter(
-                object_nodes, counter_exp=copies, command="container_objects_total", cid=cid, type="user"
-            )
+            count_metrics = (object_chunks * copies) + link_object
+            if policy == "EC":
+                count_metrics = (object_chunks * 2) + link_object
+            check_metrics_counter(object_nodes, counter_exp=count_metrics, command="container_objects_total", cid=cid, type="phy")
+            check_metrics_counter(object_nodes, counter_exp=count_metrics, command="container_objects_total", cid=cid, type="logic")
+            check_metrics_counter(object_nodes, counter_exp=copies, command="container_objects_total", cid=cid, type="user")
 
         with reporter.step("Delete file, wait until gc remove object"):
             delete_object(default_wallet, cid, oid, self.shell, cluster.default_rpc_endpoint)
 
         with reporter.step(f"Check container metrics 'the counter should equal {len(object_nodes)}' in object nodes"):
-            check_metrics_counter(
-                object_nodes, counter_exp=len(object_nodes), command="container_objects_total", cid=cid, type="phy"
-            )
-            check_metrics_counter(
-                object_nodes, counter_exp=len(object_nodes), command="container_objects_total", cid=cid, type="logic"
-            )
+            check_metrics_counter(object_nodes, counter_exp=len(object_nodes), command="container_objects_total", cid=cid, type="phy")
+            check_metrics_counter(object_nodes, counter_exp=len(object_nodes), command="container_objects_total", cid=cid, type="logic")
             check_metrics_counter(object_nodes, counter_exp=0, command="container_objects_total", cid=cid, type="user")
 
         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
+            expect_metrics = 4 if policy == "REP" else 2
+            check_metrics_counter(cluster.cluster_nodes, counter_exp=expect_metrics, command="container_objects_total", cid=cid, type="phy")
             check_metrics_counter(
-                cluster.cluster_nodes, counter_exp=4, command="container_objects_total", cid=cid, type="phy"
+                cluster.cluster_nodes, counter_exp=expect_metrics, command="container_objects_total", cid=cid, type="logic"
             )
-            check_metrics_counter(
-                cluster.cluster_nodes, counter_exp=4, command="container_objects_total", cid=cid, type="logic"
+            check_metrics_counter(cluster.cluster_nodes, counter_exp=0, command="container_objects_total", cid=cid, type="user")
+
+    @allure.title("Container size metrics (obj_size={object_size},policy={policy})")
+    @pytest.mark.parametrize("placement_policy, policy", [("REP 2 IN X CBF 2 SELECT 2 FROM * AS X", "REP"), ("EC 1.1 CBF 1", "EC")])
+    def test_container_size_metrics(
+        self,
+        object_size: ObjectSize,
+        default_wallet: WalletInfo,
+        placement_policy: str,
+        policy: str,
+    ):
+        file_path = generate_file(object_size.value)
+
+        with reporter.step(f"Create container with policy {policy}"):
+            cid = create_container(default_wallet, self.shell, self.cluster.default_rpc_endpoint, placement_policy)
+
+        with reporter.step("Put object to random node"):
+            oid = put_object_to_random_node(
+                wallet=default_wallet,
+                path=file_path,
+                cid=cid,
+                shell=self.shell,
+                cluster=self.cluster,
             )
-            check_metrics_counter(
-                cluster.cluster_nodes, counter_exp=0, command="container_objects_total", cid=cid, type="user"
+
+        with reporter.step("Get object nodes"):
+            object_storage_nodes = get_nodes_with_object(cid, oid, self.shell, self.cluster.storage_nodes)
+            object_nodes = [
+                cluster_node for cluster_node in self.cluster.cluster_nodes if cluster_node.storage_node in object_storage_nodes
+            ]
+
+        with reporter.step("Check metric appears in all node where the object is located"):
+            act_metric = sum(
+                [get_metrics_value(node, command="frostfs_node_engine_container_size_bytes", cid=cid) for node in object_nodes]
             )
+            assert (act_metric // 2) == object_size.value
+
+        with reporter.step("Delete file, wait until gc remove object"):
+            id_tombstone = delete_object(default_wallet, cid, oid, self.shell, self.cluster.default_rpc_endpoint)
+            tombstone = head_object(default_wallet, cid, id_tombstone, self.shell, self.cluster.default_rpc_endpoint)
+
+        with reporter.step(f"Check container size metrics"):
+            act_metric = get_metrics_value(object_nodes[0], command="frostfs_node_engine_container_size_bytes", cid=cid)
+            assert act_metric == int(tombstone["header"]["payloadLength"])

pytest_tests/testsuites/metrics/test_garbage_collector_metrics.py

@@ -33,9 +33,7 @@ class TestGarbageCollectorMetrics(ClusterTestBase):
         return sum(map(int, result))
 
     @allure.title("Garbage collector expire_at object")
-    def test_garbage_collector_metrics_expire_at_object(
-        self, simple_object_size: ObjectSize, default_wallet: WalletInfo, cluster: Cluster
-    ):
+    def test_garbage_collector_metrics_expire_at_object(self, simple_object_size: ObjectSize, default_wallet: WalletInfo, cluster: Cluster):
         file_path = generate_file(simple_object_size.value)
         placement_policy = "REP 2 IN X CBF 2 SELECT 2 FROM * AS X"
         metrics_step = 1
@@ -43,9 +41,7 @@ class TestGarbageCollectorMetrics(ClusterTestBase):
         with reporter.step("Get current garbage collector metrics for each nodes"):
             metrics_counter = {}
             for node in cluster.cluster_nodes:
-                metrics_counter[node] = get_metrics_value(
-                    node, command="frostfs_node_garbage_collector_marked_for_removal_objects_total"
-                )
+                metrics_counter[node] = get_metrics_value(node, command="frostfs_node_garbage_collector_marked_for_removal_objects_total")
 
         with reporter.step(f"Create container with policy {placement_policy}"):
             cid = create_container(default_wallet, self.shell, cluster.default_rpc_endpoint, placement_policy)
@@ -63,18 +59,12 @@ class TestGarbageCollectorMetrics(ClusterTestBase):
 
         with reporter.step("Get object nodes"):
             object_storage_nodes = get_nodes_with_object(cid, oid, self.shell, cluster.storage_nodes)
-            object_nodes = [
-                cluster_node
-                for cluster_node in cluster.cluster_nodes
-                if cluster_node.storage_node in object_storage_nodes
-            ]
+            object_nodes = [cluster_node for cluster_node in cluster.cluster_nodes if cluster_node.storage_node in object_storage_nodes]
 
         with reporter.step("Tick Epoch"):
             self.tick_epochs(epochs_to_tick=2, wait_block=2)
 
-        with reporter.step(
-            f"Check garbage collector metrics 'the counter should increase by {metrics_step}' in object nodes"
-        ):
+        with reporter.step(f"Check garbage collector metrics 'the counter should increase by {metrics_step}' in object nodes"):
             for node in object_nodes:
                 metrics_counter[node] += metrics_step
 
@@ -86,30 +76,38 @@ class TestGarbageCollectorMetrics(ClusterTestBase):
                 )
 
     @allure.title("Garbage collector delete object")
-    def test_garbage_collector_metrics_deleted_objects(
-        self, simple_object_size: ObjectSize, default_wallet: WalletInfo, cluster: Cluster
-    ):
+    def test_garbage_collector_metrics_deleted_objects(self, simple_object_size: ObjectSize, default_wallet: WalletInfo, cluster: Cluster):
         file_path = generate_file(simple_object_size.value)
         placement_policy = "REP 2 IN X CBF 2 SELECT 2 FROM * AS X"
         metrics_step = 1
 
-        with reporter.step("Select random node"):
-            node = random.choice(cluster.cluster_nodes)
-
-        with reporter.step("Get current garbage collector metrics for selected node"):
-            metrics_counter = get_metrics_value(node, command="frostfs_node_garbage_collector_deleted_objects_total")
+        with reporter.step("Get current garbage collector metrics for each nodes"):
+            metrics_counter = {}
+            for node in cluster.cluster_nodes:
+                metrics_counter[node] = get_metrics_value(node, command="frostfs_node_garbage_collector_deleted_objects_total")
 
         with reporter.step(f"Create container with policy {placement_policy}"):
             cid = create_container(default_wallet, self.shell, node.storage_node.get_rpc_endpoint(), placement_policy)
 
-        with reporter.step("Put object to selected node"):
-            oid = put_object(default_wallet, file_path, cid, self.shell, node.storage_node.get_rpc_endpoint())
+        with reporter.step("Put object to random node"):
+            oid = put_object_to_random_node(
+                default_wallet,
+                file_path,
+                cid,
+                self.shell,
+                cluster,
+            )
+
+        with reporter.step("Get object nodes"):
+            object_storage_nodes = get_nodes_with_object(cid, oid, self.shell, cluster.storage_nodes)
+            object_nodes = [cluster_node for cluster_node in cluster.cluster_nodes if cluster_node.storage_node in object_storage_nodes]
 
         with reporter.step("Delete file, wait until gc remove object"):
             delete_object(default_wallet, cid, oid, self.shell, node.storage_node.get_rpc_endpoint())
 
         with reporter.step(f"Check garbage collector metrics 'the counter should increase by {metrics_step}'"):
-            metrics_counter += metrics_step
-            check_metrics_counter(
-                [node], counter_exp=metrics_counter, command="frostfs_node_garbage_collector_deleted_objects_total"
-            )
+            for node in object_nodes:
+                exp_metrics_counter = metrics_counter[node] + metrics_step
+                check_metrics_counter(
+                    [node], counter_exp=exp_metrics_counter, command="frostfs_node_garbage_collector_deleted_objects_total"
+                )

pytest_tests/testsuites/metrics/test_logs_metrics.py

@@ -16,37 +16,42 @@ from frostfs_testlib.testing.test_control import wait_for_success
 
 class TestLogsMetrics(ClusterTestBase):
     @pytest.fixture
+    def revert_all(self, cluster_state_controller: ClusterStateController):
+        yield
+        cluster_state_controller.manager(ConfigStateManager).revert_all()
+
     def restart_storage_service(self, cluster_state_controller: ClusterStateController) -> datetime:
         config_manager = cluster_state_controller.manager(ConfigStateManager)
         config_manager.csc.stop_services_of_type(StorageNode)
         restart_time = datetime.now(timezone.utc)
         config_manager.csc.start_services_of_type(StorageNode)
-        yield restart_time
-
-        cluster_state_controller.manager(ConfigStateManager).revert_all()
+        return restart_time
 
     @wait_for_success(interval=10)
     def check_metrics_in_node(self, cluster_node: ClusterNode, restart_time: datetime, log_priority: str = None, **metrics_greps):
-        counter_logs = self.get_count_logs_by_level(cluster_node, metrics_greps.get("level"), restart_time, log_priority)
+        current_time = datetime.now(timezone.utc)
         counter_metrics = get_metrics_value(cluster_node, **metrics_greps)
+        counter_logs = self.get_count_logs_by_level(cluster_node, metrics_greps.get("level"), restart_time, current_time, log_priority)
         assert counter_logs == counter_metrics, f"counter_logs: {counter_logs}, counter_metrics: {counter_metrics} in node: {cluster_node}"
 
     @staticmethod
-    def get_count_logs_by_level(cluster_node: ClusterNode, log_level: str, after_time: datetime, log_priority: str):
+    def get_count_logs_by_level(cluster_node: ClusterNode, log_level: str, after_time: datetime, until_time: datetime, log_priority: str):
         count_logs = 0
         try:
-            logs = cluster_node.host.get_filtered_logs(log_level, unit="frostfs-storage", since=after_time, priority=log_priority)
-            result = re.findall(rf"\s+{log_level}\s+", logs)
+            logs = cluster_node.host.get_filtered_logs(
+                log_level, unit="frostfs-storage", since=after_time, until=until_time, priority=log_priority
+            )
+            result = re.findall(rf"Z\s+{log_level}\s+", logs)
             count_logs += len(result)
         except RuntimeError as e:
             ...
         return count_logs
 
     @allure.title("Metrics for the log counter")
-    def test_log_counter_metrics(self, cluster: Cluster, restart_storage_service: datetime):
-        restart_time = restart_storage_service
+    def test_log_counter_metrics(self, cluster_state_controller: ClusterStateController, revert_all):
+        restart_time = self.restart_storage_service(cluster_state_controller)
         with reporter.step("Select random node"):
-            node = random.choice(cluster.cluster_nodes)
+            node = random.choice(self.cluster.cluster_nodes)
 
         with reporter.step(f"Check metrics count logs with level 'info'"):
             self.check_metrics_in_node(

pytest_tests/testsuites/object/test_object_without_user.py

@@ -0,0 +1,414 @@
+import logging
+import re
+
+import allure
+import pytest
+from frostfs_testlib import reporter
+from frostfs_testlib.cli import FrostfsCli
+from frostfs_testlib.resources.cli import CLI_DEFAULT_TIMEOUT, FROSTFS_CLI_EXEC
+from frostfs_testlib.resources.error_patterns import OBJECT_IS_LOCKED
+from frostfs_testlib.resources.wellknown_acl import PUBLIC_ACL_F
+from frostfs_testlib.shell import Shell
+from frostfs_testlib.steps.cli.container import create_container
+from frostfs_testlib.storage.dataclasses.wallet import WalletInfo
+from frostfs_testlib.testing.cluster_test_base import ClusterTestBase
+from frostfs_testlib.testing.test_control import expect_not_raises
+from frostfs_testlib.utils.file_utils import TestFile, get_file_hash
+
+logger = logging.getLogger("NeoLogger")
+
+
+@pytest.mark.grpc_without_user
+class TestObjectApiWithoutUser(ClusterTestBase):
+    def _parse_oid(self, stdout: str) -> str:
+        id_str = stdout.strip().split("\n")[-2]
+        oid = id_str.split(":")[1]
+        return oid.strip()
+
+    def _parse_tombstone_oid(self, stdout: str) -> str:
+        id_str = stdout.split("\n")[1]
+        tombstone = id_str.split(":")[1]
+        return tombstone.strip()
+
+    @pytest.fixture(scope="function")
+    def public_container(self, default_wallet: WalletInfo) -> str:
+        with reporter.step("Create public container"):
+            cid_public = create_container(
+                default_wallet,
+                self.shell,
+                self.cluster.default_rpc_endpoint,
+                basic_acl=PUBLIC_ACL_F,
+            )
+
+        return cid_public
+
+    @pytest.fixture(scope="class")
+    def frostfs_cli(self, client_shell: Shell) -> FrostfsCli:
+        return FrostfsCli(client_shell, FROSTFS_CLI_EXEC)
+
+    @allure.title("Get public container by native API with generate private key")
+    def test_get_container_with_generated_key(self, frostfs_cli: FrostfsCli, public_container: str):
+        """
+        Validate `container get` native API with flag `--generate-key`.
+        """
+
+        cid = public_container
+        rpc_endpoint = self.cluster.default_rpc_endpoint
+
+        with reporter.step("Get container with generate key"):
+            with expect_not_raises():
+                frostfs_cli.container.get(rpc_endpoint, cid, generate_key=True, timeout=CLI_DEFAULT_TIMEOUT)
+
+    @allure.title("Get list containers by native API with generate private key")
+    def test_list_containers_with_generated_key(self, frostfs_cli: FrostfsCli, default_wallet: WalletInfo, public_container: str):
+        """
+        Validate `container list` native API with flag `--generate-key`.
+        """
+
+        rpc_endpoint = self.cluster.default_rpc_endpoint
+        owner = default_wallet.get_address_from_json(0)
+
+        with reporter.step("List containers with generate key"):
+            with expect_not_raises():
+                result = frostfs_cli.container.list(rpc_endpoint, owner=owner, generate_key=True, timeout=CLI_DEFAULT_TIMEOUT)
+
+        with reporter.step("Expect container in received containers list"):
+            containers = result.stdout.split()
+            assert public_container in containers
+
+    @allure.title("Get list of public container objects by native API with generate private key")
+    def test_list_objects_with_generate_key(self, frostfs_cli: FrostfsCli, public_container: str):
+        """
+        Validate `container list_objects` native API with flag `--generate-key`.
+        """
+
+        cid = public_container
+        rpc_endpoint = self.cluster.default_rpc_endpoint
+
+        with reporter.step("List objects with generate key"):
+            with expect_not_raises():
+                result = frostfs_cli.container.list_objects(rpc_endpoint, cid, generate_key=True, timeout=CLI_DEFAULT_TIMEOUT)
+
+        with reporter.step("Expect empty objects list"):
+            objects = result.stdout.split()
+            assert len(objects) == 0, objects
+
+    @allure.title("Search public container nodes by native API with generate private key")
+    def test_search_nodes_with_generate_key(self, frostfs_cli: FrostfsCli, public_container: str):
+        """
+        Validate `container search_node` native API with flag `--generate-key`.
+        """
+
+        cid = public_container
+        rpc_endpoint = self.cluster.default_rpc_endpoint
+
+        with reporter.step("Search nodes with generate key"):
+            with expect_not_raises():
+                frostfs_cli.container.search_node(rpc_endpoint, cid, generate_key=True, timeout=CLI_DEFAULT_TIMEOUT)
+
+    @allure.title("Put object into public container by native API with generate private key (obj_size={object_size})")
+    def test_put_object_with_generate_key(self, frostfs_cli: FrostfsCli, public_container: str, file_path: TestFile):
+        """
+        Validate `object put` into container with public ACL and flag `--generate-key`.
+        """
+
+        cid = public_container
+        rpc_endpoint = self.cluster.default_rpc_endpoint
+
+        with reporter.step("Put object with generate key"):
+            with expect_not_raises():
+                result = frostfs_cli.object.put(
+                    rpc_endpoint,
+                    cid,
+                    file_path,
+                    generate_key=True,
+                    no_progress=True,
+                    timeout=CLI_DEFAULT_TIMEOUT,
+                )
+
+        oid = self._parse_oid(result.stdout)
+
+        with reporter.step("List objects with generate key"):
+            result = frostfs_cli.container.list_objects(rpc_endpoint, cid, generate_key=True, timeout=CLI_DEFAULT_TIMEOUT)
+
+        with reporter.step("Expect object in received objects list"):
+            objects = result.stdout.split()
+            assert oid in objects, objects
+
+    @allure.title("Get public container object by native API with generate private key (obj_size={object_size})")
+    def test_get_object_with_generate_key(self, frostfs_cli: FrostfsCli, public_container: str, file_path: TestFile):
+        """
+        Validate `object get` for container with public ACL and flag `--generate-key`.
+        """
+
+        cid = public_container
+        rpc_endpoint = self.cluster.default_rpc_endpoint
+        expected_hash = get_file_hash(file_path)
+
+        with reporter.step("Put object with generate key"):
+            result = frostfs_cli.object.put(
+                rpc_endpoint,
+                cid,
+                file_path,
+                generate_key=True,
+                no_progress=True,
+                timeout=CLI_DEFAULT_TIMEOUT,
+            )
+
+        oid = self._parse_oid(result.stdout)
+
+        with reporter.step("Get object with generate key"):
+            with expect_not_raises():
+                frostfs_cli.object.get(
+                    rpc_endpoint,
+                    cid,
+                    oid,
+                    file=file_path,
+                    generate_key=True,
+                    no_progress=True,
+                    timeout=CLI_DEFAULT_TIMEOUT,
+                )
+
+        downloaded_hash = get_file_hash(file_path)
+
+        with reporter.step("Validate downloaded file"):
+            assert expected_hash == downloaded_hash
+
+    @allure.title("Head public container object by native API with generate private key (obj_size={object_size})")
+    def test_head_object_with_generate_key(self, frostfs_cli: FrostfsCli, public_container: str, file_path: TestFile):
+        """
+        Validate `object head` for container with public ACL and flag `--generate-key`.
+        """
+
+        cid = public_container
+        rpc_endpoint = self.cluster.default_rpc_endpoint
+
+        with reporter.step("Put object with generate key"):
+            result = frostfs_cli.object.put(
+                rpc_endpoint,
+                cid,
+                file_path,
+                generate_key=True,
+                no_progress=True,
+                timeout=CLI_DEFAULT_TIMEOUT,
+            )
+
+        oid = self._parse_oid(result.stdout)
+
+        with reporter.step("Head object with generate key"):
+            with expect_not_raises():
+                frostfs_cli.object.head(rpc_endpoint, cid, oid, generate_key=True, timeout=CLI_DEFAULT_TIMEOUT)
+
+    @allure.title("Delete public container object by native API with generate private key (obj_size={object_size})")
+    def test_delete_object_with_generate_key(self, frostfs_cli: FrostfsCli, public_container: str, file_path: TestFile):
+        """
+        Validate `object delete` for container with public ACL and flag `--generate key`.
+        """
+
+        cid = public_container
+        rpc_endpoint = self.cluster.default_rpc_endpoint
+
+        with reporter.step("Put object with generate key"):
+            result = frostfs_cli.object.put(
+                rpc_endpoint,
+                cid,
+                file_path,
+                generate_key=True,
+                no_progress=True,
+                timeout=CLI_DEFAULT_TIMEOUT,
+            )
+
+        oid = self._parse_oid(result.stdout)
+
+        with reporter.step("Delete object with generate key"):
+            with expect_not_raises():
+                result = frostfs_cli.object.delete(rpc_endpoint, cid, oid, generate_key=True, timeout=CLI_DEFAULT_TIMEOUT)
+
+        oid = self._parse_tombstone_oid(result.stdout)
+
+        with reporter.step("Head object with generate key"):
+            result = frostfs_cli.object.head(
+                rpc_endpoint,
+                cid,
+                oid,
+                generate_key=True,
+                timeout=CLI_DEFAULT_TIMEOUT,
+            )
+
+        with reporter.step("Expect object type TOMBSTONE"):
+            object_type = re.search(r"(?<=type: )tombstone", result.stdout, re.IGNORECASE).group()
+            assert object_type == "TOMBSTONE", object_type
+
+    @allure.title("Lock public container object by native API with generate private key (obj_size={object_size})")
+    def test_lock_object_with_generate_key(self, frostfs_cli: FrostfsCli, public_container: str, file_path: TestFile):
+        """
+        Validate `object lock` for container with public ACL and flag `--generate-key`.
+        Attempt to delete the locked object.
+        """
+
+        cid = public_container
+        rpc_endpoint = self.cluster.default_rpc_endpoint
+
+        with reporter.step("Put object with generate key"):
+            result = frostfs_cli.object.put(
+                rpc_endpoint,
+                cid,
+                file_path,
+                generate_key=True,
+                no_progress=True,
+                timeout=CLI_DEFAULT_TIMEOUT,
+            )
+
+        oid = self._parse_oid(result.stdout)
+
+        with reporter.step("Lock object with generate key"):
+            with expect_not_raises():
+                frostfs_cli.object.lock(
+                    rpc_endpoint,
+                    cid,
+                    oid,
+                    generate_key=True,
+                    timeout=CLI_DEFAULT_TIMEOUT,
+                    lifetime=5,
+                )
+
+        with reporter.step("Delete locked object with generate key and expect error"):
+            with pytest.raises(Exception, match=OBJECT_IS_LOCKED):
+                frostfs_cli.object.delete(
+                    rpc_endpoint,
+                    cid,
+                    oid,
+                    generate_key=True,
+                    timeout=CLI_DEFAULT_TIMEOUT,
+                )
+
+    @allure.title("Search public container objects by native API with generate private key (obj_size={object_size})")
+    def test_search_object_with_generate_key(self, frostfs_cli: FrostfsCli, public_container: str, file_path: TestFile):
+        """
+        Validate `object search` for container with public ACL and flag `--generate-key`.
+        """
+
+        cid = public_container
+        rpc_endpoint = self.cluster.default_rpc_endpoint
+
+        with reporter.step("Put object with generate key"):
+            result = frostfs_cli.object.put(
+                rpc_endpoint,
+                cid,
+                file_path,
+                generate_key=True,
+                no_progress=True,
+                timeout=CLI_DEFAULT_TIMEOUT,
+            )
+
+        oid = self._parse_oid(result.stdout)
+
+        with reporter.step("Object search with generate key"):
+            with expect_not_raises():
+                result = frostfs_cli.object.search(rpc_endpoint, cid, generate_key=True, timeout=CLI_DEFAULT_TIMEOUT)
+
+        with reporter.step("Expect object in received objects list of container"):
+            object_ids = re.findall(r"(\w{43,44})", result.stdout)
+            assert oid in object_ids
+
+    @allure.title("Get range of public container object by native API with generate private key (obj_size={object_size})")
+    def test_range_with_generate_key(self, frostfs_cli: FrostfsCli, public_container: str, file_path: TestFile):
+        """
+        Validate `object range` for container with public ACL and `--generate-key`.
+        """
+
+        cid = public_container
+        rpc_endpoint = self.cluster.default_rpc_endpoint
+
+        with reporter.step("Put object with generate key"):
+            result = frostfs_cli.object.put(
+                rpc_endpoint,
+                cid,
+                file_path,
+                generate_key=True,
+                no_progress=True,
+                timeout=CLI_DEFAULT_TIMEOUT,
+            )
+
+        oid = self._parse_oid(result.stdout)
+
+        with reporter.step("Get range of object with generate key"):
+            with expect_not_raises():
+                frostfs_cli.object.range(
+                    rpc_endpoint,
+                    cid,
+                    oid,
+                    "0:10",
+                    file=file_path,
+                    generate_key=True,
+                    timeout=CLI_DEFAULT_TIMEOUT,
+                )
+
+    @allure.title("Get hash of public container object by native API with generate private key (obj_size={object_size})")
+    def test_hash_with_generate_key(self, frostfs_cli: FrostfsCli, public_container: str, file_path: TestFile):
+        """
+        Validate `object hash` for container with public ACL and `--generate-key`.
+        """
+
+        cid = public_container
+        rpc_endpoint = self.cluster.default_rpc_endpoint
+
+        with reporter.step("Put object with generate key"):
+            result = frostfs_cli.object.put(
+                rpc_endpoint,
+                cid,
+                file_path,
+                generate_key=True,
+                no_progress=True,
+                timeout=CLI_DEFAULT_TIMEOUT,
+            )
+
+        oid = self._parse_oid(result.stdout)
+
+        with reporter.step("Get range hash of object with generate key"):
+            with expect_not_raises():
+                frostfs_cli.object.hash(
+                    rpc_endpoint,
+                    cid,
+                    oid,
+                    range="0:10",
+                    generate_key=True,
+                    timeout=CLI_DEFAULT_TIMEOUT,
+                )
+
+    @allure.title("Get public container object nodes by native API with generate private key (obj_size={object_size})")
+    def test_nodes_with_generate_key(self, frostfs_cli: FrostfsCli, public_container: str, file_path: TestFile):
+        """
+        Validate `object nodes` for container with public ACL and `--generate-key`.
+        """
+
+        cid = public_container
+        rpc_endpoint = self.cluster.default_rpc_endpoint
+
+        with reporter.step("Put object with generate key"):
+            result = frostfs_cli.object.put(
+                rpc_endpoint,
+                cid,
+                file_path,
+                no_progress=True,
+                generate_key=True,
+                timeout=CLI_DEFAULT_TIMEOUT,
+            )
+
+        oid = self._parse_oid(result.stdout)
+
+        with reporter.step("Configure frostfs-cli for alive remote node"):
+            alive_node = self.cluster.cluster_nodes[0]
+            node_shell = alive_node.host.get_shell()
+            rpc_endpoint = alive_node.storage_node.get_rpc_endpoint()
+            node_frostfs_cli = FrostfsCli(node_shell, FROSTFS_CLI_EXEC)
+
+        with reporter.step("Get object nodes with generate key"):
+            with expect_not_raises():
+                node_frostfs_cli.object.nodes(
+                    rpc_endpoint,
+                    cid,
+                    oid=oid,
+                    generate_key=True,
+                    timeout=CLI_DEFAULT_TIMEOUT,
+                )

pytest_tests/testsuites/replication/test_ec_replication.py

@@ -4,24 +4,25 @@ from dataclasses import dataclass
 import allure
 import pytest
 import yaml
-from frostfs_testlib import reporter
+from frostfs_testlib import plugins, reporter
 from frostfs_testlib.cli import FrostfsAdm, FrostfsCli
 from frostfs_testlib.cli.netmap_parser import NetmapParser
 from frostfs_testlib.credentials.interfaces import User
-from frostfs_testlib.resources.cli import FROSTFS_ADM_CONFIG_PATH, FROSTFS_ADM_EXEC, FROSTFS_CLI_EXEC
-from frostfs_testlib.shell import Shell
+from frostfs_testlib.resources.cli import CLI_DEFAULT_TIMEOUT, FROSTFS_ADM_CONFIG_PATH, FROSTFS_ADM_EXEC, FROSTFS_CLI_EXEC
+from frostfs_testlib.resources.common import COMPLEX_OBJECT_CHUNKS_COUNT, COMPLEX_OBJECT_TAIL_SIZE, HOSTING_CONFIG_FILE
+from frostfs_testlib.s3 import AwsCliClient, S3ClientWrapper
+from frostfs_testlib.s3.interfaces import BucketContainerResolver, VersioningStatus
 from frostfs_testlib.steps.cli.object import get_object, put_object
 from frostfs_testlib.storage.cluster import Cluster, ClusterNode, StorageNode
-from frostfs_testlib.storage.controllers import ClusterStateController
+from frostfs_testlib.storage.controllers import ClusterStateController, ShardsWatcher
 from frostfs_testlib.storage.controllers.state_managers.config_state_manager import ConfigStateManager
 from frostfs_testlib.storage.dataclasses.object_size import ObjectSize
 from frostfs_testlib.storage.dataclasses.storage_object_info import NodeNetmapInfo
 from frostfs_testlib.testing.cluster_test_base import ClusterTestBase
+from frostfs_testlib.testing.test_control import wait_for_success
 from frostfs_testlib.utils.cli_utils import parse_netmap_output
 from frostfs_testlib.utils.file_utils import generate_file, get_file_hash
 
-from pytest_tests.resources.common import HOSTING_CONFIG_FILE
-
 
 def pytest_generate_tests(metafunc: pytest.Metafunc) -> None:
     if "ec_policy" not in metafunc.fixturenames:
@@ -33,8 +34,8 @@ def pytest_generate_tests(metafunc: pytest.Metafunc) -> None:
     node_count = len(hosting_config["hosts"])
 
     ec_map = {
-        4: ["EC 1.1", "EC 2.1", "EC 3.1"],
-        8: ["EC 5.3", "EC 3.2", "EC 7.1", "EC 4.4"],
+        4: ["EC 1.1", "EC 2.1", "EC 3.1", "EC 2.2"],
+        8: ["EC 5.3", "EC 3.2", "EC 7.1", "EC 4.4", "EC 3.1"],
         16: ["EC 12.4", "EC 8.4", "EC 5.3", "EC 4.4"],
         100: ["EC 12.4", "EC 8.4", "EC 5.3", "EC 4.4"],
     }
@@ -55,10 +56,12 @@ class Chunk:
         return self.object_id
 
 
-@allure.title("Initialized local FrostfsCli")
+@allure.title("Init bucket container resolver")
 @pytest.fixture()
-def frostfs_local_cli(client_shell: Shell, default_user: User) -> FrostfsCli:
-    return FrostfsCli(client_shell, frostfs_cli_exec_path=FROSTFS_CLI_EXEC, config_file=default_user.wallet.config_path)
+def bucket_container_resolver(node_under_test: ClusterNode) -> BucketContainerResolver:
+    resolver_cls = plugins.load_plugin("frostfs.testlib.bucket_cid_resolver", node_under_test.host.config.product)
+    resolver: BucketContainerResolver = resolver_cls()
+    return resolver
 
 
 @allure.title("Initialized remote FrostfsAdm")
@@ -72,6 +75,40 @@ def frostfs_remote_adm(cluster: Cluster) -> FrostfsAdm:
 @pytest.mark.replication
 @pytest.mark.ec_replication
 class TestECReplication(ClusterTestBase):
+    @pytest.fixture()
+    def rep_count(self, object_size: ObjectSize) -> int:
+        rep_count = 3
+        if object_size.name == "complex":
+            rep_count *= int(COMPLEX_OBJECT_CHUNKS_COUNT) + 1 if COMPLEX_OBJECT_TAIL_SIZE else int(COMPLEX_OBJECT_CHUNKS_COUNT)
+        return rep_count
+
+    @wait_for_success(120, 5)
+    def wait_for_nodes_appears_in_map(self, frostfs_cli: FrostfsCli, alive_node: ClusterNode, desired_nodes_count: int) -> bool:
+        self.tick_epoch(alive_node, 2)
+        netmap = parse_netmap_output(
+            frostfs_cli.netmap.snapshot(alive_node.storage_node.get_rpc_endpoint(), timeout=CLI_DEFAULT_TIMEOUT).stdout
+        )
+        assert len(netmap) == desired_nodes_count
+
+    @wait_for_success(120, 5)
+    def wait_replication(self, total_chunks: int, local_cli: FrostfsCli, cid: str, oid: str, success: bool = True) -> None:
+        if not success:
+            assert not self.check_replication(total_chunks, local_cli, cid, oid)
+        else:
+            assert self.check_replication(total_chunks, local_cli, cid, oid)
+
+    @allure.title("Search shard")
+    def get_shard_chunk(self, node: ClusterNode, chunk: Chunk) -> str:
+        oid_path = f"{chunk.object_id[0]}/{chunk.object_id[1]}/{chunk.object_id[2]}/{chunk.object_id[3]}"
+        node_shell = node.storage_node.host.get_shell()
+        shards_watcher = ShardsWatcher(node)
+
+        with reporter.step("Search object file"):
+            for shard_id, shard_info in shards_watcher.shards_snapshots[-1].items():
+                check_dir = node_shell.exec(f" [ -d {shard_info['blobstor'][1]['path']}/{oid_path} ] && echo 1 || echo 0").stdout
+                if "1" in check_dir.strip():
+                    return shard_id
+
     @allure.title("Restore chunk maximum params in network params ")
     @pytest.fixture
     def restore_network_config(self, frostfs_remote_adm: FrostfsAdm) -> None:
@@ -82,7 +119,10 @@ class TestECReplication(ClusterTestBase):
     def get_object_nodes(self, cli: FrostfsCli, cid: str, oid: str, endpoint: str = None) -> dict:
         if not endpoint:
             endpoint = self.cluster.default_rpc_endpoint
-        return json.loads(cli.object.nodes(endpoint, cid, oid=oid, json=True).stdout)
+        object_nodes = json.loads(cli.object.nodes(endpoint, cid, oid=oid, json=True, timeout=CLI_DEFAULT_TIMEOUT).stdout)
+        if object_nodes.get("errors"):
+            raise object_nodes["errors"]
+        return object_nodes
 
     @reporter.step("Get all chunks object ")
     def get_all_chunks_object(self, cli: FrostfsCli, cid: str, oid: str, endpoint: str = None) -> list[Chunk]:
@@ -103,7 +143,7 @@ class TestECReplication(ClusterTestBase):
     def search_node_not_chunks(self, chunks: list[Chunk], local_cli: FrostfsCli, endpoint: str = None) -> list[ClusterNode]:
         if not endpoint:
             self.cluster.default_rpc_endpoint
-        netmap = parse_netmap_output(local_cli.netmap.snapshot(endpoint).stdout)
+        netmap = parse_netmap_output(local_cli.netmap.snapshot(endpoint, timeout=CLI_DEFAULT_TIMEOUT).stdout)
         chunks_node_key = []
         for chunk in chunks:
             chunks_node_key.extend(chunk.confirmed_nodes)
@@ -119,11 +159,16 @@ class TestECReplication(ClusterTestBase):
 
     @reporter.step("Create container, policy={policy}")
     def create_container(self, user_cli: FrostfsCli, endpoint: str, policy: str) -> str:
-        return user_cli.container.create(endpoint, policy=policy, await_mode=True).stdout.split(" ")[1].strip().split("\n")[0]
+        return (
+            user_cli.container.create(endpoint, policy=policy, await_mode=True, timeout=CLI_DEFAULT_TIMEOUT)
+            .stdout.split(" ")[1]
+            .strip()
+            .split("\n")[0]
+        )
 
     @reporter.step("Search node chunk {chunk}")
     def get_chunk_node(self, frostfs_cli: FrostfsCli, chunk: Chunk) -> tuple[ClusterNode, NodeNetmapInfo]:
-        netmap = parse_netmap_output(frostfs_cli.netmap.snapshot(self.cluster.default_rpc_endpoint).stdout)
+        netmap = parse_netmap_output(frostfs_cli.netmap.snapshot(self.cluster.default_rpc_endpoint, timeout=CLI_DEFAULT_TIMEOUT).stdout)
         for node_info in netmap:
             if node_info.node_id in chunk.confirmed_nodes:
                 for cluster_node in self.cluster.cluster_nodes:
@@ -132,7 +177,9 @@ class TestECReplication(ClusterTestBase):
 
     @reporter.step("Check replication chunks={total_chunks} chunks ")
     def check_replication(self, total_chunks: int, local_cli: FrostfsCli, cid: str, oid: str) -> bool:
-        object_nodes_info = local_cli.object.nodes(self.cluster.default_rpc_endpoint, cid, oid=oid, json=True).stdout
+        object_nodes_info = local_cli.object.nodes(
+            self.cluster.default_rpc_endpoint, cid, oid=oid, json=True, timeout=CLI_DEFAULT_TIMEOUT
+        ).stdout
         object_nodes_info = json.loads(object_nodes_info)
         return len(object_nodes_info["data_objects"]) == total_chunks
 
@@ -151,49 +198,48 @@ class TestECReplication(ClusterTestBase):
             cluster_state_controller.start_stopped_hosts()
             cluster_state_controller.manager(ConfigStateManager).revert_all()
 
-    @allure.title("Create container with EC policy (size={object_size.value})")
+    @allure.title("Create container with EC policy (size={object_size})")
     def test_create_container_with_ec_policy(
         self,
         default_user: User,
-        frostfs_local_cli: FrostfsCli,
+        frostfs_cli: FrostfsCli,
         object_size: ObjectSize,
+        rep_count: int,
     ) -> None:
         test_file = generate_file(object_size.value)
-        rep_count = 3
-        if object_size.name == "complex":
-            rep_count *= 4
+
         with reporter.step("Create container."):
-            cid = self.create_container(frostfs_local_cli, self.cluster.default_rpc_endpoint, "EC 2.1")
+            cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 2.1")
 
         with reporter.step("Put object in container."):
             oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
 
         with reporter.step("Check replication chunks."):
-            assert self.check_replication(rep_count, frostfs_local_cli, cid, oid)
+            assert self.check_replication(rep_count, frostfs_cli, cid, oid)
 
     @allure.title("Lose node with chunk data")
     @pytest.mark.failover
     def test_lose_node_with_data_chunk(
         self,
-        frostfs_local_cli: FrostfsCli,
+        frostfs_cli: FrostfsCli,
         default_user: User,
         simple_object_size: ObjectSize,
         cluster_state_controller: ClusterStateController,
         disable_policer: None,
     ) -> None:
         with reporter.step("Create container."):
-            cid = self.create_container(frostfs_local_cli, self.cluster.default_rpc_endpoint, "EC 3.1")
+            cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 3.1")
 
         with reporter.step("Put object in container."):
             test_file = generate_file(simple_object_size.value)
             oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
 
         with reporter.step("Check chunk replication on 4 nodes."):
-            assert self.check_replication(4, frostfs_local_cli, cid, oid)
+            assert self.check_replication(4, frostfs_cli, cid, oid)
 
         with reporter.step("Search node data chunk"):
-            chunk = self.get_data_chunk_object(frostfs_local_cli, cid, oid)
-            chunk_node = self.get_chunk_node(frostfs_local_cli, chunk)[0]
+            chunk = self.get_data_chunk_object(frostfs_cli, cid, oid)
+            chunk_node = self.get_chunk_node(frostfs_cli, chunk)[0]
 
         with reporter.step("Stop node with data chunk."):
             cluster_state_controller.stop_node_host(chunk_node, "hard")
@@ -204,31 +250,31 @@ class TestECReplication(ClusterTestBase):
 
         with reporter.step("Start stopped node, and check replication chunks."):
             cluster_state_controller.start_node_host(chunk_node)
-            assert self.check_replication(4, frostfs_local_cli, cid, oid)
+            assert self.check_replication(4, frostfs_cli, cid, oid)
 
     @allure.title("Lose node with chunk parity")
     @pytest.mark.failover
     def test_lose_node_with_parity_chunk(
         self,
-        frostfs_local_cli: FrostfsCli,
+        frostfs_cli: FrostfsCli,
         default_user: User,
         simple_object_size: ObjectSize,
         cluster_state_controller: ClusterStateController,
         disable_policer: None,
     ) -> None:
         with reporter.step("Create container."):
-            cid = self.create_container(frostfs_local_cli, self.cluster.default_rpc_endpoint, "EC 3.1")
+            cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 3.1")
 
         with reporter.step("Put object in container."):
             test_file = generate_file(simple_object_size.value)
             oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
 
         with reporter.step("Check chunk replication on 4 nodes."):
-            assert self.check_replication(4, frostfs_local_cli, cid, oid)
+            assert self.check_replication(4, frostfs_cli, cid, oid)
 
         with reporter.step("Search node with parity chunk"):
-            chunk = self.get_parity_chunk_object(frostfs_local_cli, cid, oid)
-            chunk_node = self.get_chunk_node(frostfs_local_cli, chunk)[0]
+            chunk = self.get_parity_chunk_object(frostfs_cli, cid, oid)
+            chunk_node = self.get_chunk_node(frostfs_cli, chunk)[0]
 
         with reporter.step("Stop node parity chunk."):
             cluster_state_controller.stop_node_host(chunk_node, "hard")
@@ -239,33 +285,33 @@ class TestECReplication(ClusterTestBase):
 
         with reporter.step("Start stoped node, and check replication chunks."):
             cluster_state_controller.start_node_host(chunk_node)
-            assert self.check_replication(4, frostfs_local_cli, cid, oid)
+            assert self.check_replication(4, frostfs_cli, cid, oid)
 
     @allure.title("Lose nodes with chunk data and parity")
     @pytest.mark.failover
     def test_lose_nodes_data_chunk_and_parity(
         self,
-        frostfs_local_cli: FrostfsCli,
+        frostfs_cli: FrostfsCli,
         default_user: User,
         simple_object_size: ObjectSize,
         cluster_state_controller: ClusterStateController,
         disable_policer: None,
     ) -> None:
         with reporter.step("Create container."):
-            cid = self.create_container(frostfs_local_cli, self.cluster.default_rpc_endpoint, "EC 3.1")
+            cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 3.1")
 
         with reporter.step("Put object in container."):
             test_file = generate_file(simple_object_size.value)
             oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
 
         with reporter.step("Check count chunks, expect 4."):
-            assert self.check_replication(4, frostfs_local_cli, cid, oid)
+            assert self.check_replication(4, frostfs_cli, cid, oid)
 
         with reporter.step("Search node data chunk and node parity chunk"):
-            data_chunk = self.get_data_chunk_object(frostfs_local_cli, cid, oid)
-            node_data_chunk = self.get_chunk_node(frostfs_local_cli, data_chunk)[0]
-            parity_chunk = self.get_parity_chunk_object(frostfs_local_cli, cid, oid)
-            node_parity_chunk = self.get_chunk_node(frostfs_local_cli, parity_chunk)[0]
+            data_chunk = self.get_data_chunk_object(frostfs_cli, cid, oid)
+            node_data_chunk = self.get_chunk_node(frostfs_cli, data_chunk)[0]
+            parity_chunk = self.get_parity_chunk_object(frostfs_cli, cid, oid)
+            node_parity_chunk = self.get_chunk_node(frostfs_cli, parity_chunk)[0]
 
         with reporter.step("Stop node with data chunk."):
             cluster_state_controller.stop_node_host(node_data_chunk, "hard")
@@ -276,7 +322,7 @@ class TestECReplication(ClusterTestBase):
 
         with reporter.step("Start stopped host and check chunks."):
             cluster_state_controller.start_node_host(node_data_chunk)
-            assert self.check_replication(4, frostfs_local_cli, cid, oid)
+            assert self.check_replication(4, frostfs_cli, cid, oid)
 
         with reporter.step("Stop node with parity chunk and one all node."):
             cluster_state_controller.stop_node_host(node_data_chunk, "hard")
@@ -288,68 +334,73 @@ class TestECReplication(ClusterTestBase):
 
         with reporter.step("Start stopped nodes and check replication chunk."):
             cluster_state_controller.start_stopped_hosts()
-            assert self.check_replication(4, frostfs_local_cli, cid, oid)
+            assert self.check_replication(4, frostfs_cli, cid, oid)
 
     @allure.title("Policer work with chunk")
     @pytest.mark.failover
     def test_work_policer_with_nodes(
         self,
         simple_object_size: ObjectSize,
-        frostfs_local_cli: FrostfsCli,
+        frostfs_cli: FrostfsCli,
         default_user: User,
         cluster_state_controller: ClusterStateController,
     ) -> None:
         with reporter.step("Create container."):
-            cid = self.create_container(frostfs_local_cli, self.cluster.default_rpc_endpoint, "EC 2.1")
+            cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 2.1")
 
         with reporter.step("Put object on container."):
             test_file = generate_file(simple_object_size.value)
             oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
 
         with reporter.step("Check count chunks nodes on 3."):
-            assert self.check_replication(3, frostfs_local_cli, cid, oid)
+            assert self.check_replication(3, frostfs_cli, cid, oid)
 
         with reporter.step("Stop node with chunk."):
-            data_chunk = self.get_data_chunk_object(frostfs_local_cli, cid, oid)
-            first_all_chunks = self.get_all_chunks_object(frostfs_local_cli, cid, oid)
-            node_data_chunk = self.get_chunk_node(frostfs_local_cli, data_chunk)[0]
+            data_chunk = self.get_data_chunk_object(frostfs_cli, cid, oid)
+            first_all_chunks = self.get_all_chunks_object(frostfs_cli, cid, oid)
+            node_data_chunk = self.get_chunk_node(frostfs_cli, data_chunk)[0]
             cluster_state_controller.stop_node_host(node_data_chunk, "hard")
 
-        with reporter.step("Check replication chunk with different node."):
-            alive_endpoint = list(set(self.cluster.cluster_nodes) - {node_data_chunk})[0].storage_node.get_rpc_endpoint()
-            node = self.search_node_not_chunks(first_all_chunks, frostfs_local_cli, endpoint=alive_endpoint)[0]
-            second_all_chunks = self.get_all_chunks_object(frostfs_local_cli, cid, oid, node.storage_node.get_rpc_endpoint())
+        with reporter.step("Tick epoch and wait update network map."):
+            alive_node = list(set(self.cluster.cluster_nodes) - {node_data_chunk})[0]
+            self.wait_for_nodes_appears_in_map(frostfs_cli, alive_node, 3)
+
+        with reporter.step("Wait replication chunk with different node."):
+            node = self.search_node_not_chunks(first_all_chunks, frostfs_cli, endpoint=alive_node.storage_node.get_rpc_endpoint())[0]
+            self.wait_replication(3, frostfs_cli, cid, oid)
+
+        with reporter.step("Get new chunks"):
+            second_all_chunks = self.get_all_chunks_object(frostfs_cli, cid, oid, node.storage_node.get_rpc_endpoint())
 
         with reporter.step("Check that oid no change."):
-            oid_chunk_check = [chunk for chunk in second_all_chunks if data_chunk.object_id == chunk.object_id]
-            assert len(oid_chunk_check) > 0
+            assert [chunk for chunk in second_all_chunks if data_chunk.object_id == chunk.object_id]
 
         with reporter.step("Start stopped host, and check delete 4 chunk."):
             cluster_state_controller.start_node_host(node_data_chunk)
-            all_chunks_after_start_node = self.get_all_chunks_object(frostfs_local_cli, cid, oid)
+            all_chunks_after_start_node = self.get_all_chunks_object(frostfs_cli, cid, oid)
             assert len(all_chunks_after_start_node) == 3
 
-    @allure.title("EC X.Y combinations (nodes={node_count},policy={ec_policy},size={object_size.name})")
+    @allure.title("EC X.Y combinations (nodes={node_count},policy={ec_policy},size={object_size})")
     def test_create_container_with_difference_count_nodes(
         self,
         node_count: int,
         ec_policy: str,
         object_size: ObjectSize,
         default_user: User,
-        frostfs_local_cli: FrostfsCli,
+        frostfs_cli: FrostfsCli,
     ) -> None:
         with reporter.step("Create container."):
             expected_chunks = int(ec_policy.split(" ")[1].split(".")[0]) + int(ec_policy.split(" ")[1].split(".")[1])
             if "complex" in object_size.name:
                 expected_chunks *= 4
-            cid = self.create_container(frostfs_local_cli, self.cluster.default_rpc_endpoint, ec_policy)
+            cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, ec_policy)
 
         with reporter.step("Put object in container."):
             test_file = generate_file(object_size.value)
             oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
 
         with reporter.step("Check count object chunks."):
-            chunks = self.get_all_chunks_object(frostfs_local_cli, cid, oid, self.cluster.default_rpc_endpoint)
+            chunks = self.get_all_chunks_object(frostfs_cli, cid, oid, self.cluster.default_rpc_endpoint)
             assert len(chunks) == expected_chunks
 
         with reporter.step("get object and check hash."):
@@ -359,154 +410,299 @@ class TestECReplication(ClusterTestBase):
     @allure.title("Request PUT with copies_number flag")
     def test_put_object_with_copies_number(
         self,
-        frostfs_local_cli: FrostfsCli,
+        frostfs_cli: FrostfsCli,
         default_user: User,
         simple_object_size: ObjectSize,
     ) -> None:
         with reporter.step("Create container."):
-            cid = self.create_container(frostfs_local_cli, self.cluster.default_rpc_endpoint, "EC 2.1")
+            cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 2.1")
 
         with reporter.step("Put object in container with copies number = 1"):
             test_file = generate_file(simple_object_size.value)
             oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint, copies_number=1)
 
         with reporter.step("Check that count chunks > 1."):
-            chunks = self.get_all_chunks_object(frostfs_local_cli, cid, oid, self.cluster.default_rpc_endpoint)
+            chunks = self.get_all_chunks_object(frostfs_cli, cid, oid, self.cluster.default_rpc_endpoint)
             assert len(chunks) > 1
 
     @allure.title("Request PUT and 1 node off")
     @pytest.mark.failover
     def test_put_object_with_off_cnr_node(
         self,
-        frostfs_local_cli: FrostfsCli,
+        frostfs_cli: FrostfsCli,
         cluster_state_controller: ClusterStateController,
         default_user: User,
         simple_object_size: ObjectSize,
     ) -> None:
         with reporter.step("Create container."):
-            cid = self.create_container(frostfs_local_cli, self.cluster.default_rpc_endpoint, "EC 3.1")
+            cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 3.1")
 
         with reporter.step("Stop one node in container nodes"):
             cluster_state_controller.stop_node_host(self.cluster.cluster_nodes[1], "hard")
 
-        with reporter.step("Put object in container, expect error."):
+        with reporter.step("Put object in container, expect success for EC container."):
             test_file = generate_file(simple_object_size.value)
-            with pytest.raises(RuntimeError, match="put single object on client"):
-                put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
+            put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
 
-    @allure.title("Request DELETE (size={object_size.name})")
+    @allure.title("Request PUT (size={object_size})")
+    def test_put_object_with_ec_cnr(
+        self,
+        frostfs_cli: FrostfsCli,
+        default_user: User,
+        object_size: ObjectSize,
+    ) -> None:
+        with reporter.step("Create container."):
+            cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 2.1")
+
+        with reporter.step("Put object in container with --prepare-locally."):
+            test_file = generate_file(object_size.value)
+            oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
+
+        with reporter.step("Get chunks object."):
+            chunks = self.get_all_chunks_object(frostfs_cli, cid, oid, self.cluster.default_rpc_endpoint)
+
+        with reporter.step("Check header chunks object"):
+            for chunk in chunks:
+                chunk_head = frostfs_cli.object.head(self.cluster.default_rpc_endpoint, cid, chunk.object_id, raw=True).stdout
+                assert "EC header:" in chunk_head
+
+    @allure.title("Request PUT with copies number")
+    def test_put_object_with_copies_number(
+        self,
+        frostfs_cli: FrostfsCli,
+        default_user: User,
+        simple_object_size: ObjectSize,
+    ) -> None:
+        with reporter.step("Create container."):
+            cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 2.1")
+
+        with reporter.step("Put object in container with --copies-number=1."):
+            test_file = generate_file(simple_object_size.value)
+            oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint, copies_number=1)
+
+        with reporter.step("Check len chunks object."):
+            chunks = self.get_all_chunks_object(frostfs_cli, cid, oid, self.cluster.default_rpc_endpoint)
+            assert len(chunks) > 1
+
+    @allure.title("Request GET (size={object_size})")
+    def test_get_object_in_ec_cnr(
+        self,
+        default_user: User,
+        frostfs_cli: FrostfsCli,
+        object_size: ObjectSize,
+    ) -> None:
+        with reporter.step("Create container."):
+            cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 2.1 CBF 1")
+
+        with reporter.step("Put object in container"):
+            test_file = generate_file(object_size.value)
+            hash_origin_file = get_file_hash(test_file)
+            oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
+
+        with reporter.step("Get id all chunks."):
+            chunks = self.get_all_chunks_object(frostfs_cli, cid, oid, self.cluster.default_rpc_endpoint)
+
+        with reporter.step("Search chunk node and not chunks node."):
+            chunk_node = self.get_chunk_node(frostfs_cli, chunks[0])
+            not_chunk_node = self.search_node_not_chunks(chunks, frostfs_cli, self.cluster.default_rpc_endpoint)
+
+        with reporter.step("GET request with chunk node, expect success"):
+            file_one = get_object(default_user.wallet, cid, oid, self.shell, chunk_node[0].storage_node.get_rpc_endpoint())
+            hash_file_one = get_file_hash(file_one)
+            assert hash_file_one == hash_origin_file
+
+        with reporter.step("Get request with not chunk node"):
+            file_two = get_object(default_user.wallet, cid, oid, self.shell, not_chunk_node[0].storage_node.get_rpc_endpoint())
+            hash_file_two = get_file_hash(file_two)
+            assert hash_file_two == hash_file_one == hash_origin_file
+
+    @allure.title("Request SEARCH with flags 'root' (size={object_size})")
+    def test_search_object_in_ec_cnr_root_flags(
+        self,
+        default_user: User,
+        frostfs_cli: FrostfsCli,
+        object_size: ObjectSize,
+    ) -> None:
+        with reporter.step("Create container."):
+            cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 2.1")
+
+        with reporter.step("Put object in container"):
+            test_file = generate_file(object_size.value)
+            oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
+
+        with reporter.step("Search operation with --root flags"):
+            search_output = frostfs_cli.object.search(
+                self.cluster.default_rpc_endpoint, cid, root=True, timeout=CLI_DEFAULT_TIMEOUT
+            ).stdout.split("\n")[1:]
+            assert search_output[0] == oid
+
+    @allure.title("Request SEARCH check valid chunk id (size={object_size})")
+    def test_search_object_in_ec_cnr_chunk_id(
+        self,
+        default_user: User,
+        frostfs_cli: FrostfsCli,
+        object_size: ObjectSize,
+    ) -> None:
+        with reporter.step("Create container."):
+            cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 2.1")
+
+        with reporter.step("Put object in container"):
+            test_file = generate_file(object_size.value)
+            oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
+
+        with reporter.step("Search operation object"):
+            search_output = frostfs_cli.object.search(self.cluster.default_rpc_endpoint, cid, timeout=CLI_DEFAULT_TIMEOUT).stdout
+            chunks = self.get_all_chunks_object(frostfs_cli, cid, oid, self.cluster.default_rpc_endpoint)
+            for chunk in chunks:
+                assert chunk.object_id in search_output
+
+    @allure.title("Request SEARCH check no chunk index info (size={object_size})")
+    def test_search_object_in_ec_cnr(
+        self,
+        default_user: User,
+        frostfs_cli: FrostfsCli,
+        object_size: ObjectSize,
+    ) -> None:
+        with reporter.step("Create container."):
+            cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 2.1")
+
+        with reporter.step("Put object in container"):
+            test_file = generate_file(object_size.value)
+            oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
+
+        with reporter.step("Search operation all chunk"):
+            chunks = self.get_all_chunks_object(frostfs_cli, cid, oid, self.cluster.default_rpc_endpoint)
+            for chunk in chunks:
+                chunk_search = frostfs_cli.object.search(
+                    self.cluster.default_rpc_endpoint, cid, oid=chunk.object_id, timeout=CLI_DEFAULT_TIMEOUT
+                ).stdout
+                assert "index" not in chunk_search
+
+    @allure.title("Request DELETE (size={object_size})")
     @pytest.mark.failover
     def test_delete_object_in_ec_cnr(
         self,
         default_user: User,
-        frostfs_local_cli: FrostfsCli,
+        frostfs_cli: FrostfsCli,
         object_size: ObjectSize,
         cluster_state_controller: ClusterStateController,
     ) -> None:
         with reporter.step("Create container."):
-            cid = self.create_container(frostfs_local_cli, self.cluster.default_rpc_endpoint, "EC 2.1")
+            cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 2.1")
 
         with reporter.step("Put object in container."):
             test_file = generate_file(object_size.value)
             oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
 
         with reporter.step("Check object chunks nodes."):
-            chunks_object = self.get_all_chunks_object(frostfs_local_cli, cid, oid, self.cluster.default_rpc_endpoint)
+            chunks_object = self.get_all_chunks_object(frostfs_cli, cid, oid, self.cluster.default_rpc_endpoint)
             replication_count = 3 if object_size.name == "simple" else 3 * 4
             assert len(chunks_object) == replication_count
 
         with reporter.step("Delete object"):
-            frostfs_local_cli.object.delete(self.cluster.default_rpc_endpoint, cid, oid)
+            frostfs_cli.object.delete(self.cluster.default_rpc_endpoint, cid, oid, timeout=CLI_DEFAULT_TIMEOUT)
 
         with reporter.step("Check that delete all chunks."):
             for chunk in chunks_object:
                 with pytest.raises(RuntimeError, match="object already removed"):
-                    frostfs_local_cli.object.head(self.cluster.default_rpc_endpoint, cid, chunk.object_id)
+                    frostfs_cli.object.head(self.cluster.default_rpc_endpoint, cid, chunk.object_id, timeout=CLI_DEFAULT_TIMEOUT)
 
         with reporter.step("Put second object."):
             oid_second = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
 
         with reporter.step("Check second object chunks nodes."):
-            chunks_second_object = self.get_all_chunks_object(frostfs_local_cli, cid, oid_second, self.cluster.default_rpc_endpoint)
+            chunks_second_object = self.get_all_chunks_object(frostfs_cli, cid, oid_second, self.cluster.default_rpc_endpoint)
             assert len(chunks_second_object) == replication_count
 
         with reporter.step("Stop nodes with chunk."):
-            chunk_node = self.get_chunk_node(frostfs_local_cli, chunks_second_object[0])
+            chunk_node = self.get_chunk_node(frostfs_cli, chunks_second_object[0])
             cluster_state_controller.stop_node_host(chunk_node[0], "hard")
 
         with reporter.step("Delete second object"):
-            frostfs_local_cli.object.delete(self.cluster.default_rpc_endpoint, cid, oid_second)
+            cluster_nodes = list(set(self.cluster.cluster_nodes) - {chunk_node[0]})
+            frostfs_cli.object.delete(cluster_nodes[0].storage_node.get_rpc_endpoint(), cid, oid_second, timeout=CLI_DEFAULT_TIMEOUT)
 
         with reporter.step("Check that delete all chunk second object."):
             for chunk in chunks_second_object:
                 with pytest.raises(RuntimeError, match="object already removed"):
-                    frostfs_local_cli.object.head(self.cluster.default_rpc_endpoint, cid, chunk.object_id)
+                    frostfs_cli.object.head(self.cluster.default_rpc_endpoint, cid, chunk.object_id, timeout=CLI_DEFAULT_TIMEOUT)
 
-    @allure.title("Request LOCK (size={object_size.name})")
+    @allure.title("Request LOCK (size={object_size})")
     @pytest.mark.failover
     def test_lock_object_in_ec_cnr(
         self,
-        frostfs_local_cli: FrostfsCli,
+        frostfs_cli: FrostfsCli,
         object_size: ObjectSize,
         default_user: User,
         cluster_state_controller: ClusterStateController,
     ) -> None:
         with reporter.step("Create container."):
-            cid = self.create_container(frostfs_local_cli, self.cluster.default_rpc_endpoint, "EC 2.1")
+            cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 2.1")
 
         with reporter.step("Put object in container."):
             test_file = generate_file(object_size.value)
             oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
 
         with reporter.step("Check object chunks nodes."):
-            chunks_object = self.get_all_chunks_object(frostfs_local_cli, cid, oid, self.cluster.default_rpc_endpoint)
+            chunks_object = self.get_all_chunks_object(frostfs_cli, cid, oid, self.cluster.default_rpc_endpoint)
             replication_count = 3 if object_size.name == "simple" else 3 * 4
             assert len(chunks_object) == replication_count
 
         with reporter.step("Put LOCK in object."):
-            epoch = frostfs_local_cli.netmap.epoch(self.cluster.default_rpc_endpoint).stdout.strip()
-            frostfs_local_cli.object.lock(self.cluster.default_rpc_endpoint, cid, oid, expire_at=int(epoch) + 5).stdout
+            epoch = frostfs_cli.netmap.epoch(self.cluster.default_rpc_endpoint, timeout=CLI_DEFAULT_TIMEOUT).stdout.strip()
+            frostfs_cli.object.lock(
+                self.cluster.default_rpc_endpoint, cid, oid, timeout=CLI_DEFAULT_TIMEOUT, expire_at=(int(epoch) + 5)
+            ).stdout
 
-        with reporter.step("Check LOCK in object"):
-            chunks = frostfs_local_cli.object.head(self.cluster.default_rpc_endpoint, cid, oid, raw=True).stdout.strip().split(" ")
-            oids_chunks = [chunk.strip() for chunk in chunks if len(chunk) > 35]
-            for chunk_id in oids_chunks:
-                with pytest.raises(RuntimeError, match="could not delete objects"):
-                    frostfs_local_cli.object.delete(self.cluster.default_rpc_endpoint, cid, chunk_id)
+        with reporter.step("Check don`t delete chunk"):
+            for chunk in chunks_object:
+                with pytest.raises(RuntimeError, match="Lock EC chunk failed"):
+                    frostfs_cli.object.delete(self.cluster.default_rpc_endpoint, cid, chunk.object_id, timeout=CLI_DEFAULT_TIMEOUT)
+
+        with reporter.step("Check enable LOCK object"):
+            with pytest.raises(RuntimeError, match="object is locked"):
+                frostfs_cli.object.delete(self.cluster.default_rpc_endpoint, cid, oid, timeout=CLI_DEFAULT_TIMEOUT)
 
         with reporter.step("Stop chunk node."):
-            chunk_node = self.get_chunk_node(frostfs_local_cli, chunks_object[0])
+            chunk_node = self.get_chunk_node(frostfs_cli, chunks_object[0])
             cluster_state_controller.stop_node_host(chunk_node[0], "hard")
             cluster_state_controller.start_node_host(chunk_node[0])
 
-        with reporter.step("Check LOCK in object."):
-            chunks = self.get_all_chunks_object(frostfs_local_cli, cid, oid, self.cluster.default_rpc_endpoint)
-            for chunk_id in oids_chunks:
-                with pytest.raises(RuntimeError, match="could not delete objects"):
-                    frostfs_local_cli.object.delete(self.cluster.default_rpc_endpoint, cid, chunk_id)
+        with reporter.step("Check don`t delete chunk."):
+            for chunk in chunks_object:
+                with pytest.raises(RuntimeError, match="Lock EC chunk failed"):
+                    frostfs_cli.object.delete(self.cluster.default_rpc_endpoint, cid, chunk.object_id, timeout=CLI_DEFAULT_TIMEOUT)
 
-    @allure.title("Output MaxEC* params in frostfscli (type={type_shards})")
+        with reporter.step("Check enable LOCK object"):
+            with pytest.raises(RuntimeError, match="object is locked"):
+                frostfs_cli.object.delete(self.cluster.default_rpc_endpoint, cid, oid, timeout=CLI_DEFAULT_TIMEOUT)
+
+    @allure.title("Output MaxEC* params in frostf-scli (type={type_shards})")
     @pytest.mark.parametrize("type_shards", ["Maximum count of data shards", "Maximum count of parity shards"])
-    def test_maxec_info_with_output_cli(self, frostfs_local_cli: FrostfsCli, type_shards: str) -> None:
+    def test_maxec_info_with_output_cli(self, frostfs_cli: FrostfsCli, type_shards: str) -> None:
         with reporter.step("Get and check params"):
-            net_info = frostfs_local_cli.netmap.netinfo(self.cluster.default_rpc_endpoint).stdout
+            net_info = frostfs_cli.netmap.netinfo(self.cluster.default_rpc_endpoint).stdout
             assert type_shards in net_info
 
     @allure.title("Change MaxEC*Count params")
     def test_change_max_data_shards_params(
         self,
         frostfs_remote_adm: FrostfsAdm,
-        frostfs_local_cli: FrostfsCli,
+        frostfs_cli: FrostfsCli,
         restore_network_config: None,
     ) -> None:
         with reporter.step("Get now params MaxECDataCount and MaxECParityCount"):
-            node_netinfo = NetmapParser.netinfo(frostfs_local_cli.netmap.netinfo(self.cluster.default_rpc_endpoint).stdout)
+            node_netinfo = NetmapParser.netinfo(
+                frostfs_cli.netmap.netinfo(self.cluster.default_rpc_endpoint, timeout=CLI_DEFAULT_TIMEOUT).stdout
+            )
 
         with reporter.step("Change params"):
             frostfs_remote_adm.morph.set_config(set_key_value='"MaxECDataCount=5" "MaxECParityCount=3"')
 
         with reporter.step("Get update params"):
-            update_net_info = NetmapParser.netinfo(frostfs_local_cli.netmap.netinfo(self.cluster.default_rpc_endpoint).stdout)
+            update_net_info = NetmapParser.netinfo(
+                frostfs_cli.netmap.netinfo(self.cluster.default_rpc_endpoint, timeout=CLI_DEFAULT_TIMEOUT).stdout
+            )
 
         with reporter.step("Check old and new params difference"):
             assert (
@@ -528,14 +724,18 @@ class TestECReplication(ClusterTestBase):
     def test_create_container_with_select(
         self,
         select: int,
-        frostfs_local_cli: FrostfsCli,
+        frostfs_cli: FrostfsCli,
     ) -> None:
         with reporter.step("Create container"):
             policy = f"EC 1.1 CBF 1 SELECT {select} FROM *"
-            cid = self.create_container(frostfs_local_cli, self.cluster.default_rpc_endpoint, policy)
+            cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, policy)
 
         with reporter.step("Check container nodes decomposed"):
-            container_nodes = frostfs_local_cli.container.search_node(self.cluster.default_rpc_endpoint, cid).stdout.strip().split("\n")[1:]
+            container_nodes = (
+                frostfs_cli.container.search_node(self.cluster.default_rpc_endpoint, cid, timeout=CLI_DEFAULT_TIMEOUT)
+                .stdout.strip()
+                .split("\n")[1:]
+            )
             assert len(container_nodes) == select
 
     @allure.title("Create container with EC policy and CBF (CBF={cbf})")
@@ -544,35 +744,167 @@ class TestECReplication(ClusterTestBase):
         self,
         cbf: int,
         expected_nodes: int,
-        frostfs_local_cli: FrostfsCli,
+        frostfs_cli: FrostfsCli,
     ) -> None:
         with reporter.step("Create container."):
             policy = f"EC 1.1 CBF {cbf}"
-            cid = self.create_container(frostfs_local_cli, self.cluster.default_rpc_endpoint, policy)
+            cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, policy)
 
         with reporter.step("Check expected container nodes."):
-            container_nodes = frostfs_local_cli.container.search_node(self.cluster.default_rpc_endpoint, cid).stdout.strip().split("\n")[1:]
+            container_nodes = (
+                frostfs_cli.container.search_node(self.cluster.default_rpc_endpoint, cid, timeout=CLI_DEFAULT_TIMEOUT)
+                .stdout.strip()
+                .split("\n")[1:]
+            )
             assert len(container_nodes) == expected_nodes
 
     @allure.title("Create container with EC policy and FILTER")
     def test_create_container_with_filter(
         self,
         default_user: User,
-        frostfs_local_cli: FrostfsCli,
+        frostfs_cli: FrostfsCli,
         simple_object_size: ObjectSize,
     ) -> None:
         with reporter.step("Create Container."):
             policy = "EC 1.1 IN RUS SELECT 2 FROM RU AS RUS FILTER Country EQ Russia AS RU"
-            cid = self.create_container(frostfs_local_cli, self.cluster.default_rpc_endpoint, policy)
+            cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, policy)
 
         with reporter.step("Put object in container."):
             test_file = generate_file(simple_object_size.value)
             oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
 
         with reporter.step("Check object is decomposed exclusively on Russian nodes"):
-            data_chunk = self.get_data_chunk_object(frostfs_local_cli, cid, oid, self.cluster.default_rpc_endpoint)
-            parity_chunk = self.get_parity_chunk_object(frostfs_local_cli, cid, oid, self.cluster.default_rpc_endpoint)
-            node_data_chunk = self.get_chunk_node(frostfs_local_cli, data_chunk)
-            node_parity_chunk = self.get_chunk_node(frostfs_local_cli, parity_chunk)
+            data_chunk = self.get_data_chunk_object(frostfs_cli, cid, oid, self.cluster.default_rpc_endpoint)
+            parity_chunk = self.get_parity_chunk_object(frostfs_cli, cid, oid, self.cluster.default_rpc_endpoint)
+            node_data_chunk = self.get_chunk_node(frostfs_cli, data_chunk)
+            node_parity_chunk = self.get_chunk_node(frostfs_cli, parity_chunk)
             for node in [node_data_chunk[1], node_parity_chunk[1]]:
                 assert "Russia" in node.country
+
+    @allure.title("Evacuation shard with chunk (type={type})")
+    @pytest.mark.parametrize("type, get_chunk", [("data", get_data_chunk_object), ("parity", get_parity_chunk_object)])
+    def test_evacuation_data_shard(
+        self,
+        default_user: User,
+        frostfs_cli: FrostfsCli,
+        max_object_size: int,
+        type: str,
+        get_chunk,
+    ) -> None:
+        with reporter.step("Create container."):
+            cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 1.1 CBF 1")
+
+        with reporter.step("Put object in container."):
+            test_file = generate_file(max_object_size - 1000)
+            oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
+
+        with reporter.step("Get object chunks."):
+            chunk = get_chunk(self, frostfs_cli, cid, oid, self.cluster.default_rpc_endpoint)
+            chunk_node = self.get_chunk_node(frostfs_cli, chunk)
+            frostfs_node_cli = FrostfsCli(
+                chunk_node[0].host.get_shell(),
+                frostfs_cli_exec_path=FROSTFS_CLI_EXEC,
+                config_file=chunk_node[0].storage_node.get_remote_wallet_config_path(),
+            )
+
+        with reporter.step("Search shards chunk"):
+            shard_id = self.get_shard_chunk(chunk_node[0], chunk)
+
+        with reporter.step("Enable evacuation for shard"):
+            frostfs_node_cli.shards.set_mode(chunk_node[0].storage_node.get_control_endpoint(), mode="read-only", id=shard_id)
+            frostfs_node_cli.shards.evacuation_start(chunk_node[0].storage_node.get_control_endpoint(), shard_id, await_mode=True)
+
+        with reporter.step("Get object after evacuation shard"):
+            get_object(default_user.wallet, cid, oid, self.shell, self.cluster.default_rpc_endpoint)
+
+    @allure.title("[NEGATIVE] Don`t create more 1 EC policy")
+    def test_more_one_ec_policy(
+        self,
+        frostfs_cli: FrostfsCli,
+    ) -> None:
+        with reporter.step("Create container with policy - 'EC 2.1 EC 1.1'"):
+            with pytest.raises(RuntimeError, match="can't parse placement policy"):
+                self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 2.1 EC 1.1 CBF 1 SELECT 4 FROM *")
+
+    @allure.title("Create bucket with EC policy (s3_client={s3_client})")
+    @pytest.mark.parametrize("s3_policy, s3_client", [("pytest_tests/resources/files/policy.json", AwsCliClient)], indirect=True)
+    def test_create_bucket_with_ec_location(
+        self,
+        s3_client: S3ClientWrapper,
+        bucket_container_resolver: BucketContainerResolver,
+        frostfs_cli: FrostfsCli,
+    ) -> None:
+        with reporter.step("Create bucket with EC location constrain"):
+            bucket = s3_client.create_bucket(location_constraint="ec3.1")
+
+        with reporter.step("Resolve container bucket"):
+            cid = bucket_container_resolver.resolve(self.cluster.cluster_nodes[0], bucket)
+
+        with reporter.step("Validate container policy"):
+            container = frostfs_cli.container.get(
+                self.cluster.default_rpc_endpoint, cid, json_mode=True, timeout=CLI_DEFAULT_TIMEOUT
+            ).stdout
+            assert container
+
+    @allure.title("Bucket object count chunks (s3_client={s3_client}, size={object_size})")
+    @pytest.mark.parametrize("s3_policy, s3_client", [("pytest_tests/resources/files/policy.json", AwsCliClient)], indirect=True)
+    def test_count_chunks_bucket_with_ec_location(
+        self,
+        s3_client: S3ClientWrapper,
+        bucket_container_resolver: BucketContainerResolver,
+        frostfs_cli: FrostfsCli,
+        object_size: ObjectSize,
+    ) -> None:
+        with reporter.step("Create bucket with EC location constrain"):
+            bucket = s3_client.create_bucket(location_constraint="ec3.1")
+
+        with reporter.step("Enable versioning object"):
+            s3_client.put_bucket_versioning(bucket, VersioningStatus.ENABLED)
+            bucket_status = s3_client.get_bucket_versioning_status(bucket)
+            assert bucket_status == VersioningStatus.ENABLED.value
+
+        with reporter.step("Put object in bucket"):
+            test_file = generate_file(object_size.value)
+            bucket_object = s3_client.put_object(bucket, test_file)
+
+        with reporter.step("Watch replication count chunks"):
+            cid = bucket_container_resolver.resolve(self.cluster.cluster_nodes[0], bucket)
+            chunks = self.get_all_chunks_object(frostfs_cli, cid, bucket_object, self.cluster.default_rpc_endpoint)
+            expect_chunks = 4 if object_size.name == "simple" else 16
+            assert len(chunks) == expect_chunks
+
+    @allure.title("Replication chunk after drop (size={object_size})")
+    def test_drop_chunk_and_replication(
+        self,
+        frostfs_cli: FrostfsCli,
+        default_user: User,
+        object_size: ObjectSize,
+        rep_count: int,
+    ) -> None:
+        with reporter.step("Create container"):
+            cid = self.create_container(frostfs_cli, self.cluster.default_rpc_endpoint, "EC 2.1 CBF 1")
+
+        with reporter.step("Put object"):
+            test_file = generate_file(object_size.value)
+            oid = put_object(default_user.wallet, test_file, cid, self.shell, self.cluster.default_rpc_endpoint)
+
+        with reporter.step("Get all chunks"):
+            chunk = self.get_data_chunk_object(frostfs_cli, cid, oid, self.cluster.default_rpc_endpoint)
+
+        with reporter.step("Search chunk node"):
+            chunk_node = self.get_chunk_node(frostfs_cli, chunk)
+            shell_chunk_node = chunk_node[0].host.get_shell()
+
+        with reporter.step("Get replication count"):
+            assert self.check_replication(rep_count, frostfs_cli, cid, oid)
+
+        with reporter.step("Delete chunk"):
+            frostfs_node_cli = FrostfsCli(
+                shell_chunk_node,
+                frostfs_cli_exec_path=FROSTFS_CLI_EXEC,
+                config_file=chunk_node[0].storage_node.get_remote_wallet_config_path(),
+            )
+            frostfs_node_cli.control.drop_objects(chunk_node[0].storage_node.get_control_endpoint(), f"{cid}/{chunk.object_id}")
+
+        with reporter.step("Wait replication count after drop one chunk"):
+            self.wait_replication(rep_count, frostfs_cli, cid, oid)

pytest_tests/testsuites/services/http_gate/test_http_bearer.py

@@ -60,6 +60,7 @@ class Test_http_bearer(ClusterTestBase):
             error_pattern="access to object operation denied",
         )
 
+    @allure.title("Put object via HTTP using bearer token (object_size={object_size})")
     def test_put_with_bearer_when_eacl_restrict(
         self,
         object_size: ObjectSize,

pytest_tests/testsuites/services/http_gate/test_http_object.py

@@ -125,7 +125,7 @@ class Test_http_object(ClusterTestBase):
                 http_request_path=request,
             )
 
-    @allure.title("Put over s3, Get over HTTP with bucket name and key")
+    @allure.title("Put over s3, Get over HTTP with bucket name and key (object_size={object_size})")
     @pytest.mark.parametrize("s3_client", [AwsCliClient], indirect=True)
     def test_object_put_get_bucketname_key(self, object_size: ObjectSize, s3_client: S3ClientWrapper):
         """

pytest_tests/testsuites/session_token/test_static_session_token_container.py

@@ -1,3 +1,4 @@
+import allure
 import pytest
 from frostfs_testlib import reporter
 from frostfs_testlib.shell import Shell
@@ -22,6 +23,7 @@ class TestSessionTokenContainer(ClusterTestBase):
         """
         return {verb: get_container_signed_token(owner_wallet, user_wallet, verb, client_shell, temp_directory) for verb in ContainerVerb}
 
+    @allure.title("Static session with create operation")
     def test_static_session_token_container_create(
         self,
         owner_wallet: WalletInfo,
@@ -46,6 +48,7 @@ class TestSessionTokenContainer(ClusterTestBase):
         assert cid not in list_containers(user_wallet, shell=self.shell, endpoint=self.cluster.default_rpc_endpoint)
         assert cid in list_containers(owner_wallet, shell=self.shell, endpoint=self.cluster.default_rpc_endpoint)
 
+    @allure.title("[NEGATIVE] Static session without create operation")
     def test_static_session_token_container_create_with_other_verb(
         self,
         user_wallet: WalletInfo,
@@ -65,6 +68,7 @@ class TestSessionTokenContainer(ClusterTestBase):
                         wait_for_creation=False,
                     )
 
+    @allure.title("[NEGATIVE] Static session with create operation for other wallet")
     def test_static_session_token_container_create_with_other_wallet(
         self,
         stranger_wallet: WalletInfo,
@@ -83,6 +87,7 @@ class TestSessionTokenContainer(ClusterTestBase):
                     wait_for_creation=False,
                 )
 
+    @allure.title("Static session with delete operation")
     def test_static_session_token_container_delete(
         self,
         owner_wallet: WalletInfo,

pytest_tests/testsuites/shard/test_control_shard.py

@@ -31,9 +31,7 @@ class TestControlShard(ClusterTestBase):
             data_path = node.storage_node.get_data_directory()
             all_datas = node_shell.exec(f"ls -la {data_path}/data | awk '{{ print $9 }}'").stdout.strip()
             for data_dir in all_datas.replace(".", "").strip().split("\n"):
-                check_dir = node_shell.exec(
-                    f" [ -d {data_path}/data/{data_dir}/data/{oid_path} ] && echo 1 || echo 0"
-                ).stdout
+                check_dir = node_shell.exec(f" [ -d {data_path}/data/{data_dir}/data/{oid_path} ] && echo 1 || echo 0").stdout
                 if "1" in check_dir:
                     object_path = f"{data_path}/data/{data_dir}/data/{oid_path}"
                     object_name = f"{oid[4:]}.{cid}"
@@ -66,9 +64,7 @@ class TestControlShard(ClusterTestBase):
                 basic_acl=EACL_PUBLIC_READ_WRITE,
             )
             file = generate_file(round(max_object_size * 0.8))
-            oid = put_object(
-                wallet=default_wallet, path=file, cid=cid, shell=self.shell, endpoint=self.cluster.default_rpc_endpoint
-            )
+            oid = put_object(wallet=default_wallet, path=file, cid=cid, shell=self.shell, endpoint=self.cluster.default_rpc_endpoint)
         with reporter.step("Search node with object"):
             nodes = get_object_nodes(cluster=self.cluster, cid=cid, oid=oid, alive_node=self.cluster.cluster_nodes[0])
 
@@ -76,9 +72,7 @@ class TestControlShard(ClusterTestBase):
 
         object_path, object_name = self.get_object_path_and_name_file(oid, cid, nodes[0])
         nodes[0].host.get_shell().exec(f"chmod +r {object_path}/{object_name}")
-        delete_object(
-            wallet=default_wallet, cid=cid, oid=oid, shell=self.shell, endpoint=self.cluster.default_rpc_endpoint
-        )
+        delete_object(wallet=default_wallet, cid=cid, oid=oid, shell=self.shell, endpoint=self.cluster.default_rpc_endpoint)
         delete_container(wallet=default_wallet, cid=cid, shell=self.shell, endpoint=self.cluster.default_rpc_endpoint)
 
     @staticmethod
@@ -117,6 +111,7 @@ class TestControlShard(ClusterTestBase):
 
             assert set(shards_from_config) == set(shards_from_cli)
 
+    @allure.title("Shard become read-only when errors exceeds threshold")
     @pytest.mark.failover
     def test_shard_errors(
         self,

pytest_tests/testsuites/special/test_frostfs_logs.py

@@ -20,8 +20,9 @@ def pytest_generate_tests(metafunc: pytest.Metafunc):
     )
 
 
-@pytest.mark.logs_after_session
+@pytest.mark.session_logs
 class TestLogs:
+    @pytest.mark.logs_after_session
     @pytest.mark.order(1000)
     @allure.title("Check logs from frostfs-testcases with marks '{request.config.option.markexpr}' - search errors")
     def test_logs_search_errors(self, temp_directory: str, cluster: Cluster, session_start_time: datetime, request: pytest.FixtureRequest):

requirements.txt

@@ -4,7 +4,6 @@ base58==2.1.0
 boto3==1.16.33
 botocore==1.19.33
 configobj==5.0.6
-frostfs-testlib>=2.0.1
 neo-mamba==1.0.0
 pexpect==4.8.0
 pyyaml==6.0.1