tests: add ec sanity test

Signed-off-by: Evgeniy Zayats <zayatsevgeniy@nspcc.io>

Author: Evgeniy Zayats

neofs-testlib/neofs_testlib/cli/neofs_cli/object.py

@@ -415,3 +415,27 @@ def searchv2(
             "object searchv2",
             **{param: value for param, value in locals().items() if param not in ["self"]},
         )
+
+    def nodes(
+        self,
+        rpc_endpoint: str,
+        cid: str,
+        oid: Optional[str] = None,
+        shell_timeout: Optional[str] = None,
+    ) -> CommandResult:
+        """
+        Search object.
+
+        Args:
+            rpc_endpoint: Remote node address (as 'multiaddr' or '<host>:<port>').
+            cid: Container ID.
+            oid: Object ID.
+            shell_timeout: Shell timeout for the command.
+
+        Returns:
+            Command's result.
+        """
+        return self._execute(
+            "object nodes",
+            **{param: value for param, value in locals().items() if param not in ["self"]},
+        )

neofs-testlib/neofs_testlib/env/env.py

@@ -171,13 +171,16 @@ def generate_neo_go_config(self, wallet: NodeWallet):
         return neo_go_config_path
 
     @allure.step("Deploy inner ring nodes")
-    def deploy_inner_ring_nodes(self, count=1, with_main_chain=False, chain_meta_data=False, sn_validator_url=None):
+    def deploy_inner_ring_nodes(
+        self, count=1, with_main_chain=False, chain_meta_data=False, sn_validator_url=None, allow_ec=False
+    ):
         for _ in range(count):
             new_inner_ring_node = InnerRing(
                 self,
                 len(self.inner_ring_nodes) + 1,
                 chain_meta_data=chain_meta_data,
                 sn_validator_url=sn_validator_url,
+                allow_ec=allow_ec,
             )
             new_inner_ring_node.generate_network_config()
             self.inner_ring_nodes.append(new_inner_ring_node)
@@ -664,6 +667,7 @@ def deploy(
         request=None,
         chain_meta_data=False,
         sn_validator_url=None,
+        allow_ec=False,
         fschain_endpoints: Optional[list[str]] = None,
         shards_count=2,
         gc_remover_batch_size=200,
@@ -680,6 +684,7 @@ def deploy(
                 with_main_chain=with_main_chain,
                 chain_meta_data=chain_meta_data,
                 sn_validator_url=sn_validator_url,
+                allow_ec=allow_ec,
             )
 
             if storage_nodes_count:
@@ -1052,11 +1057,7 @@ def _wait_until_ready(self):
 
 class InnerRing(ResurrectableProcess):
     def __init__(
-        self,
-        neofs_env: NeoFSEnv,
-        ir_number: int,
-        chain_meta_data=False,
-        sn_validator_url=None,
+        self, neofs_env: NeoFSEnv, ir_number: int, chain_meta_data=False, sn_validator_url=None, allow_ec=False
     ):
         self.neofs_env = neofs_env
         self.ir_number = ir_number
@@ -1083,6 +1084,7 @@ def __init__(
         self.ir_state_file = self.neofs_env._generate_temp_file(self.inner_ring_dir, prefix="ir_state_file")
         self.chain_meta_data = chain_meta_data
         self.sn_validator_url = sn_validator_url
+        self.allow_ec = allow_ec
         self.stdout = "Not initialized"
         self.stderr = "Not initialized"
         self.process = None
@@ -1178,6 +1180,7 @@ def start(
                 prometheus_address=self.prometheus_address,
                 chain_meta_data=self.chain_meta_data,
                 sn_validator_url=self.sn_validator_url,
+                allow_ec=self.allow_ec,
             )
         logger.info(f"Launching Inner Ring Node:{self}")
         self._launch_process()

neofs-testlib/neofs_testlib/env/templates/ir.yaml

@@ -125,6 +125,7 @@ prometheus:
 
 experimental:
   chain_meta_data: {{ chain_meta_data }}
+  allow_ec: {{ allow_ec }}
 
 {% if sn_validator_url %}
 sn_validator:

pytest_tests/tests/conftest.py

@@ -38,6 +38,7 @@ def get_or_create_neofs_env(
     with_rest_gw=True,
     chain_meta_data=False,
     sn_validator_url=None,
+    allow_ec=False,
     shards_count=2,
     gc_remover_batch_size=200,
     gc_sleep_interval=STORAGE_GC_TIME,
@@ -56,6 +57,7 @@ def get_or_create_neofs_env(
             request=request,
             chain_meta_data=chain_meta_data,
             sn_validator_url=sn_validator_url,
+            allow_ec=allow_ec,
             shards_count=shards_count,
             gc_remover_batch_size=gc_remover_batch_size,
             gc_sleep_interval=gc_sleep_interval,
@@ -70,7 +72,11 @@ def neofs_env(temp_directory, artifacts_directory, request):
     else:
         params = {}
     neofs_env = get_or_create_neofs_env(
-        request, with_s3_gw=True, with_rest_gw=True, chain_meta_data=params.get("chain_meta_data", False)
+        request,
+        with_s3_gw=True,
+        with_rest_gw=True,
+        chain_meta_data=params.get("chain_meta_data", False),
+        allow_ec=params.get("allow_ec", False),
     )
     yield neofs_env
     neofs_env.finalize(request)

pytest_tests/tests/container/test_ec_container.py

@@ -0,0 +1,111 @@
+import re
+
+import allure
+import neofs_env.neofs_epoch as neofs_epoch
+import pytest
+from helpers.container import (
+    create_container,
+    delete_container,
+    list_containers,
+    wait_for_container_deletion,
+)
+from helpers.file_helper import generate_file
+from helpers.neofs_verbs import (
+    get_object,
+    put_object_to_random_node,
+    search_objectv2,
+)
+from neofs_testlib.env.env import NeoFSEnv, NodeWallet
+
+
+def parse_ec_nodes_count(output: str) -> int:
+    """
+    Parse the EC descriptor output and count the number of nodes.
+
+    Args:
+        output: The output from neofs-cli object nodes command
+
+    Returns:
+        int: Number of nodes found in the output
+    """
+    node_pattern = r"Node \d+:"
+    nodes = re.findall(node_pattern, output)
+    return len(nodes)
+
+
+@pytest.mark.sanity
+@pytest.mark.parametrize("neofs_env", [{"allow_ec": True}], ids=["allow_ec=True"], indirect=True)
+@pytest.mark.parametrize(
+    "data_shards,parity_shards",
+    [
+        (3, 1),
+        (2, 1),
+        (1, 1),
+        (1, 2),
+        (2, 2),
+        (1, 3),
+    ],
+    ids=[
+        "EC_3/1",
+        "EC_2/1",
+        "EC_1/1",
+        "EC_1/2",
+        "EC_2/2",
+        "EC_1/3",
+    ],
+)
+@pytest.mark.simple
+def test_ec_container_sanity(default_wallet: NodeWallet, neofs_env: NeoFSEnv, data_shards: int, parity_shards: int):
+    wallet = default_wallet
+
+    placement_rule = f"EC {data_shards}/{parity_shards} CBF 1"
+    cid = create_container(
+        wallet.path,
+        rule=placement_rule,
+        name="ec-container",
+        shell=neofs_env.shell,
+        endpoint=neofs_env.sn_rpc,
+    )
+
+    containers = list_containers(wallet.path, shell=neofs_env.shell, endpoint=neofs_env.sn_rpc)
+    assert cid in containers, f"Expected container {cid} in containers: {containers}"
+
+    source_file_path = generate_file(neofs_env.get_object_size("simple_object_size"))
+
+    oid = put_object_to_random_node(wallet.path, source_file_path, cid, shell=neofs_env.shell, neofs_env=neofs_env)
+
+    get_object(
+        default_wallet.path,
+        cid,
+        oid,
+        neofs_env.shell,
+        neofs_env.sn_rpc,
+    )
+
+    result = (
+        neofs_env.neofs_cli(neofs_env.storage_nodes[0].cli_config)
+        .object.nodes(rpc_endpoint=neofs_env.storage_nodes[0].endpoint, cid=cid, oid=oid)
+        .stdout
+    )
+    assert f"EC {data_shards}/{parity_shards}" in result, f"Expected placement rule {placement_rule} in nodes output: {result}"
+
+    expected_nodes = data_shards + parity_shards
+    actual_nodes = parse_ec_nodes_count(result)
+    assert actual_nodes == expected_nodes, (
+        f"Expected {expected_nodes} nodes (data: {data_shards}, parity: {parity_shards}), but found {actual_nodes} nodes in output: {result}"
+    )
+
+    found_objects, _ = search_objectv2(
+        rpc_endpoint=neofs_env.sn_rpc, wallet=default_wallet.path, cid=cid, shell=neofs_env.shell
+    )
+
+    assert len(found_objects) == expected_nodes + 1, (
+        f"Invalid number of found objects in EC container, expected {expected_nodes + 1}, found {len(found_objects)}"
+    )
+
+    with allure.step("Delete container and check it was deleted"):
+        delete_container(wallet.path, cid, shell=neofs_env.shell, endpoint=neofs_env.sn_rpc)
+        current_epoch = neofs_epoch.get_epoch(neofs_env)
+        neofs_epoch.tick_epoch(neofs_env)
+        neofs_epoch.wait_for_epochs_align(neofs_env, current_epoch)
+        wait_for_container_deletion(wallet.path, cid, shell=neofs_env.shell, endpoint=neofs_env.sn_rpc)