feat(anta): Added testcases to verifying Route Type

anta/custom_types.py

@@ -208,3 +208,34 @@ def validate_regex(value: str) -> str:
 SnmpErrorCounter = Literal[
     "inVersionErrs", "inBadCommunityNames", "inBadCommunityUses", "inParseErrs", "outTooBigErrs", "outNoSuchNameErrs", "outBadValueErrs", "outGeneralErrs"
 ]
+# TODO: Needs to update the route types with confirmation.
+
+RouteType = Literal[
+    "connected",
+    "static",
+    "kernel",
+    "OSPF",
+    "OSPF inter area",
+    "OSPF external type 1",
+    "OSPF external type 2",
+    "OSPF NSSA external type 1",
+    "OSPF NSSA external type2",
+    "Other BGP Routes",
+    "iBGP",
+    "eBGP",
+    "RIP",
+    "IS-IS level 1",
+    "IS-IS level 2",
+    "OSPFv3",
+    "BGP Aggregate",
+    "OSPF Summary",
+    "Nexthop Group Static Route",
+    "VXLAN Control Service",
+    "Martian",
+    "DHCP client installed default route",
+    "Dynamic Policy Route",
+    "VRF Leaked",
+    "gRIBI",
+    "Route Cache Route",
+    "CBF Leaked Route",
+]

anta/tests/routing/generic.py

@@ -8,13 +8,14 @@
 from __future__ import annotations
 
 from functools import cache
-from ipaddress import IPv4Address, IPv4Interface
+from ipaddress import IPv4Address, IPv4Interface, IPv4Network
 from typing import TYPE_CHECKING, ClassVar, Literal
 
-from pydantic import model_validator
+from pydantic import BaseModel, model_validator
 
-from anta.custom_types import PositiveInteger
+from anta.custom_types import PositiveInteger, RouteType
 from anta.models import AntaCommand, AntaTemplate, AntaTest
+from anta.tools import get_value
 
 if TYPE_CHECKING:
     import sys
@@ -181,3 +182,95 @@ def test(self) -> None:
             self.result.is_success()
         else:
             self.result.is_failure(f"The following route(s) are missing from the routing table of VRF {self.inputs.vrf}: {missing_routes}")
+
+
+class VerifyRouteType(AntaTest):
+    """Verifies the type of the provided route in the routing table of a specified VRF.
+
+    Expected Results
+    ----------------
+    * Success: The test will pass if the provided route is of the expected type.
+    * Failure: The test will fail if the provided route is not of the expected type.
+
+    Examples
+    --------
+    ```yaml
+    anta.tests.routing:
+      generic:
+       VerifyRouteType:
+          routes_entries:
+            - vrf: default
+              prefix: 10.10.0.1/32
+              route_type: eBGP
+            - vrf: default
+              prefix: 10.100.0.12/31
+              route_type: connected
+            - vrf: default
+              prefix: 10.100.0.14/31
+              route_type: connected
+            - vrf: default
+              prefix: 10.100.0.128/31
+              route_type: eBGP
+            - vrf: default
+              prefix: 10.100.1.5/32
+              route_type: iBGP```
+    """
+
+    categories: ClassVar[list[str]] = ["routing"]
+    commands: ClassVar[list[AntaCommand | AntaTemplate]] = [
+        AntaCommand(command="show ip route vrf all", revision=4),
+    ]
+
+    class Input(AntaTest.Input):
+        """Input model for the VerifyRouteType test."""
+
+        routes_entries: list[Routes]
+
+        class Routes(BaseModel):
+            """Model for a list of route entries."""
+
+            vrf: str = "default"
+            """ VRF context. Defaults to `default` VRF."""
+            prefix: IPv4Network
+            """ IPV4network to validate the rout type. """
+            route_type: RouteType
+            """ List of Route type to validate the valid rout type. """
+
+    @AntaTest.anta_test
+    def test(self) -> None:
+        """Main test function for VerifyRouteType."""
+        self.result.is_success()
+
+        # Forming a dictionary for the test failure message.
+        failures: dict[str, any] = {"routes_entries": {}}
+
+        # Collecting the 'show ip route vrf all' command output.
+        output = self.instance_commands[0].json_output
+
+        # Iterating over the all routes entries mentioned in the inputs.
+        for entries in self.inputs.routes_entries:
+            vrf = entries.vrf
+            network = str(entries.prefix)
+            expected_route_type = entries.route_type
+
+            # Verifying that on device, expected VRF is configured.
+            if (routes_details := get_value(output, f"vrfs.{vrf}.routes")) is None:
+                failures["routes_entries"][network] = {vrf: "Not configured"}
+                continue
+
+            # Verifying that the expected route is present or not on the device
+            if (route_data := get_value(routes_details, network, separator="..")) is None:
+                failures["routes_entries"][network] = {vrf: "Routes not found."}
+                continue
+
+            actual_route_type = route_data.get("routeType")
+
+            # Verifying that the expected route-type and the actual routes are the same.
+            if expected_route_type != actual_route_type:
+                failures["routes_entries"][network] = {
+                    vrf: {"route_type": f"Expected route type is '{expected_route_type}' " f"however in actual it is found as '{actual_route_type}'"}
+                }
+
+        # Updating the result, as per the testcase failure message.
+        if failures["routes_entries"]:
+            self.result.is_failure(f"For following routes, VRF is not configured or Route types are invalid:\n{failures}")

examples/tests.yaml

@@ -508,6 +508,23 @@ anta.tests.routing:
         routes:
           - 10.1.0.1
           - 10.1.0.2
+    - VerifyRouteType:
+        routes_entries:
+          - vrf: default
+            prefix: 10.10.0.1/32
+            route_type: eBGP
+          - vrf: default
+            prefix: 10.100.0.12/31
+            route_type: connected
+          - vrf: default
+            prefix: 10.100.0.14/31
+            route_type: connected
+          - vrf: default
+            prefix: 10.100.0.128/31
+            route_type: eBGP
+          - vrf: default
+            prefix: 10.100.1.5/32
+            route_type: iBGP
   bgp:
     - VerifyBGPPeerCount:
         address_families: