Only do local sealing self-healing-open

[cjen1-msft]

We only intend to use self-healing-open when local sealing is available, so we should run all of our tests in that environment.

[Copilot]

Pull request overview

This PR modifies the self-healing-open test functions to enforce that they only run with local sealing enabled, as per the intended use case. The removed run_self_healing_open_local_unsealing function is consolidated into the main run_self_healing_open test, and all three self-healing-open tests are moved to run only in the SNP test suite (which has local sealing available).

Changes:

• Added enable_local_sealing = True to run_self_healing_open function and updated its label
• Simplified test assertions by removing redundant recovery share submission and network opening checks
• Removed the duplicate run_self_healing_open_local_unsealing function (75 lines)
• Moved all three self-healing-open tests from run() to run_snp_tests() to ensure they only execute in environments with local sealing

Comments suppressed due to low confidence (2)

tests/e2e_operations.py:1813

• The function run_self_healing_open_timeout_path is missing args.enable_local_sealing = True like the other self-healing-open functions. According to the PR description, all self-healing-open tests should run with local sealing enabled.

    args.label += "_self_healing_open_timeout"

tests/e2e_operations.py:1871

• The function run_self_healing_open_multiple_timeout is missing args.enable_local_sealing = True like run_self_healing_open. According to the PR description, all self-healing-open tests should run with local sealing enabled.

    args.label += "_self_healing_open_multiple_timeout"

[achamayou]

I am confused as to why we are prefixing labels that way, and only doing it in this one file.

[achamayou]

As best I can tell, this is because the traditional style of test looked like this:

def toplevel(args):
  with network() as network:
    network.start_and_open()
    test1(network)
    test2(network)
    ...

And so having common under infra.network.get_common_folder_name(args.workspace, args.label) was plausibly fine, because each toplevel would get its own label/CMake name.

Then the ConcurrentRunners came, and they started prefixing, partly to avoid collisions, but mostly to make it easier to find output: args_.label = f"{prefix}_{self.args.label}".

But e2e_operations starts a lot of networks, almost as many as all other tests combined, and so this isn't granular enough.

Two thoughts:

1. We could introduce an extra directory label, probably the current CMake testname/label before it gets tampered with, to cut down on crowding.
2. Inside there, use {runner}.{module}.{function} as a prefix, and keep the rest identical.

For example:

operations_schema_test_self_healing_open_multiple_timeout_0

would become:

schema_test/operations.e2e_operations.run_self_healing_open_multiple_timeout

I am not sure if the CR name is useful to be honest, I think this might be fine:

schema_test/e2e_operations.run_self_healing_open_multiple_timeout

That tells you easily which tests did this and where to find the code that created the network. For functions that start multiple networks, we can suffix further:

schema_test/e2e_operations.run_self_healing_open_multiple_timeout[B]

We could also decide to create common, 0, 1 etc as sub-directories of that rather than _suffix them.