Repository: aristanetworks/anta
Pull request #1194: feat(anta.tests): Added testcases to validate redundancy SSO is enabled
Author: login: geetanjalimanegslab
Labels: name: rn: feat(anta.tests)
Created: 2025-05-12T02:51:39Z | Merged: 2025-05-20T12:25:24Z

# Description
feat(anta.tests): 'Added testcases to validate redundancy SSO is enabled

Added test - **base_services_redundancy_sso_test.py**

# Checklist:

- [x] My code follows the style guidelines of this project
- [x] I have performed a self-review of my code
- [x] I have run pre-commit for code linting and typing (`pre-commit run`)
- [ ] I have made corresponding changes to the documentation
- [x] I have added tests that prove my fix is effective or that my feature works
- [x] New and existing unit tests pass locally with my changes (`tox -e testenv`)



Diff:
diff --git a/anta/tests/hardware.py b/anta/tests/hardware.py
index 8bac413d8..f44657a99 100644
--- a/anta/tests/hardware.py
+++ b/anta/tests/hardware.py
@@ -7,7 +7,7 @@
 # mypy: disable-error-code=attr-defined
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, ClassVar
+from typing import TYPE_CHECKING, ClassVar, Literal
 
 from anta.custom_types import PowerSupplyFanStatus, PowerSupplyStatus
 from anta.decorators import skip_on_platforms
@@ -269,3 +269,54 @@ def test(self) -> None:
         total_adverse_drop = command_output.get("totalAdverseDrops", "")
         if total_adverse_drop != 0:
             self.result.is_failure(f"Incorrect total adverse drops counter - Expected: 0 Actual: {total_adverse_drop}")
+
+
+class VerifySupervisorRedundancy(AntaTest):
+    """Verifies the redundancy protocol configured on the active supervisor.
+
+    Expected Results
+    ----------------
+    * Success: The test will pass if the expected redundancy protocol is configured and operational, and if switchover is ready.
+    * Failure: The test will fail if the expected redundancy protocol is not configured, not operational, or if switchover is not ready.
+    * Skipped: The test will be skipped if the peer supervisor card is not inserted.
+
+    Examples
+    --------
+    ```yaml
+    anta.tests.hardware:
+      - VerifySupervisorRedundancy:
+    ```
+    """
+
+    categories: ClassVar[list[str]] = ["hardware"]
+    commands: ClassVar[list[AntaCommand | AntaTemplate]] = [AntaCommand(command="show redundancy status", revision=1)]
+
+    class Input(AntaTest.Input):
+        """Input model for the VerifySupervisorRedundancy test."""
+
+        redundency_proto: Literal["sso", "rpr", "simplex"] = "sso"
+        """Configured redundancy protocol."""
+
+    @skip_on_platforms(["cEOSLab", "vEOS-lab", "cEOSCloudLab", "vEOS"])
+    @AntaTest.anta_test
+    def test(self) -> None:
+        """Main test function for VerifySupervisorRedundancy."""
+        self.result.is_success()
+        command_output = self.instance_commands[0].json_output
+
+        # Verify peer supervisor card insertion
+        if command_output["peerState"] == "notInserted":
+            self.result.is_skipped("Peer supervisor card not inserted")
+            return
+
+        # Verify that the expected redundancy protocol is configured
+        if (act_proto := command_output["configuredProtocol"]) != self.inputs.redundency_proto:
+            self.result.is_failure(f"Configured redundancy protocol mismatch - Expected {self.inputs.redundency_proto} Actual: {act_proto}")
+
+        # Verify that the expected redundancy protocol configured and operational
+        elif (act_proto := command_output["operationalProtocol"]) != self.inputs.redundency_proto:
+            self.result.is_failure(f"Operational redundancy protocol mismatch - Expected {self.inputs.redundency_proto} Actual: {act_proto}")
+
+        # Verify that the expected redundancy protocol configured, operational and switchover ready
+        elif not command_output["switchoverReady"]:
+            self.result.is_failure(f"Redundancy protocol switchover status mismatch - Expected: True Actual: {command_output['switchoverReady']}")
diff --git a/examples/tests.yaml b/examples/tests.yaml
index a25957f0f..1efbbffe2 100644
--- a/examples/tests.yaml
+++ b/examples/tests.yaml
@@ -229,6 +229,8 @@ anta.tests.hardware:
         - ok
   - VerifyEnvironmentSystemCooling:
       # Verifies the device's system cooling status.
+  - VerifySupervisorRedundancy:
+      # Verifies the redundancy protocol configured on the active supervisor.
   - VerifyTemperature:
       # Verifies if the device temperature is within acceptable limits.
   - VerifyTransceiversManufacturers:
diff --git a/tests/units/anta_tests/test_hardware.py b/tests/units/anta_tests/test_hardware.py
index 7ab748df2..14df82ec0 100644
--- a/tests/units/anta_tests/test_hardware.py
+++ b/tests/units/anta_tests/test_hardware.py
@@ -15,6 +15,7 @@
     VerifyEnvironmentCooling,
     VerifyEnvironmentPower,
     VerifyEnvironmentSystemCooling,
+    VerifySupervisorRedundancy,
     VerifyTemperature,
     VerifyTransceiversManufacturers,
     VerifyTransceiversTemperature,
@@ -872,4 +873,77 @@
         "eos_data": [{"totalAdverseDrops": 10}],
         "expected": {"result": AntaTestStatus.FAILURE, "messages": ["Incorrect total adverse drops counter - Expected: 0 Actual: 10"]},
     },
+    (VerifySupervisorRedundancy, "success-redunduncy-status"): {
+        "eos_data": [
+            {
+                "configuredProtocol": "sso",
+                "operationalProtocol": "sso",
+                "communicationDesc": "Up",
+                "peerState": "unknownPeerState",
+                "switchoverReady": True,
+            }
+        ],
+        "expected": {"result": AntaTestStatus.SUCCESS},
+    },
+    (VerifySupervisorRedundancy, "success-redunduncy-status-simplex"): {
+        "eos_data": [
+            {
+                "configuredProtocol": "simplex",
+                "operationalProtocol": "simplex",
+                "communicationDesc": "Up",
+                "peerState": "unknownPeerState",
+                "switchoverReady": True,
+            }
+        ],
+        "inputs": {"redundency_proto": "simplex"},
+        "expected": {"result": AntaTestStatus.SUCCESS},
+    },
+    (VerifySupervisorRedundancy, "failure-no-redunduncy-status"): {
+        "eos_data": [
+            {
+                "configuredProtocol": "simplex",
+                "operationalProtocol": "simplex",
+                "communicationDesc": "Up",
+                "peerState": "unknownPeerState",
+                "switchoverReady": True,
+            }
+        ],
+        "expected": {"result": AntaTestStatus.FAILURE, "messages": ["Configured redundancy protocol mismatch - Expected sso Actual: simplex"]},
+    },
+    (VerifySupervisorRedundancy, "failure-no-redunduncy-operational"): {
+        "eos_data": [
+            {
+                "configuredProtocol": "sso",
+                "operationalProtocol": "simplex",
+                "communicationDesc": "Up",
+                "peerState": "unknownPeerState",
+                "switchoverReady": False,
+            }
+        ],
+        "expected": {"result": AntaTestStatus.FAILURE, "messages": ["Operational redundancy protocol mismatch - Expected sso Actual: simplex"]},
+    },
+    (VerifySupervisorRedundancy, "skip-card-not-inserted"): {
+        "eos_data": [
+            {
+                "configuredProtocol": "sso",
+                "operationalProtocol": "sso",
+                "communicationDesc": "Up",
+                "peerState": "notInserted",
+                "switchoverReady": False,
+            }
+        ],
+        "expected": {"result": AntaTestStatus.SKIPPED, "messages": ["Peer supervisor card not inserted"]},
+    },
+    (VerifySupervisorRedundancy, "failure-no-redunduncy-switchover-ready"): {
+        "eos_data": [
+            {
+                "configuredProtocol": "sso",
+                "operationalProtocol": "sso",
+                "communicationDesc": "Up",
+                "peerState": "unknownPeerState",
+                "switchoverReady": False,
+            }
+        ],
+        "expected": {"result": AntaTestStatus.FAILURE, "messages": ["Redundancy protocol switchover status mismatch - Expected: True Actual: False"]},
+    },
 }


Reviews:
user: login: vitthalmagadum
state: CHANGES_REQUESTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-13T08:21:48Z
user: login: vitthalmagadum
state: APPROVED
author_association: CONTRIBUTOR
submitted_at: 2025-05-13T11:31:07Z
user: login: carl-baillargeon
state: CHANGES_REQUESTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-13T17:55:36Z
user: login: geetanjalimanegslab
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-14T07:05:45Z
user: login: geetanjalimanegslab
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-14T07:05:47Z
user: login: geetanjalimanegslab
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-14T07:05:53Z
user: login: geetanjalimanegslab
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-14T07:05:55Z
user: login: geetanjalimanegslab
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-14T07:05:57Z
user: login: geetanjalimanegslab
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-14T07:06:08Z
user: login: geetanjalimanegslab
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-14T07:20:13Z
user: login: carl-baillargeon
body: LGTM!
state: APPROVED
author_association: CONTRIBUTOR
submitted_at: 2025-05-20T12:24:48Z

Review comments:
diff_hunk: @@ -269,3 +269,43 @@ def test(self) -> None:
         total_adverse_drop = command_output.get("totalAdverseDrops", "")
         if total_adverse_drop != 0:
             self.result.is_failure(f"Incorrect total adverse drops counter - Expected: 0 Actual: {total_adverse_drop}")
+
+
+class VerifyredundencySso(AntaTest):
path: anta/tests/hardware.py
user: login: vitthalmagadum
body: ```suggestion
class VerifyRedundencyMode(AntaTest):
```
created_at: 2025-05-13T08:13:08Z
author_association: CONTRIBUTOR
diff_hunk: @@ -269,3 +269,43 @@ def test(self) -> None:
         total_adverse_drop = command_output.get("totalAdverseDrops", "")
         if total_adverse_drop != 0:
             self.result.is_failure(f"Incorrect total adverse drops counter - Expected: 0 Actual: {total_adverse_drop}")
+
+
+class VerifyredundencySso(AntaTest):
+    """Verifies that the redundancy SSO is enabled.
+
+    Expected Results
+    ----------------
+    * Success: The test will pass if redundancy protocol SSO is configured and operational and switchover is ready.
+    * Failure: The test will fail if the redundancy protocol SSO is not configured, not operational, or switchover is not ready.
+    * Skipped: The test will be skipped if the peer supervisor card is not inserted.
+
+    Examples
+    --------
+    ```yaml
+    anta.tests.hardware:
+      - VerifyredundencySso:
path: anta/tests/hardware.py
user: login: vitthalmagadum
body: We may support multiple redundancy modes.
created_at: 2025-05-13T08:20:53Z
author_association: CONTRIBUTOR
diff_hunk: @@ -269,3 +269,43 @@ def test(self) -> None:
         total_adverse_drop = command_output.get("totalAdverseDrops", "")
         if total_adverse_drop != 0:
             self.result.is_failure(f"Incorrect total adverse drops counter - Expected: 0 Actual: {total_adverse_drop}")
+
+
+class VerifyredundencySso(AntaTest):
path: anta/tests/hardware.py
user: login: vitthalmagadum
body: Take ref from other comment
created_at: 2025-05-13T08:21:42Z
author_association: CONTRIBUTOR
diff_hunk: @@ -269,3 +269,53 @@ def test(self) -> None:
         total_adverse_drop = command_output.get("totalAdverseDrops", "")
         if total_adverse_drop != 0:
             self.result.is_failure(f"Incorrect total adverse drops counter - Expected: 0 Actual: {total_adverse_drop}")
+
+
+class VerifyRedundancyProto(AntaTest):
path: anta/tests/hardware.py
user: login: carl-baillargeon
body: ```suggestion
class VerifySupervisorRedundancy(AntaTest):
```
created_at: 2025-05-13T17:33:33Z
author_association: CONTRIBUTOR
diff_hunk: @@ -269,3 +269,53 @@ def test(self) -> None:
         total_adverse_drop = command_output.get("totalAdverseDrops", "")
         if total_adverse_drop != 0:
             self.result.is_failure(f"Incorrect total adverse drops counter - Expected: 0 Actual: {total_adverse_drop}")
+
+
+class VerifyRedundancyProto(AntaTest):
+    """Verifies that the redundancy protocol status.
path: anta/tests/hardware.py
user: login: carl-baillargeon
body: ```suggestion
    """Verifies the redundancy protocol configured on the active supervisor.
```
created_at: 2025-05-13T17:36:27Z
author_association: CONTRIBUTOR
diff_hunk: @@ -269,3 +269,53 @@ def test(self) -> None:
         total_adverse_drop = command_output.get("totalAdverseDrops", "")
         if total_adverse_drop != 0:
             self.result.is_failure(f"Incorrect total adverse drops counter - Expected: 0 Actual: {total_adverse_drop}")
+
+
+class VerifyRedundancyProto(AntaTest):
+    """Verifies that the redundancy protocol status.
+
+    Expected Results
+    ----------------
+    * Success: The test will pass if the expected redundancy protocol is configured and operational, and if switchover is ready.
+    * Failure: The test will fail if the expected redundancy protocol is not configured, not operational, or if switchover is not ready.
+    * Skipped: The test will be skipped if the peer supervisor card is not inserted.
+
+    Examples
+    --------
+    ```yaml
+    anta.tests.hardware:
+      - VerifyRedundancyProto:
path: anta/tests/hardware.py
user: login: carl-baillargeon
body: ```suggestion
      - VerifySupervisorRedundancy:
```
created_at: 2025-05-13T17:37:19Z
author_association: CONTRIBUTOR
diff_hunk: @@ -269,3 +269,53 @@ def test(self) -> None:
         total_adverse_drop = command_output.get("totalAdverseDrops", "")
         if total_adverse_drop != 0:
             self.result.is_failure(f"Incorrect total adverse drops counter - Expected: 0 Actual: {total_adverse_drop}")
+
+
+class VerifyRedundancyProto(AntaTest):
+    """Verifies that the redundancy protocol status.
+
+    Expected Results
+    ----------------
+    * Success: The test will pass if the expected redundancy protocol is configured and operational, and if switchover is ready.
+    * Failure: The test will fail if the expected redundancy protocol is not configured, not operational, or if switchover is not ready.
+    * Skipped: The test will be skipped if the peer supervisor card is not inserted.
+
+    Examples
+    --------
+    ```yaml
+    anta.tests.hardware:
+      - VerifyRedundancyProto:
+    ```
+    """
+
+    categories: ClassVar[list[str]] = ["hardware"]
+    commands: ClassVar[list[AntaCommand | AntaTemplate]] = [AntaCommand(command="show redundancy status", revision=1)]
+
+    class Input(AntaTest.Input):
+        """Input model for the VerifyRedundancyProto test."""
+
+        redundency_proto: Literal["unknownProtocol", "sso", "rpr", "simplex"] = "sso"
path: anta/tests/hardware.py
user: login: carl-baillargeon
body: ```suggestion
        redundancy_protocol: Literal["sso", "rpr", "simplex"] = "sso"
```
created_at: 2025-05-13T17:38:15Z
author_association: CONTRIBUTOR
diff_hunk: @@ -269,3 +269,53 @@ def test(self) -> None:
         total_adverse_drop = command_output.get("totalAdverseDrops", "")
         if total_adverse_drop != 0:
             self.result.is_failure(f"Incorrect total adverse drops counter - Expected: 0 Actual: {total_adverse_drop}")
+
+
+class VerifyRedundancyProto(AntaTest):
+    """Verifies that the redundancy protocol status.
+
+    Expected Results
+    ----------------
+    * Success: The test will pass if the expected redundancy protocol is configured and operational, and if switchover is ready.
+    * Failure: The test will fail if the expected redundancy protocol is not configured, not operational, or if switchover is not ready.
+    * Skipped: The test will be skipped if the peer supervisor card is not inserted.
+
+    Examples
+    --------
+    ```yaml
+    anta.tests.hardware:
+      - VerifyRedundancyProto:
+    ```
+    """
+
+    categories: ClassVar[list[str]] = ["hardware"]
+    commands: ClassVar[list[AntaCommand | AntaTemplate]] = [AntaCommand(command="show redundancy status", revision=1)]
+
+    class Input(AntaTest.Input):
+        """Input model for the VerifyRedundancyProto test."""
path: anta/tests/hardware.py
user: login: carl-baillargeon
body: ```suggestion
        """Input model for the VerifySupervisorRedundancy test."""
```
created_at: 2025-05-13T17:38:32Z
author_association: CONTRIBUTOR
diff_hunk: @@ -269,3 +269,53 @@ def test(self) -> None:
         total_adverse_drop = command_output.get("totalAdverseDrops", "")
         if total_adverse_drop != 0:
             self.result.is_failure(f"Incorrect total adverse drops counter - Expected: 0 Actual: {total_adverse_drop}")
+
+
+class VerifyRedundancyProto(AntaTest):
+    """Verifies that the redundancy protocol status.
+
+    Expected Results
+    ----------------
+    * Success: The test will pass if the expected redundancy protocol is configured and operational, and if switchover is ready.
+    * Failure: The test will fail if the expected redundancy protocol is not configured, not operational, or if switchover is not ready.
+    * Skipped: The test will be skipped if the peer supervisor card is not inserted.
+
+    Examples
+    --------
+    ```yaml
+    anta.tests.hardware:
+      - VerifyRedundancyProto:
+    ```
+    """
+
+    categories: ClassVar[list[str]] = ["hardware"]
+    commands: ClassVar[list[AntaCommand | AntaTemplate]] = [AntaCommand(command="show redundancy status", revision=1)]
+
+    class Input(AntaTest.Input):
+        """Input model for the VerifyRedundancyProto test."""
+
+        redundency_proto: Literal["unknownProtocol", "sso", "rpr", "simplex"] = "sso"
+        """Configured redundancy protocol."""
+
+    @skip_on_platforms(["cEOSLab", "vEOS-lab", "cEOSCloudLab", "vEOS"])
+    @AntaTest.anta_test
+    def test(self) -> None:
+        """Main test function for VerifyRedundancyProto."""
path: anta/tests/hardware.py
user: login: carl-baillargeon
body: ```suggestion
        """Main test function for VerifySupervisorRedundancy."""
```
created_at: 2025-05-13T17:38:49Z
author_association: CONTRIBUTOR
diff_hunk: @@ -269,3 +269,53 @@ def test(self) -> None:
         total_adverse_drop = command_output.get("totalAdverseDrops", "")
         if total_adverse_drop != 0:
             self.result.is_failure(f"Incorrect total adverse drops counter - Expected: 0 Actual: {total_adverse_drop}")
+
+
+class VerifyRedundancyProto(AntaTest):
+    """Verifies that the redundancy protocol status.
+
+    Expected Results
+    ----------------
+    * Success: The test will pass if the expected redundancy protocol is configured and operational, and if switchover is ready.
+    * Failure: The test will fail if the expected redundancy protocol is not configured, not operational, or if switchover is not ready.
+    * Skipped: The test will be skipped if the peer supervisor card is not inserted.
+
+    Examples
+    --------
+    ```yaml
+    anta.tests.hardware:
+      - VerifyRedundancyProto:
+    ```
+    """
+
+    categories: ClassVar[list[str]] = ["hardware"]
+    commands: ClassVar[list[AntaCommand | AntaTemplate]] = [AntaCommand(command="show redundancy status", revision=1)]
+
+    class Input(AntaTest.Input):
+        """Input model for the VerifyRedundancyProto test."""
+
+        redundency_proto: Literal["unknownProtocol", "sso", "rpr", "simplex"] = "sso"
+        """Configured redundancy protocol."""
+
+    @skip_on_platforms(["cEOSLab", "vEOS-lab", "cEOSCloudLab", "vEOS"])
+    @AntaTest.anta_test
+    def test(self) -> None:
+        """Main test function for VerifyRedundancyProto."""
+        self.result.is_success()
+        command_output = self.instance_commands[0].json_output
+
+        # Verify peer supervisor card insertion
+        if command_output["peerState"] == "notInserted":
+            self.result.is_skipped("Peer supervisor card not inserted")
path: anta/tests/hardware.py
user: login: carl-baillargeon
body: ```suggestion
        if command_output["peerState"] == "notInserted":
            self.result.is_skipped("Peer supervisor card not inserted")
            return
```
created_at: 2025-05-13T17:42:15Z
author_association: CONTRIBUTOR
diff_hunk: @@ -269,3 +269,53 @@ def test(self) -> None:
         total_adverse_drop = command_output.get("totalAdverseDrops", "")
         if total_adverse_drop != 0:
             self.result.is_failure(f"Incorrect total adverse drops counter - Expected: 0 Actual: {total_adverse_drop}")
+
+
+class VerifyRedundancyProto(AntaTest):
+    """Verifies that the redundancy protocol status.
+
+    Expected Results
+    ----------------
+    * Success: The test will pass if the expected redundancy protocol is configured and operational, and if switchover is ready.
+    * Failure: The test will fail if the expected redundancy protocol is not configured, not operational, or if switchover is not ready.
+    * Skipped: The test will be skipped if the peer supervisor card is not inserted.
+
+    Examples
+    --------
+    ```yaml
+    anta.tests.hardware:
+      - VerifyRedundancyProto:
+    ```
+    """
+
+    categories: ClassVar[list[str]] = ["hardware"]
+    commands: ClassVar[list[AntaCommand | AntaTemplate]] = [AntaCommand(command="show redundancy status", revision=1)]
+
+    class Input(AntaTest.Input):
+        """Input model for the VerifyRedundancyProto test."""
+
+        redundency_proto: Literal["unknownProtocol", "sso", "rpr", "simplex"] = "sso"
+        """Configured redundancy protocol."""
+
+    @skip_on_platforms(["cEOSLab", "vEOS-lab", "cEOSCloudLab", "vEOS"])
+    @AntaTest.anta_test
+    def test(self) -> None:
+        """Main test function for VerifyRedundancyProto."""
+        self.result.is_success()
+        command_output = self.instance_commands[0].json_output
+
+        # Verify peer supervisor card insertion
+        if command_output["peerState"] == "notInserted":
+            self.result.is_skipped("Peer supervisor card not inserted")
+
+        # Verify that the expected redundancy protocol is configured.
+        elif command_output["configuredProtocol"] != self.inputs.redundency_proto:
+            self.result.is_failure(f"Redundancy protocol {self.inputs.redundency_proto} not configured")
path: anta/tests/hardware.py
user: login: carl-baillargeon
body: We should follow the other test failure messages. Something like `Actual: simplex Expected: sso`...
created_at: 2025-05-13T17:47:42Z
author_association: CONTRIBUTOR
diff_hunk: @@ -269,3 +269,53 @@ def test(self) -> None:
         total_adverse_drop = command_output.get("totalAdverseDrops", "")
         if total_adverse_drop != 0:
             self.result.is_failure(f"Incorrect total adverse drops counter - Expected: 0 Actual: {total_adverse_drop}")
+
+
+class VerifyRedundancyProto(AntaTest):
+    """Verifies that the redundancy protocol status.
+
+    Expected Results
+    ----------------
+    * Success: The test will pass if the expected redundancy protocol is configured and operational, and if switchover is ready.
+    * Failure: The test will fail if the expected redundancy protocol is not configured, not operational, or if switchover is not ready.
+    * Skipped: The test will be skipped if the peer supervisor card is not inserted.
+
+    Examples
+    --------
+    ```yaml
+    anta.tests.hardware:
+      - VerifyRedundancyProto:
+    ```
+    """
+
+    categories: ClassVar[list[str]] = ["hardware"]
+    commands: ClassVar[list[AntaCommand | AntaTemplate]] = [AntaCommand(command="show redundancy status", revision=1)]
+
+    class Input(AntaTest.Input):
+        """Input model for the VerifyRedundancyProto test."""
+
+        redundency_proto: Literal["unknownProtocol", "sso", "rpr", "simplex"] = "sso"
+        """Configured redundancy protocol."""
+
+    @skip_on_platforms(["cEOSLab", "vEOS-lab", "cEOSCloudLab", "vEOS"])
+    @AntaTest.anta_test
+    def test(self) -> None:
+        """Main test function for VerifyRedundancyProto."""
+        self.result.is_success()
+        command_output = self.instance_commands[0].json_output
+
+        # Verify peer supervisor card insertion
+        if command_output["peerState"] == "notInserted":
+            self.result.is_skipped("Peer supervisor card not inserted")
+
+        # Verify that the expected redundancy protocol is configured.
+        elif command_output["configuredProtocol"] != self.inputs.redundency_proto:
path: anta/tests/hardware.py
user: login: carl-baillargeon
body: ```suggestion
        if command_output["configuredProtocol"] != self.inputs.redundency_proto:
```
created_at: 2025-05-13T17:47:49Z
author_association: CONTRIBUTOR
diff_hunk: @@ -269,3 +269,53 @@ def test(self) -> None:
         total_adverse_drop = command_output.get("totalAdverseDrops", "")
         if total_adverse_drop != 0:
             self.result.is_failure(f"Incorrect total adverse drops counter - Expected: 0 Actual: {total_adverse_drop}")
+
+
+class VerifyRedundancyProto(AntaTest):
+    """Verifies that the redundancy protocol status.
+
+    Expected Results
+    ----------------
+    * Success: The test will pass if the expected redundancy protocol is configured and operational, and if switchover is ready.
+    * Failure: The test will fail if the expected redundancy protocol is not configured, not operational, or if switchover is not ready.
+    * Skipped: The test will be skipped if the peer supervisor card is not inserted.
+
+    Examples
+    --------
+    ```yaml
+    anta.tests.hardware:
+      - VerifyRedundancyProto:
+    ```
+    """
+
+    categories: ClassVar[list[str]] = ["hardware"]
+    commands: ClassVar[list[AntaCommand | AntaTemplate]] = [AntaCommand(command="show redundancy status", revision=1)]
+
+    class Input(AntaTest.Input):
+        """Input model for the VerifyRedundancyProto test."""
+
+        redundency_proto: Literal["unknownProtocol", "sso", "rpr", "simplex"] = "sso"
+        """Configured redundancy protocol."""
+
+    @skip_on_platforms(["cEOSLab", "vEOS-lab", "cEOSCloudLab", "vEOS"])
+    @AntaTest.anta_test
+    def test(self) -> None:
+        """Main test function for VerifyRedundancyProto."""
+        self.result.is_success()
+        command_output = self.instance_commands[0].json_output
+
+        # Verify peer supervisor card insertion
+        if command_output["peerState"] == "notInserted":
+            self.result.is_skipped("Peer supervisor card not inserted")
+
+        # Verify that the expected redundancy protocol is configured.
+        elif command_output["configuredProtocol"] != self.inputs.redundency_proto:
+            self.result.is_failure(f"Redundancy protocol {self.inputs.redundency_proto} not configured")
+
+        # Verify that the expected redundancy protocol configured and operational
+        elif command_output["operationalProtocol"] != self.inputs.redundency_proto:
+            self.result.is_failure(f"Redundancy protocol {self.inputs.redundency_proto} configured but not operational")
path: anta/tests/hardware.py
user: login: carl-baillargeon
body: Same here we should know which redundancy protocol is actually operational.
created_at: 2025-05-13T17:50:33Z
author_association: CONTRIBUTOR
diff_hunk: @@ -269,3 +269,53 @@ def test(self) -> None:
         total_adverse_drop = command_output.get("totalAdverseDrops", "")
         if total_adverse_drop != 0:
             self.result.is_failure(f"Incorrect total adverse drops counter - Expected: 0 Actual: {total_adverse_drop}")
+
+
+class VerifyRedundancyProto(AntaTest):
+    """Verifies that the redundancy protocol status.
+
+    Expected Results
+    ----------------
+    * Success: The test will pass if the expected redundancy protocol is configured and operational, and if switchover is ready.
+    * Failure: The test will fail if the expected redundancy protocol is not configured, not operational, or if switchover is not ready.
+    * Skipped: The test will be skipped if the peer supervisor card is not inserted.
+
+    Examples
+    --------
+    ```yaml
+    anta.tests.hardware:
+      - VerifyRedundancyProto:
+    ```
+    """
+
+    categories: ClassVar[list[str]] = ["hardware"]
+    commands: ClassVar[list[AntaCommand | AntaTemplate]] = [AntaCommand(command="show redundancy status", revision=1)]
+
+    class Input(AntaTest.Input):
+        """Input model for the VerifyRedundancyProto test."""
+
+        redundency_proto: Literal["unknownProtocol", "sso", "rpr", "simplex"] = "sso"
+        """Configured redundancy protocol."""
+
+    @skip_on_platforms(["cEOSLab", "vEOS-lab", "cEOSCloudLab", "vEOS"])
+    @AntaTest.anta_test
+    def test(self) -> None:
+        """Main test function for VerifyRedundancyProto."""
+        self.result.is_success()
+        command_output = self.instance_commands[0].json_output
+
+        # Verify peer supervisor card insertion
+        if command_output["peerState"] == "notInserted":
+            self.result.is_skipped("Peer supervisor card not inserted")
+
+        # Verify that the expected redundancy protocol is configured.
+        elif command_output["configuredProtocol"] != self.inputs.redundency_proto:
+            self.result.is_failure(f"Redundancy protocol {self.inputs.redundency_proto} not configured")
+
+        # Verify that the expected redundancy protocol configured and operational
path: anta/tests/hardware.py
user: login: carl-baillargeon
body: If you use `is`, please use it everywhere for consistency. Same thing for periods `.`.
```suggestion
        # Verify that the expected redundancy protocol is configured and operational.
```
created_at: 2025-05-13T17:52:28Z
author_association: CONTRIBUTOR
diff_hunk: @@ -269,3 +269,53 @@ def test(self) -> None:
         total_adverse_drop = command_output.get("totalAdverseDrops", "")
         if total_adverse_drop != 0:
             self.result.is_failure(f"Incorrect total adverse drops counter - Expected: 0 Actual: {total_adverse_drop}")
+
+
+class VerifyRedundancyProto(AntaTest):
+    """Verifies that the redundancy protocol status.
+
+    Expected Results
+    ----------------
+    * Success: The test will pass if the expected redundancy protocol is configured and operational, and if switchover is ready.
+    * Failure: The test will fail if the expected redundancy protocol is not configured, not operational, or if switchover is not ready.
+    * Skipped: The test will be skipped if the peer supervisor card is not inserted.
+
+    Examples
+    --------
+    ```yaml
+    anta.tests.hardware:
+      - VerifyRedundancyProto:
+    ```
+    """
+
+    categories: ClassVar[list[str]] = ["hardware"]
+    commands: ClassVar[list[AntaCommand | AntaTemplate]] = [AntaCommand(command="show redundancy status", revision=1)]
+
+    class Input(AntaTest.Input):
+        """Input model for the VerifyRedundancyProto test."""
+
+        redundency_proto: Literal["unknownProtocol", "sso", "rpr", "simplex"] = "sso"
+        """Configured redundancy protocol."""
+
+    @skip_on_platforms(["cEOSLab", "vEOS-lab", "cEOSCloudLab", "vEOS"])
+    @AntaTest.anta_test
+    def test(self) -> None:
+        """Main test function for VerifyRedundancyProto."""
+        self.result.is_success()
+        command_output = self.instance_commands[0].json_output
+
+        # Verify peer supervisor card insertion
+        if command_output["peerState"] == "notInserted":
+            self.result.is_skipped("Peer supervisor card not inserted")
+
+        # Verify that the expected redundancy protocol is configured.
+        elif command_output["configuredProtocol"] != self.inputs.redundency_proto:
+            self.result.is_failure(f"Redundancy protocol {self.inputs.redundency_proto} not configured")
+
+        # Verify that the expected redundancy protocol configured and operational
+        elif command_output["operationalProtocol"] != self.inputs.redundency_proto:
+            self.result.is_failure(f"Redundancy protocol {self.inputs.redundency_proto} configured but not operational")
+
+        # Verify that the expected redundancy protocol configured, operational and switchover is ready
path: anta/tests/hardware.py
user: login: carl-baillargeon
body: ```suggestion
        # Verify that the expected redundancy protocol is configured, operational and switchover is ready.
```
created_at: 2025-05-13T17:53:34Z
author_association: CONTRIBUTOR
diff_hunk: @@ -269,3 +269,53 @@ def test(self) -> None:
         total_adverse_drop = command_output.get("totalAdverseDrops", "")
         if total_adverse_drop != 0:
             self.result.is_failure(f"Incorrect total adverse drops counter - Expected: 0 Actual: {total_adverse_drop}")
+
+
+class VerifyRedundancyProto(AntaTest):
+    """Verifies that the redundancy protocol status.
+
+    Expected Results
+    ----------------
+    * Success: The test will pass if the expected redundancy protocol is configured and operational, and if switchover is ready.
+    * Failure: The test will fail if the expected redundancy protocol is not configured, not operational, or if switchover is not ready.
+    * Skipped: The test will be skipped if the peer supervisor card is not inserted.
+
+    Examples
+    --------
+    ```yaml
+    anta.tests.hardware:
+      - VerifyRedundancyProto:
+    ```
+    """
+
+    categories: ClassVar[list[str]] = ["hardware"]
+    commands: ClassVar[list[AntaCommand | AntaTemplate]] = [AntaCommand(command="show redundancy status", revision=1)]
+
+    class Input(AntaTest.Input):
+        """Input model for the VerifyRedundancyProto test."""
+
+        redundency_proto: Literal["unknownProtocol", "sso", "rpr", "simplex"] = "sso"
+        """Configured redundancy protocol."""
+
+    @skip_on_platforms(["cEOSLab", "vEOS-lab", "cEOSCloudLab", "vEOS"])
+    @AntaTest.anta_test
+    def test(self) -> None:
+        """Main test function for VerifyRedundancyProto."""
+        self.result.is_success()
+        command_output = self.instance_commands[0].json_output
+
+        # Verify peer supervisor card insertion
+        if command_output["peerState"] == "notInserted":
+            self.result.is_skipped("Peer supervisor card not inserted")
+
+        # Verify that the expected redundancy protocol is configured.
+        elif command_output["configuredProtocol"] != self.inputs.redundency_proto:
+            self.result.is_failure(f"Redundancy protocol {self.inputs.redundency_proto} not configured")
+
+        # Verify that the expected redundancy protocol configured and operational
+        elif command_output["operationalProtocol"] != self.inputs.redundency_proto:
+            self.result.is_failure(f"Redundancy protocol {self.inputs.redundency_proto} configured but not operational")
+
+        # Verify that the expected redundancy protocol configured, operational and switchover is ready
+        elif not command_output["switchoverReady"]:
+            self.result.is_failure(f"Redundancy protocol {self.inputs.redundency_proto} is configured and operational but switchover is not ready")
path: anta/tests/hardware.py
user: login: carl-baillargeon
body: Here you are using `is configured` :)
created_at: 2025-05-13T17:55:15Z
author_association: CONTRIBUTOR
diff_hunk: @@ -269,3 +269,53 @@ def test(self) -> None:
         total_adverse_drop = command_output.get("totalAdverseDrops", "")
         if total_adverse_drop != 0:
             self.result.is_failure(f"Incorrect total adverse drops counter - Expected: 0 Actual: {total_adverse_drop}")
+
+
+class VerifyRedundancyProto(AntaTest):
+    """Verifies that the redundancy protocol status.
+
+    Expected Results
+    ----------------
+    * Success: The test will pass if the expected redundancy protocol is configured and operational, and if switchover is ready.
+    * Failure: The test will fail if the expected redundancy protocol is not configured, not operational, or if switchover is not ready.
+    * Skipped: The test will be skipped if the peer supervisor card is not inserted.
+
+    Examples
+    --------
+    ```yaml
+    anta.tests.hardware:
+      - VerifyRedundancyProto:
+    ```
+    """
+
+    categories: ClassVar[list[str]] = ["hardware"]
+    commands: ClassVar[list[AntaCommand | AntaTemplate]] = [AntaCommand(command="show redundancy status", revision=1)]
+
+    class Input(AntaTest.Input):
+        """Input model for the VerifyRedundancyProto test."""
+
+        redundency_proto: Literal["unknownProtocol", "sso", "rpr", "simplex"] = "sso"
+        """Configured redundancy protocol."""
+
+    @skip_on_platforms(["cEOSLab", "vEOS-lab", "cEOSCloudLab", "vEOS"])
+    @AntaTest.anta_test
+    def test(self) -> None:
+        """Main test function for VerifyRedundancyProto."""
path: anta/tests/hardware.py
user: login: geetanjalimanegslab
body: Updated Thanks!
created_at: 2025-05-14T07:05:45Z
author_association: CONTRIBUTOR
diff_hunk: @@ -269,3 +269,53 @@ def test(self) -> None:
         total_adverse_drop = command_output.get("totalAdverseDrops", "")
         if total_adverse_drop != 0:
             self.result.is_failure(f"Incorrect total adverse drops counter - Expected: 0 Actual: {total_adverse_drop}")
+
+
+class VerifyRedundancyProto(AntaTest):
+    """Verifies that the redundancy protocol status.
+
+    Expected Results
+    ----------------
+    * Success: The test will pass if the expected redundancy protocol is configured and operational, and if switchover is ready.
+    * Failure: The test will fail if the expected redundancy protocol is not configured, not operational, or if switchover is not ready.
+    * Skipped: The test will be skipped if the peer supervisor card is not inserted.
+
+    Examples
+    --------
+    ```yaml
+    anta.tests.hardware:
+      - VerifyRedundancyProto:
+    ```
+    """
+
+    categories: ClassVar[list[str]] = ["hardware"]
+    commands: ClassVar[list[AntaCommand | AntaTemplate]] = [AntaCommand(command="show redundancy status", revision=1)]
+
+    class Input(AntaTest.Input):
+        """Input model for the VerifyRedundancyProto test."""
path: anta/tests/hardware.py
user: login: geetanjalimanegslab
body: Updated Thanks!
created_at: 2025-05-14T07:05:46Z
author_association: CONTRIBUTOR
diff_hunk: @@ -269,3 +269,53 @@ def test(self) -> None:
         total_adverse_drop = command_output.get("totalAdverseDrops", "")
         if total_adverse_drop != 0:
             self.result.is_failure(f"Incorrect total adverse drops counter - Expected: 0 Actual: {total_adverse_drop}")
+
+
+class VerifyRedundancyProto(AntaTest):
+    """Verifies that the redundancy protocol status.
+
+    Expected Results
+    ----------------
+    * Success: The test will pass if the expected redundancy protocol is configured and operational, and if switchover is ready.
+    * Failure: The test will fail if the expected redundancy protocol is not configured, not operational, or if switchover is not ready.
+    * Skipped: The test will be skipped if the peer supervisor card is not inserted.
+
+    Examples
+    --------
+    ```yaml
+    anta.tests.hardware:
+      - VerifyRedundancyProto:
path: anta/tests/hardware.py
user: login: geetanjalimanegslab
body: Updated Thanks!
created_at: 2025-05-14T07:05:53Z
author_association: CONTRIBUTOR
diff_hunk: @@ -269,3 +269,53 @@ def test(self) -> None:
         total_adverse_drop = command_output.get("totalAdverseDrops", "")
         if total_adverse_drop != 0:
             self.result.is_failure(f"Incorrect total adverse drops counter - Expected: 0 Actual: {total_adverse_drop}")
+
+
+class VerifyRedundancyProto(AntaTest):
+    """Verifies that the redundancy protocol status.
+
+    Expected Results
+    ----------------
+    * Success: The test will pass if the expected redundancy protocol is configured and operational, and if switchover is ready.
+    * Failure: The test will fail if the expected redundancy protocol is not configured, not operational, or if switchover is not ready.
+    * Skipped: The test will be skipped if the peer supervisor card is not inserted.
+
+    Examples
+    --------
+    ```yaml
+    anta.tests.hardware:
+      - VerifyRedundancyProto:
+    ```
+    """
+
+    categories: ClassVar[list[str]] = ["hardware"]
+    commands: ClassVar[list[AntaCommand | AntaTemplate]] = [AntaCommand(command="show redundancy status", revision=1)]
+
+    class Input(AntaTest.Input):
+        """Input model for the VerifyRedundancyProto test."""
+
+        redundency_proto: Literal["unknownProtocol", "sso", "rpr", "simplex"] = "sso"
path: anta/tests/hardware.py
user: login: geetanjalimanegslab
body: Updated Thanks!
created_at: 2025-05-14T07:05:55Z
author_association: CONTRIBUTOR
diff_hunk: @@ -269,3 +269,53 @@ def test(self) -> None:
         total_adverse_drop = command_output.get("totalAdverseDrops", "")
         if total_adverse_drop != 0:
             self.result.is_failure(f"Incorrect total adverse drops counter - Expected: 0 Actual: {total_adverse_drop}")
+
+
+class VerifyRedundancyProto(AntaTest):
+    """Verifies that the redundancy protocol status.
path: anta/tests/hardware.py
user: login: geetanjalimanegslab
body: Updated Thanks!
created_at: 2025-05-14T07:05:57Z
author_association: CONTRIBUTOR
diff_hunk: @@ -269,3 +269,53 @@ def test(self) -> None:
         total_adverse_drop = command_output.get("totalAdverseDrops", "")
         if total_adverse_drop != 0:
             self.result.is_failure(f"Incorrect total adverse drops counter - Expected: 0 Actual: {total_adverse_drop}")
+
+
+class VerifyRedundancyProto(AntaTest):
path: anta/tests/hardware.py
user: login: geetanjalimanegslab
body: Updated Thanks!
created_at: 2025-05-14T07:06:08Z
author_association: CONTRIBUTOR
diff_hunk: @@ -269,3 +269,53 @@ def test(self) -> None:
         total_adverse_drop = command_output.get("totalAdverseDrops", "")
         if total_adverse_drop != 0:
             self.result.is_failure(f"Incorrect total adverse drops counter - Expected: 0 Actual: {total_adverse_drop}")
+
+
+class VerifyRedundancyProto(AntaTest):
+    """Verifies that the redundancy protocol status.
+
+    Expected Results
+    ----------------
+    * Success: The test will pass if the expected redundancy protocol is configured and operational, and if switchover is ready.
+    * Failure: The test will fail if the expected redundancy protocol is not configured, not operational, or if switchover is not ready.
+    * Skipped: The test will be skipped if the peer supervisor card is not inserted.
+
+    Examples
+    --------
+    ```yaml
+    anta.tests.hardware:
+      - VerifyRedundancyProto:
+    ```
+    """
+
+    categories: ClassVar[list[str]] = ["hardware"]
+    commands: ClassVar[list[AntaCommand | AntaTemplate]] = [AntaCommand(command="show redundancy status", revision=1)]
+
+    class Input(AntaTest.Input):
+        """Input model for the VerifyRedundancyProto test."""
+
+        redundency_proto: Literal["unknownProtocol", "sso", "rpr", "simplex"] = "sso"
+        """Configured redundancy protocol."""
+
+    @skip_on_platforms(["cEOSLab", "vEOS-lab", "cEOSCloudLab", "vEOS"])
+    @AntaTest.anta_test
+    def test(self) -> None:
+        """Main test function for VerifyRedundancyProto."""
+        self.result.is_success()
+        command_output = self.instance_commands[0].json_output
+
+        # Verify peer supervisor card insertion
+        if command_output["peerState"] == "notInserted":
+            self.result.is_skipped("Peer supervisor card not inserted")
path: anta/tests/hardware.py
user: login: geetanjalimanegslab
body: Updated thanks!
created_at: 2025-05-14T07:17:52Z
author_association: CONTRIBUTOR
diff_hunk: @@ -269,3 +269,53 @@ def test(self) -> None:
         total_adverse_drop = command_output.get("totalAdverseDrops", "")
         if total_adverse_drop != 0:
             self.result.is_failure(f"Incorrect total adverse drops counter - Expected: 0 Actual: {total_adverse_drop}")
+
+
+class VerifyRedundancyProto(AntaTest):
+    """Verifies that the redundancy protocol status.
+
+    Expected Results
+    ----------------
+    * Success: The test will pass if the expected redundancy protocol is configured and operational, and if switchover is ready.
+    * Failure: The test will fail if the expected redundancy protocol is not configured, not operational, or if switchover is not ready.
+    * Skipped: The test will be skipped if the peer supervisor card is not inserted.
+
+    Examples
+    --------
+    ```yaml
+    anta.tests.hardware:
+      - VerifyRedundancyProto:
+    ```
+    """
+
+    categories: ClassVar[list[str]] = ["hardware"]
+    commands: ClassVar[list[AntaCommand | AntaTemplate]] = [AntaCommand(command="show redundancy status", revision=1)]
+
+    class Input(AntaTest.Input):
+        """Input model for the VerifyRedundancyProto test."""
+
+        redundency_proto: Literal["unknownProtocol", "sso", "rpr", "simplex"] = "sso"
+        """Configured redundancy protocol."""
+
+    @skip_on_platforms(["cEOSLab", "vEOS-lab", "cEOSCloudLab", "vEOS"])
+    @AntaTest.anta_test
+    def test(self) -> None:
+        """Main test function for VerifyRedundancyProto."""
+        self.result.is_success()
+        command_output = self.instance_commands[0].json_output
+
+        # Verify peer supervisor card insertion
+        if command_output["peerState"] == "notInserted":
+            self.result.is_skipped("Peer supervisor card not inserted")
+
+        # Verify that the expected redundancy protocol is configured.
+        elif command_output["configuredProtocol"] != self.inputs.redundency_proto:
+            self.result.is_failure(f"Redundancy protocol {self.inputs.redundency_proto} not configured")
+
+        # Verify that the expected redundancy protocol configured and operational
path: anta/tests/hardware.py
user: login: geetanjalimanegslab
body: Thanks for the suggestion, Carl. You're right, other test cases don't use "is" or end with a period in comments, so we're removing them here too.
created_at: 2025-05-14T07:19:21Z
author_association: CONTRIBUTOR
diff_hunk: @@ -269,3 +269,53 @@ def test(self) -> None:
         total_adverse_drop = command_output.get("totalAdverseDrops", "")
         if total_adverse_drop != 0:
             self.result.is_failure(f"Incorrect total adverse drops counter - Expected: 0 Actual: {total_adverse_drop}")
+
+
+class VerifyRedundancyProto(AntaTest):
+    """Verifies that the redundancy protocol status.
+
+    Expected Results
+    ----------------
+    * Success: The test will pass if the expected redundancy protocol is configured and operational, and if switchover is ready.
+    * Failure: The test will fail if the expected redundancy protocol is not configured, not operational, or if switchover is not ready.
+    * Skipped: The test will be skipped if the peer supervisor card is not inserted.
+
+    Examples
+    --------
+    ```yaml
+    anta.tests.hardware:
+      - VerifyRedundancyProto:
+    ```
+    """
+
+    categories: ClassVar[list[str]] = ["hardware"]
+    commands: ClassVar[list[AntaCommand | AntaTemplate]] = [AntaCommand(command="show redundancy status", revision=1)]
+
+    class Input(AntaTest.Input):
+        """Input model for the VerifyRedundancyProto test."""
+
+        redundency_proto: Literal["unknownProtocol", "sso", "rpr", "simplex"] = "sso"
+        """Configured redundancy protocol."""
+
+    @skip_on_platforms(["cEOSLab", "vEOS-lab", "cEOSCloudLab", "vEOS"])
+    @AntaTest.anta_test
+    def test(self) -> None:
+        """Main test function for VerifyRedundancyProto."""
+        self.result.is_success()
+        command_output = self.instance_commands[0].json_output
+
+        # Verify peer supervisor card insertion
+        if command_output["peerState"] == "notInserted":
+            self.result.is_skipped("Peer supervisor card not inserted")
+
+        # Verify that the expected redundancy protocol is configured.
+        elif command_output["configuredProtocol"] != self.inputs.redundency_proto:
+            self.result.is_failure(f"Redundancy protocol {self.inputs.redundency_proto} not configured")
+
+        # Verify that the expected redundancy protocol configured and operational
+        elif command_output["operationalProtocol"] != self.inputs.redundency_proto:
+            self.result.is_failure(f"Redundancy protocol {self.inputs.redundency_proto} configured but not operational")
path: anta/tests/hardware.py
user: login: geetanjalimanegslab
body: Sure, updated thanks!
created_at: 2025-05-14T07:19:40Z
author_association: CONTRIBUTOR
diff_hunk: @@ -269,3 +269,53 @@ def test(self) -> None:
         total_adverse_drop = command_output.get("totalAdverseDrops", "")
         if total_adverse_drop != 0:
             self.result.is_failure(f"Incorrect total adverse drops counter - Expected: 0 Actual: {total_adverse_drop}")
+
+
+class VerifyRedundancyProto(AntaTest):
+    """Verifies that the redundancy protocol status.
+
+    Expected Results
+    ----------------
+    * Success: The test will pass if the expected redundancy protocol is configured and operational, and if switchover is ready.
+    * Failure: The test will fail if the expected redundancy protocol is not configured, not operational, or if switchover is not ready.
+    * Skipped: The test will be skipped if the peer supervisor card is not inserted.
+
+    Examples
+    --------
+    ```yaml
+    anta.tests.hardware:
+      - VerifyRedundancyProto:
+    ```
+    """
+
+    categories: ClassVar[list[str]] = ["hardware"]
+    commands: ClassVar[list[AntaCommand | AntaTemplate]] = [AntaCommand(command="show redundancy status", revision=1)]
+
+    class Input(AntaTest.Input):
+        """Input model for the VerifyRedundancyProto test."""
+
+        redundency_proto: Literal["unknownProtocol", "sso", "rpr", "simplex"] = "sso"
+        """Configured redundancy protocol."""
+
+    @skip_on_platforms(["cEOSLab", "vEOS-lab", "cEOSCloudLab", "vEOS"])
+    @AntaTest.anta_test
+    def test(self) -> None:
+        """Main test function for VerifyRedundancyProto."""
+        self.result.is_success()
+        command_output = self.instance_commands[0].json_output
+
+        # Verify peer supervisor card insertion
+        if command_output["peerState"] == "notInserted":
+            self.result.is_skipped("Peer supervisor card not inserted")
+
+        # Verify that the expected redundancy protocol is configured.
+        elif command_output["configuredProtocol"] != self.inputs.redundency_proto:
+            self.result.is_failure(f"Redundancy protocol {self.inputs.redundency_proto} not configured")
+
+        # Verify that the expected redundancy protocol configured and operational
+        elif command_output["operationalProtocol"] != self.inputs.redundency_proto:
+            self.result.is_failure(f"Redundancy protocol {self.inputs.redundency_proto} configured but not operational")
+
+        # Verify that the expected redundancy protocol configured, operational and switchover is ready
path: anta/tests/hardware.py
user: login: geetanjalimanegslab
body: Removed is from the comment 
created_at: 2025-05-14T07:19:57Z
author_association: CONTRIBUTOR
diff_hunk: @@ -269,3 +269,53 @@ def test(self) -> None:
         total_adverse_drop = command_output.get("totalAdverseDrops", "")
         if total_adverse_drop != 0:
             self.result.is_failure(f"Incorrect total adverse drops counter - Expected: 0 Actual: {total_adverse_drop}")
+
+
+class VerifyRedundancyProto(AntaTest):
+    """Verifies that the redundancy protocol status.
+
+    Expected Results
+    ----------------
+    * Success: The test will pass if the expected redundancy protocol is configured and operational, and if switchover is ready.
+    * Failure: The test will fail if the expected redundancy protocol is not configured, not operational, or if switchover is not ready.
+    * Skipped: The test will be skipped if the peer supervisor card is not inserted.
+
+    Examples
+    --------
+    ```yaml
+    anta.tests.hardware:
+      - VerifyRedundancyProto:
+    ```
+    """
+
+    categories: ClassVar[list[str]] = ["hardware"]
+    commands: ClassVar[list[AntaCommand | AntaTemplate]] = [AntaCommand(command="show redundancy status", revision=1)]
+
+    class Input(AntaTest.Input):
+        """Input model for the VerifyRedundancyProto test."""
+
+        redundency_proto: Literal["unknownProtocol", "sso", "rpr", "simplex"] = "sso"
+        """Configured redundancy protocol."""
+
+    @skip_on_platforms(["cEOSLab", "vEOS-lab", "cEOSCloudLab", "vEOS"])
+    @AntaTest.anta_test
+    def test(self) -> None:
+        """Main test function for VerifyRedundancyProto."""
+        self.result.is_success()
+        command_output = self.instance_commands[0].json_output
+
+        # Verify peer supervisor card insertion
+        if command_output["peerState"] == "notInserted":
+            self.result.is_skipped("Peer supervisor card not inserted")
+
+        # Verify that the expected redundancy protocol is configured.
+        elif command_output["configuredProtocol"] != self.inputs.redundency_proto:
+            self.result.is_failure(f"Redundancy protocol {self.inputs.redundency_proto} not configured")
+
+        # Verify that the expected redundancy protocol configured and operational
+        elif command_output["operationalProtocol"] != self.inputs.redundency_proto:
+            self.result.is_failure(f"Redundancy protocol {self.inputs.redundency_proto} configured but not operational")
+
+        # Verify that the expected redundancy protocol configured, operational and switchover is ready
+        elif not command_output["switchoverReady"]:
+            self.result.is_failure(f"Redundancy protocol {self.inputs.redundency_proto} is configured and operational but switchover is not ready")
path: anta/tests/hardware.py
user: login: geetanjalimanegslab
body: Updated, with removing is, to maintain the consistency. Thanks  
created_at: 2025-05-14T07:20:07Z
author_association: CONTRIBUTOR

PR comments:
user: login: codspeed-hq[bot]
created_at: 2025-05-12T03:01:35Z
body: <!-- __CODSPEED_PERFORMANCE_REPORT_COMMENT__ -->
<!-- __CODSPEED_INSTRUMENTATION_PERFORMANCE_REPORT_COMMENT__ -->

## [CodSpeed Performance Report](https://codspeed.io/aristanetworks/anta/branches/geetanjalimanegslab%3Aredundency_status)

### Merging #1194 will **not alter performance**

<sub>Comparing <code>geetanjalimanegslab:redundency_status</code> (a1e3305) with <code>main</code> (6890d3f)</sub>



### Summary

`✅ 26` untouched benchmarks  




author_association: NONE
user: login: github-actions[bot]
created_at: 2025-05-14T13:52:36Z
body: This pull request has conflicts, please resolve those before we can evaluate the pull request.
author_association: CONTRIBUTOR
user: login: github-actions[bot]
created_at: 2025-05-15T07:47:37Z
body: Conflicts have been resolved. A maintainer will review the pull request shortly.
author_association: CONTRIBUTOR
user: login: sonarqubecloud[bot]
created_at: 2025-05-15T10:34:11Z
body: ## [![Quality Gate Passed](https://sonarsource.github.io/sonarcloud-github-static-resources/v2/checks/QualityGateBadge/qg-passed-20px.png 'Quality Gate Passed')](https://sonarcloud.io/dashboard?id=aristanetworks_anta&pullRequest=1194) **Quality Gate passed**  
Issues  
![](https://sonarsource.github.io/sonarcloud-github-static-resources/v2/common/passed-16px.png '') [0 New issues](https://sonarcloud.io/project/issues?id=aristanetworks_anta&pullRequest=1194&issueStatuses=OPEN,CONFIRMED&sinceLeakPeriod=true)  
![](https://sonarsource.github.io/sonarcloud-github-static-resources/v2/common/accepted-16px.png '') [0 Accepted issues](https://sonarcloud.io/project/issues?id=aristanetworks_anta&pullRequest=1194&issueStatuses=ACCEPTED)

Measures  
![](https://sonarsource.github.io/sonarcloud-github-static-resources/v2/common/passed-16px.png '') [0 Security Hotspots](https://sonarcloud.io/project/security_hotspots?id=aristanetworks_anta&pullRequest=1194&issueStatuses=OPEN,CONFIRMED&sinceLeakPeriod=true)  
![](https://sonarsource.github.io/sonarcloud-github-static-resources/v2/common/passed-16px.png '') [100.0% Coverage on New Code](https://sonarcloud.io/component_measures?id=aristanetworks_anta&pullRequest=1194&metric=new_coverage&view=list)  
![](https://sonarsource.github.io/sonarcloud-github-static-resources/v2/common/passed-16px.png '') [0.0% Duplication on New Code](https://sonarcloud.io/component_measures?id=aristanetworks_anta&pullRequest=1194&metric=new_duplicated_lines_density&view=list)  
  
[See analysis details on SonarQube Cloud](https://sonarcloud.io/dashboard?id=aristanetworks_anta&pullRequest=1194)


author_association: NONE