Skip to content

ANTA catalog for Router path-selection tests

VerifyPathsHealth

Verifies the path and telemetry state of all paths under router path-selection.

The expected states are ‘IPsec established’, ‘Resolved’ for path and ‘active’ for telemetry.

Expected Results
  • Success: The test will pass if all path states under router path-selection are either ‘IPsec established’ or ‘Resolved’ and their telemetry state as ‘active’.
  • Failure: The test will fail if router path-selection is not configured or if any path state is not ‘IPsec established’ or ‘Resolved’, or the telemetry state is ‘inactive’.
Examples 
anta.tests.path_selection:
  - VerifyPathsHealth:
Source code in anta/tests/path_selection.py 
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
class VerifyPathsHealth(AntaTest):
    """
    Verifies the path and telemetry state of all paths under router path-selection.

    The expected states are 'IPsec established', 'Resolved' for path and 'active' for telemetry.

    Expected Results
    ----------------
    * Success: The test will pass if all path states under router path-selection are either 'IPsec established' or 'Resolved'
               and their telemetry state as 'active'.
    * Failure: The test will fail if router path-selection is not configured or if any path state is not 'IPsec established' or 'Resolved',
               or the telemetry state is 'inactive'.

    Examples
    --------
    ```yaml
    anta.tests.path_selection:
      - VerifyPathsHealth:
    ```
    """

    name = "VerifyPathsHealth"
    description = "Verifies the path and telemetry state of all paths under router path-selection."
    categories: ClassVar[list[str]] = ["path-selection"]
    commands: ClassVar[list[AntaCommand | AntaTemplate]] = [AntaCommand(command="show path-selection paths", revision=1)]

    @skip_on_platforms(["cEOSLab", "vEOS-lab"])
    @AntaTest.anta_test
    def test(self) -> None:
        """Main test function for VerifyPathsHealth."""
        self.result.is_success()

        command_output = self.instance_commands[0].json_output["dpsPeers"]

        # If no paths are configured for router path-selection, the test fails
        if not command_output:
            self.result.is_failure("No path configured for router path-selection.")
            return

        # Check the state of each path
        for peer, peer_data in command_output.items():
            for group, group_data in peer_data["dpsGroups"].items():
                for path_data in group_data["dpsPaths"].values():
                    path_state = path_data["state"]
                    session = path_data["dpsSessions"]["0"]["active"]

                    # If the path state of any path is not 'ipsecEstablished' or 'routeResolved', the test fails
                    if path_state not in ["ipsecEstablished", "routeResolved"]:
                        self.result.is_failure(f"Path state for peer {peer} in path-group {group} is `{path_state}`.")

                    # If the telemetry state of any path is inactive, the test fails
                    elif not session:
                        self.result.is_failure(f"Telemetry state for peer {peer} in path-group {group} is `inactive`.")

VerifySpecificPath

Verifies the path and telemetry state of a specific path for an IPv4 peer under router path-selection.

The expected states are ‘IPsec established’, ‘Resolved’ for path and ‘active’ for telemetry.

Expected Results
  • Success: The test will pass if the path state under router path-selection is either ‘IPsec established’ or ‘Resolved’ and telemetry state as ‘active’.
  • Failure: The test will fail if router path-selection is not configured or if the path state is not ‘IPsec established’ or ‘Resolved’, or if the telemetry state is ‘inactive’.
Examples 
anta.tests.path_selection:
  - VerifySpecificPath:
      paths:
        - peer: 10.255.0.1
          path_group: internet
          source_address: 100.64.3.2
          destination_address: 100.64.1.2

Inputs

Name Type Description Default
paths list[RouterPath]
List of router paths to verify.
-

RouterPath

Name Type Description Default
peer IPv4Address
Static peer IPv4 address.
-
path_group str
Router path group name.
-
source_address IPv4Address
Source IPv4 address of path.
-
destination_address IPv4Address
Destination IPv4 address of path.
-
Source code in anta/tests/path_selection.py 
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
class VerifySpecificPath(AntaTest):
    """
    Verifies the path and telemetry state of a specific path for an IPv4 peer under router path-selection.

    The expected states are 'IPsec established', 'Resolved' for path and 'active' for telemetry.

    Expected Results
    ----------------
    * Success: The test will pass if the path state under router path-selection is either 'IPsec established' or 'Resolved'
               and telemetry state as 'active'.
    * Failure: The test will fail if router path-selection is not configured or if the path state is not 'IPsec established' or 'Resolved',
               or if the telemetry state is 'inactive'.

    Examples
    --------
    ```yaml
    anta.tests.path_selection:
      - VerifySpecificPath:
          paths:
            - peer: 10.255.0.1
              path_group: internet
              source_address: 100.64.3.2
              destination_address: 100.64.1.2
    ```
    """

    name = "VerifySpecificPath"
    description = "Verifies the path and telemetry state of a specific path under router path-selection."
    categories: ClassVar[list[str]] = ["path-selection"]
    commands: ClassVar[list[AntaCommand | AntaTemplate]] = [
        AntaTemplate(template="show path-selection paths peer {peer} path-group {group} source {source} destination {destination}", revision=1)
    ]

    class Input(AntaTest.Input):
        """Input model for the VerifySpecificPath test."""

        paths: list[RouterPath]
        """List of router paths to verify."""

        class RouterPath(BaseModel):
            """Detail of a router path."""

            peer: IPv4Address
            """Static peer IPv4 address."""

            path_group: str
            """Router path group name."""

            source_address: IPv4Address
            """Source IPv4 address of path."""

            destination_address: IPv4Address
            """Destination IPv4 address of path."""

    def render(self, template: AntaTemplate) -> list[AntaCommand]:
        """Render the template for each router path."""
        return [
            template.render(peer=path.peer, group=path.path_group, source=path.source_address, destination=path.destination_address) for path in self.inputs.paths
        ]

    @skip_on_platforms(["cEOSLab", "vEOS-lab"])
    @AntaTest.anta_test
    def test(self) -> None:
        """Main test function for VerifySpecificPath."""
        self.result.is_success()

        # Check the state of each path
        for command in self.instance_commands:
            peer = command.params.peer
            path_group = command.params.group
            source = command.params.source
            destination = command.params.destination
            command_output = command.json_output.get("dpsPeers", [])

            # If the peer is not configured for the path group, the test fails
            if not command_output:
                self.result.is_failure(f"Path `peer: {peer} source: {source} destination: {destination}` is not configured for path-group `{path_group}`.")
                continue

            # Extract the state of the path
            path_output = get_value(command_output, f"{peer}..dpsGroups..{path_group}..dpsPaths", separator="..")
            path_state = next(iter(path_output.values())).get("state")
            session = get_value(next(iter(path_output.values())), "dpsSessions.0.active")

            # If the state of the path is not 'ipsecEstablished' or 'routeResolved', or the telemetry state is 'inactive', the test fails
            if path_state not in ["ipsecEstablished", "routeResolved"]:
                self.result.is_failure(f"Path state for `peer: {peer} source: {source} destination: {destination}` in path-group {path_group} is `{path_state}`.")
            elif not session:
                self.result.is_failure(
                    f"Telemetry state for path `peer: {peer} source: {source} destination: {destination}` in path-group {path_group} is `inactive`."
                )