Skip to content

Interfaces

ANTA catalog for interfaces tests

Test functions related to the device interfaces

VerifyIPProxyARP

Bases: AntaTest

Verifies if Proxy-ARP is enabled for the provided list of interface(s).

Expected Results
  • success: The test will pass if Proxy-ARP is enabled on the specified interface(s).
  • failure: The test will fail if Proxy-ARP is disabled on the specified interface(s).
  • error: The test will give an error if a list of interface(s) is not provided as template_params.
Source code in anta/tests/interfaces.py 
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
class VerifyIPProxyARP(AntaTest):
    """
    Verifies if Proxy-ARP is enabled for the provided list of interface(s).

    Expected Results:
        * success: The test will pass if Proxy-ARP is enabled on the specified interface(s).
        * failure: The test will fail if Proxy-ARP is disabled on the specified interface(s).
        * error: The test will give an error if a list of interface(s) is not provided as template_params.

    """

    name = "VerifyIPProxyARP"
    description = "Verifies if Proxy-ARP is enabled for the provided list of interface(s)."
    categories = ["interfaces"]
    template = AntaTemplate(template="show ip interface {intf}")

    @AntaTest.anta_test
    def test(self) -> None:
        """
        Run VerifyIPProxyARP validation.
        """

        disabled_intf = []
        for command in self.instance_commands:
            if command.params and "intf" in command.params:
                intf = command.params["intf"]
            if not command.json_output["interfaces"][intf]["proxyArp"]:
                disabled_intf.append(intf)

        if disabled_intf:
            self.result.is_failure(f"The following interface(s) have Proxy-ARP disabled: {disabled_intf}")

        else:
            self.result.is_success()

test 

test() -> None

Run VerifyIPProxyARP validation.

Source code in anta/tests/interfaces.py 
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
@AntaTest.anta_test
def test(self) -> None:
    """
    Run VerifyIPProxyARP validation.
    """

    disabled_intf = []
    for command in self.instance_commands:
        if command.params and "intf" in command.params:
            intf = command.params["intf"]
        if not command.json_output["interfaces"][intf]["proxyArp"]:
            disabled_intf.append(intf)

    if disabled_intf:
        self.result.is_failure(f"The following interface(s) have Proxy-ARP disabled: {disabled_intf}")

    else:
        self.result.is_success()

VerifyIllegalLACP

Bases: AntaTest

Verifies there is no illegal LACP packets received.

Source code in anta/tests/interfaces.py 
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
class VerifyIllegalLACP(AntaTest):
    """
    Verifies there is no illegal LACP packets received.
    """

    name = "VerifyIllegalLACP"
    description = "Verifies there is no illegal LACP packets received."
    categories = ["interfaces"]
    commands = [AntaCommand(command="show lacp counters all-ports")]

    @AntaTest.anta_test
    def test(self) -> None:
        """Run VerifyIllegalLACP validation"""

        command_output = self.instance_commands[0].json_output

        po_with_illegal_lacp: List[Dict[str, Dict[str, int]]] = []
        for portchannel, portchannel_dict in command_output["portChannels"].items():
            po_with_illegal_lacp.extend(
                {portchannel: interface} for interface, interface_dict in portchannel_dict["interfaces"].items() if interface_dict["illegalRxCount"] != 0
            )

        if not po_with_illegal_lacp:
            self.result.is_success()
        else:
            self.result.is_failure("The following port-channels have recieved illegal lacp packets on the " f"following ports: {po_with_illegal_lacp}")

test 

test() -> None

Run VerifyIllegalLACP validation

Source code in anta/tests/interfaces.py 
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
@AntaTest.anta_test
def test(self) -> None:
    """Run VerifyIllegalLACP validation"""

    command_output = self.instance_commands[0].json_output

    po_with_illegal_lacp: List[Dict[str, Dict[str, int]]] = []
    for portchannel, portchannel_dict in command_output["portChannels"].items():
        po_with_illegal_lacp.extend(
            {portchannel: interface} for interface, interface_dict in portchannel_dict["interfaces"].items() if interface_dict["illegalRxCount"] != 0
        )

    if not po_with_illegal_lacp:
        self.result.is_success()
    else:
        self.result.is_failure("The following port-channels have recieved illegal lacp packets on the " f"following ports: {po_with_illegal_lacp}")

VerifyInterfaceDiscards

Bases: AntaTest

Verifies interfaces packet discard counters are equal to zero.

Source code in anta/tests/interfaces.py 
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
class VerifyInterfaceDiscards(AntaTest):
    """
    Verifies interfaces packet discard counters are equal to zero.
    """

    name = "VerifyInterfaceDiscards"
    description = "Verifies interfaces packet discard counters are equal to zero."
    categories = ["interfaces"]
    commands = [AntaCommand(command="show interfaces counters discards")]

    @AntaTest.anta_test
    def test(self) -> None:
        """Run VerifyInterfaceDiscards validation"""

        command_output = self.instance_commands[0].json_output

        wrong_interfaces: List[Dict[str, Dict[str, int]]] = []

        for interface, outer_v in command_output["interfaces"].items():
            wrong_interfaces.extend({interface: outer_v} for counter, value in outer_v.items() if value > 0)
        if not wrong_interfaces:
            self.result.is_success()
        else:
            self.result.is_failure(f"The following interfaces have non 0 discard counter(s): {wrong_interfaces}")

test 

test() -> None

Run VerifyInterfaceDiscards validation

Source code in anta/tests/interfaces.py 
86
87
88
89
90
91
92
93
94
95
96
97
98
99
@AntaTest.anta_test
def test(self) -> None:
    """Run VerifyInterfaceDiscards validation"""

    command_output = self.instance_commands[0].json_output

    wrong_interfaces: List[Dict[str, Dict[str, int]]] = []

    for interface, outer_v in command_output["interfaces"].items():
        wrong_interfaces.extend({interface: outer_v} for counter, value in outer_v.items() if value > 0)
    if not wrong_interfaces:
        self.result.is_success()
    else:
        self.result.is_failure(f"The following interfaces have non 0 discard counter(s): {wrong_interfaces}")

VerifyInterfaceErrDisabled

Bases: AntaTest

Verifies there is no interface in error disable state.

Source code in anta/tests/interfaces.py 
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
class VerifyInterfaceErrDisabled(AntaTest):
    """
    Verifies there is no interface in error disable state.
    """

    name = "VerifyInterfaceErrDisabled"
    description = "Verifies there is no interface in error disable state."
    categories = ["interfaces"]
    commands = [AntaCommand(command="show interfaces status")]

    @AntaTest.anta_test
    def test(self) -> None:
        """Run VerifyInterfaceErrDisabled validation"""

        command_output = self.instance_commands[0].json_output

        errdisabled_interfaces = [interface for interface, value in command_output["interfaceStatuses"].items() if value["linkStatus"] == "errdisabled"]

        if errdisabled_interfaces:
            self.result.is_failure(f"The following interfaces are in error disabled state: {errdisabled_interfaces}")
        else:
            self.result.is_success()

test 

test() -> None

Run VerifyInterfaceErrDisabled validation

Source code in anta/tests/interfaces.py 
112
113
114
115
116
117
118
119
120
121
122
123
@AntaTest.anta_test
def test(self) -> None:
    """Run VerifyInterfaceErrDisabled validation"""

    command_output = self.instance_commands[0].json_output

    errdisabled_interfaces = [interface for interface, value in command_output["interfaceStatuses"].items() if value["linkStatus"] == "errdisabled"]

    if errdisabled_interfaces:
        self.result.is_failure(f"The following interfaces are in error disabled state: {errdisabled_interfaces}")
    else:
        self.result.is_success()

VerifyInterfaceErrors

Bases: AntaTest

This test verifies that interfaces error counters are equal to zero.

Expected Results
  • success: The test will pass if all interfaces have error counters equal to zero.
  • failure: The test will fail if one or more interfaces have non-zero error counters.
Source code in anta/tests/interfaces.py 
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
73
class VerifyInterfaceErrors(AntaTest):
    """
    This test verifies that interfaces error counters are equal to zero.

    Expected Results:
        * success: The test will pass if all interfaces have error counters equal to zero.
        * failure: The test will fail if one or more interfaces have non-zero error counters.
    """

    name = "VerifyInterfaceErrors"
    description = "Verifies that interfaces error counters are equal to zero."
    categories = ["interfaces"]
    commands = [AntaCommand(command="show interfaces counters errors")]

    @AntaTest.anta_test
    def test(self) -> None:
        """
        Run VerifyInterfaceErrors validation
        """
        command_output = self.instance_commands[0].json_output

        wrong_interfaces: List[Dict[str, Dict[str, int]]] = []
        for interface, counters in command_output["interfaceErrorCounters"].items():
            if any(value > 0 for value in counters.values()) and not any(interface in wrong_interface for wrong_interface in wrong_interfaces):
                wrong_interfaces.append({interface: counters})
        if not wrong_interfaces:
            self.result.is_success()
        else:
            self.result.is_failure(f"The following interface(s) have non-zero error counters: {wrong_interfaces}")

test 

test() -> None

Run VerifyInterfaceErrors validation

Source code in anta/tests/interfaces.py 
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
@AntaTest.anta_test
def test(self) -> None:
    """
    Run VerifyInterfaceErrors validation
    """
    command_output = self.instance_commands[0].json_output

    wrong_interfaces: List[Dict[str, Dict[str, int]]] = []
    for interface, counters in command_output["interfaceErrorCounters"].items():
        if any(value > 0 for value in counters.values()) and not any(interface in wrong_interface for wrong_interface in wrong_interfaces):
            wrong_interfaces.append({interface: counters})
    if not wrong_interfaces:
        self.result.is_success()
    else:
        self.result.is_failure(f"The following interface(s) have non-zero error counters: {wrong_interfaces}")

VerifyInterfaceUtilization

Bases: AntaTest

Verifies interfaces utilization is below 75%.

Source code in anta/tests/interfaces.py 
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
class VerifyInterfaceUtilization(AntaTest):
    """
    Verifies interfaces utilization is below 75%.
    """

    name = "VerifyInterfaceUtilization"
    description = "Verifies interfaces utilization is below 75%."
    categories = ["interfaces"]
    # TODO - move from text to json if possible
    commands = [AntaCommand(command="show interfaces counters rates", ofmt="text")]

    @AntaTest.anta_test
    def test(self) -> None:
        """Run VerifyInterfaceUtilization validation"""

        command_output = self.instance_commands[0].text_output

        wrong_interfaces = {}
        for line in command_output.split("\n")[1:]:
            if len(line) > 0:
                if line.split()[-5] == "-" or line.split()[-2] == "-":
                    pass
                elif float(line.split()[-5].replace("%", "")) > 75.0:
                    wrong_interfaces[line.split()[0]] = line.split()[-5]
                elif float(line.split()[-2].replace("%", "")) > 75.0:
                    wrong_interfaces[line.split()[0]] = line.split()[-2]

        if not wrong_interfaces:
            self.result.is_success()
        else:
            self.result.is_failure(f"The following interfaces have a usage > 75%: {wrong_interfaces}")

test 

test() -> None

Run VerifyInterfaceUtilization validation

Source code in anta/tests/interfaces.py 
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
@AntaTest.anta_test
def test(self) -> None:
    """Run VerifyInterfaceUtilization validation"""

    command_output = self.instance_commands[0].text_output

    wrong_interfaces = {}
    for line in command_output.split("\n")[1:]:
        if len(line) > 0:
            if line.split()[-5] == "-" or line.split()[-2] == "-":
                pass
            elif float(line.split()[-5].replace("%", "")) > 75.0:
                wrong_interfaces[line.split()[0]] = line.split()[-5]
            elif float(line.split()[-2].replace("%", "")) > 75.0:
                wrong_interfaces[line.split()[0]] = line.split()[-2]

    if not wrong_interfaces:
        self.result.is_success()
    else:
        self.result.is_failure(f"The following interfaces have a usage > 75%: {wrong_interfaces}")

VerifyInterfacesStatus

Bases: AntaTest

Verifies the number of Ethernet interfaces up/up on the device is higher or equal than a value.

Source code in anta/tests/interfaces.py 
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
166
class VerifyInterfacesStatus(AntaTest):
    """
    Verifies the number of Ethernet interfaces up/up on the device is higher or equal than a value.
    """

    name = "VerifyInterfacesStatus"
    description = "Verifies the number of Ethernet interfaces up/up on the device is higher or equal than a value."
    categories = ["interfaces"]
    commands = [AntaCommand(command="show interfaces description")]

    @AntaTest.anta_test
    def test(self, minimum: Optional[int] = None) -> None:
        """
        Run VerifyInterfacesStatus validation

        Args:
            minimum: Expected minimum number of Ethernet interfaces up/up.
        """

        if minimum is None or minimum < 0:
            self.result.is_skipped(f"VerifyInterfacesStatus was not run as an invalid minimum value was given {minimum}.")
            return

        command_output = self.instance_commands[0].json_output

        count_up_up = 0
        other_ethernet_interfaces = []

        for interface in command_output["interfaceDescriptions"]:
            interface_dict = command_output["interfaceDescriptions"][interface]
            if "Ethernet" in interface:
                if re.match(r"connected|up", interface_dict["lineProtocolStatus"]) and re.match(r"connected|up", interface_dict["interfaceStatus"]):
                    count_up_up += 1
                else:
                    other_ethernet_interfaces.append(interface)

        if count_up_up >= minimum:
            self.result.is_success()
        else:
            self.result.is_failure(f"Only {count_up_up}, less than {minimum} Ethernet interfaces are UP/UP")
            self.result.messages.append(f"The following Ethernet interfaces are not UP/UP: {other_ethernet_interfaces}")

test 

test(minimum: Optional[int] = None) -> None

Run VerifyInterfacesStatus validation

Parameters:

Name Type Description Default
minimum Optional[int]

Expected minimum number of Ethernet interfaces up/up.

 None
Source code in anta/tests/interfaces.py 
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
166
@AntaTest.anta_test
def test(self, minimum: Optional[int] = None) -> None:
    """
    Run VerifyInterfacesStatus validation

    Args:
        minimum: Expected minimum number of Ethernet interfaces up/up.
    """

    if minimum is None or minimum < 0:
        self.result.is_skipped(f"VerifyInterfacesStatus was not run as an invalid minimum value was given {minimum}.")
        return

    command_output = self.instance_commands[0].json_output

    count_up_up = 0
    other_ethernet_interfaces = []

    for interface in command_output["interfaceDescriptions"]:
        interface_dict = command_output["interfaceDescriptions"][interface]
        if "Ethernet" in interface:
            if re.match(r"connected|up", interface_dict["lineProtocolStatus"]) and re.match(r"connected|up", interface_dict["interfaceStatus"]):
                count_up_up += 1
            else:
                other_ethernet_interfaces.append(interface)

    if count_up_up >= minimum:
        self.result.is_success()
    else:
        self.result.is_failure(f"Only {count_up_up}, less than {minimum} Ethernet interfaces are UP/UP")
        self.result.messages.append(f"The following Ethernet interfaces are not UP/UP: {other_ethernet_interfaces}")

VerifyL2MTU

Bases: AntaTest

Verifies the global layer 2 Maximum Transfer Unit (MTU) for all L2 interfaces.

Test that L2 interfaces are configured with the correct MTU. It supports Ethernet, Port Channel and VLAN interfaces. You can define a global MTU to check and also an MTU per interface and also ignored some interfaces.

Default ignored interfaces: [“Management”, “Loopback”, “Tunnel”, “Vxlan”]

Expected Results
  • success: The test will pass if all layer 2 interfaces have the proper MTU configured.
  • failure: The test will fail if one or many layer 2 interfaces have the wrong MTU configured.
  • skipped: The test will be skipped if the MTU value is not provided.
Source code in anta/tests/interfaces.py 
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
class VerifyL2MTU(AntaTest):

    """
    Verifies the global layer 2 Maximum Transfer Unit (MTU) for all L2 interfaces.

    Test that L2 interfaces are configured with the correct MTU. It supports Ethernet, Port Channel and VLAN interfaces.
    You can define a global MTU to check and also an MTU per interface and also ignored some interfaces.

    Default ignored interfaces: ["Management", "Loopback", "Tunnel", "Vxlan"]

    Expected Results:
        * success: The test will pass if all layer 2 interfaces have the proper MTU configured.
        * failure: The test will fail if one or many layer 2 interfaces have the wrong MTU configured.
        * skipped: The test will be skipped if the MTU value is not provided.
    """

    name = "VerifyL2MTU"
    description = "Verifies the global layer 2 Maximum Transfer Unit (MTU) for all layer 2 interfaces."
    categories = ["interfaces"]
    commands = [AntaCommand(command="show interfaces")]

    NOT_SUPPORTED_INTERFACES: List[str] = ["Management", "Loopback", "Tunnel", "Vxlan"]

    @AntaTest.anta_test
    def test(self, mtu: int = 9214, ignored_interfaces: Optional[List[str]] = None, specific_mtu: Optional[List[Dict[str, int]]] = None) -> None:
        """
        Verifies the global L2 Maximum Transfer Unit (MTU) for interfaces.

        Test that L2 interfaces are configured with the correct MTU. It supports Ethernet, Port Channel and VLAN interfaces.
        You can define a global MTU to check and also an MTU per interface and also ignored some interfaces.

        Args:
            mtu (int, optional): Default MTU we should have configured on all non-excluded interfaces. Defaults to 9214.
            ignored_interfaces (List[str]): A list of L2 interfaces to ignore. It will replace the built-in exclusion.
            specific_mtu (Optional[List[Dict[str, int]]]): A list of dictionary of L2 interfaces with their specific MTU configured.
        """
        if not mtu:
            self.result.is_skipped(f"{self.__class__.name} did not run because mtu was not supplied")
            return

        if ignored_interfaces is None:
            ignored_interfaces = self.NOT_SUPPORTED_INTERFACES

        # Parameter to save incorrect interface settings
        wrong_l2mtu_intf: List[Dict[str, int]] = []

        command_output = self.instance_commands[0].json_output

        # Set list of interfaces with specific settings
        specific_interfaces: List[str] = []
        if specific_mtu is not None:
            for d in specific_mtu:
                specific_interfaces.extend(d)
        # Set default value if there is no specific settings.
        else:
            specific_mtu = []

        for interface, values in command_output["interfaces"].items():
            if re.findall(r"[a-z]+", interface, re.IGNORECASE)[0] not in ignored_interfaces and values["forwardingModel"] == "bridged":
                if interface in specific_interfaces:
                    wrong_l2mtu_intf.extend({interface: values["mtu"]} for custom_data in specific_mtu if values["mtu"] != custom_data[interface])
                # Comparison with generic setting
                elif values["mtu"] != mtu:
                    wrong_l2mtu_intf.append({interface: values["mtu"]})

        if wrong_l2mtu_intf:
            self.result.is_failure(f"Some L2 interfaces do not have correct MTU configured:\n{wrong_l2mtu_intf}")
        else:
            self.result.is_success()

test 

test(mtu: int = 9214, ignored_interfaces: Optional[List[str]] = None, specific_mtu: Optional[List[Dict[str, int]]] = None) -> None

Verifies the global L2 Maximum Transfer Unit (MTU) for interfaces.

Test that L2 interfaces are configured with the correct MTU. It supports Ethernet, Port Channel and VLAN interfaces. You can define a global MTU to check and also an MTU per interface and also ignored some interfaces.

Parameters:

Name Type Description Default
mtu int

Default MTU we should have configured on all non-excluded interfaces. Defaults to 9214.

 9214
ignored_interfaces List[str]

A list of L2 interfaces to ignore. It will replace the built-in exclusion.

 None
specific_mtu Optional[List[Dict[str, int]]]

A list of dictionary of L2 interfaces with their specific MTU configured.

 None
Source code in anta/tests/interfaces.py 
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
@AntaTest.anta_test
def test(self, mtu: int = 9214, ignored_interfaces: Optional[List[str]] = None, specific_mtu: Optional[List[Dict[str, int]]] = None) -> None:
    """
    Verifies the global L2 Maximum Transfer Unit (MTU) for interfaces.

    Test that L2 interfaces are configured with the correct MTU. It supports Ethernet, Port Channel and VLAN interfaces.
    You can define a global MTU to check and also an MTU per interface and also ignored some interfaces.

    Args:
        mtu (int, optional): Default MTU we should have configured on all non-excluded interfaces. Defaults to 9214.
        ignored_interfaces (List[str]): A list of L2 interfaces to ignore. It will replace the built-in exclusion.
        specific_mtu (Optional[List[Dict[str, int]]]): A list of dictionary of L2 interfaces with their specific MTU configured.
    """
    if not mtu:
        self.result.is_skipped(f"{self.__class__.name} did not run because mtu was not supplied")
        return

    if ignored_interfaces is None:
        ignored_interfaces = self.NOT_SUPPORTED_INTERFACES

    # Parameter to save incorrect interface settings
    wrong_l2mtu_intf: List[Dict[str, int]] = []

    command_output = self.instance_commands[0].json_output

    # Set list of interfaces with specific settings
    specific_interfaces: List[str] = []
    if specific_mtu is not None:
        for d in specific_mtu:
            specific_interfaces.extend(d)
    # Set default value if there is no specific settings.
    else:
        specific_mtu = []

    for interface, values in command_output["interfaces"].items():
        if re.findall(r"[a-z]+", interface, re.IGNORECASE)[0] not in ignored_interfaces and values["forwardingModel"] == "bridged":
            if interface in specific_interfaces:
                wrong_l2mtu_intf.extend({interface: values["mtu"]} for custom_data in specific_mtu if values["mtu"] != custom_data[interface])
            # Comparison with generic setting
            elif values["mtu"] != mtu:
                wrong_l2mtu_intf.append({interface: values["mtu"]})

    if wrong_l2mtu_intf:
        self.result.is_failure(f"Some L2 interfaces do not have correct MTU configured:\n{wrong_l2mtu_intf}")
    else:
        self.result.is_success()

VerifyL3MTU

Bases: AntaTest

Verifies the global layer 3 Maximum Transfer Unit (MTU) for all L3 interfaces.

Test that L3 interfaces are configured with the correct MTU. It supports Ethernet, Port Channel and VLAN interfaces. You can define a global MTU to check and also an MTU per interface and also ignored some interfaces.

Default ignored interfaces: [“Management”, “Loopback”, “Vxlan”, “Tunnel”]

Expected Results
  • success: The test will pass if all layer 3 interfaces have the proper MTU configured.
  • failure: The test will fail if one or many layer 3 interfaces have the wrong MTU configured.
  • skipped: The test will be skipped if the MTU value is not provided.
Source code in anta/tests/interfaces.py 
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
class VerifyL3MTU(AntaTest):

    """
    Verifies the global layer 3 Maximum Transfer Unit (MTU) for all L3 interfaces.

    Test that L3 interfaces are configured with the correct MTU. It supports Ethernet, Port Channel and VLAN interfaces.
    You can define a global MTU to check and also an MTU per interface and also ignored some interfaces.

    Default ignored interfaces: ["Management", "Loopback", "Vxlan", "Tunnel"]

    Expected Results:
        * success: The test will pass if all layer 3 interfaces have the proper MTU configured.
        * failure: The test will fail if one or many layer 3 interfaces have the wrong MTU configured.
        * skipped: The test will be skipped if the MTU value is not provided.
    """

    name = "VerifyL3MTU"
    description = "Verifies the global layer 3 Maximum Transfer Unit (MTU) for all layer 3 interfaces."
    categories = ["interfaces"]
    commands = [AntaCommand(command="show interfaces")]

    NOT_SUPPORTED_INTERFACES: List[str] = ["Management", "Loopback", "Vxlan", "Tunnel"]

    @AntaTest.anta_test
    def test(self, mtu: int = 1500, ignored_interfaces: Optional[List[str]] = None, specific_mtu: Optional[List[Dict[str, int]]] = None) -> None:
        """
        Verifies the global L3 Maximum Transfer Unit (MTU) for interfaces.

        Test that L3 interfaces are configured with the correct MTU. It supports Ethernet, Port Channel and VLAN interfaces.
        You can define a global MTU to check and also an MTU per interface and also ignored some interfaces.

        Args:
            mtu (int, optional): Default MTU we should have configured on all non-excluded interfaces. Defaults to 1500.
            ignored_interfaces (List[str]): A list of L3 interfaces to ignore. It will replace the built-in exclusion.
            specific_mtu (Optional[List[Dict[str, int]]]): A list of dictionary of L3 interfaces with their specific MTU configured.
        """
        if not mtu:
            self.result.is_skipped(f"{self.__class__.name} did not run because mtu was not supplied")
            return

        if ignored_interfaces is None:
            ignored_interfaces = self.NOT_SUPPORTED_INTERFACES

        # Parameter to save incorrect interface settings
        wrong_l3mtu_intf: List[Dict[str, int]] = []

        command_output = self.instance_commands[0].json_output

        # Set list of interfaces with specific settings
        specific_interfaces: List[str] = []
        if specific_mtu is not None:
            for d in specific_mtu:
                specific_interfaces.extend(d)
        # Set default value if there is no specific settings.
        else:
            specific_mtu = []

        for interface, values in command_output["interfaces"].items():
            if re.findall(r"[a-z]+", interface, re.IGNORECASE)[0] not in ignored_interfaces and values["forwardingModel"] == "routed":
                if interface in specific_interfaces:
                    wrong_l3mtu_intf.extend({interface: values["mtu"]} for custom_data in specific_mtu if values["mtu"] != custom_data[interface])
                # Comparison with generic setting
                elif values["mtu"] != mtu:
                    wrong_l3mtu_intf.append({interface: values["mtu"]})

        if wrong_l3mtu_intf:
            self.result.is_failure(f"Some interfaces do not have correct MTU configured:\n{wrong_l3mtu_intf}")
        else:
            self.result.is_success()

test 

test(mtu: int = 1500, ignored_interfaces: Optional[List[str]] = None, specific_mtu: Optional[List[Dict[str, int]]] = None) -> None

Verifies the global L3 Maximum Transfer Unit (MTU) for interfaces.

Test that L3 interfaces are configured with the correct MTU. It supports Ethernet, Port Channel and VLAN interfaces. You can define a global MTU to check and also an MTU per interface and also ignored some interfaces.

Parameters:

Name Type Description Default
mtu int

Default MTU we should have configured on all non-excluded interfaces. Defaults to 1500.

 1500
ignored_interfaces List[str]

A list of L3 interfaces to ignore. It will replace the built-in exclusion.

 None
specific_mtu Optional[List[Dict[str, int]]]

A list of dictionary of L3 interfaces with their specific MTU configured.

 None
Source code in anta/tests/interfaces.py 
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
@AntaTest.anta_test
def test(self, mtu: int = 1500, ignored_interfaces: Optional[List[str]] = None, specific_mtu: Optional[List[Dict[str, int]]] = None) -> None:
    """
    Verifies the global L3 Maximum Transfer Unit (MTU) for interfaces.

    Test that L3 interfaces are configured with the correct MTU. It supports Ethernet, Port Channel and VLAN interfaces.
    You can define a global MTU to check and also an MTU per interface and also ignored some interfaces.

    Args:
        mtu (int, optional): Default MTU we should have configured on all non-excluded interfaces. Defaults to 1500.
        ignored_interfaces (List[str]): A list of L3 interfaces to ignore. It will replace the built-in exclusion.
        specific_mtu (Optional[List[Dict[str, int]]]): A list of dictionary of L3 interfaces with their specific MTU configured.
    """
    if not mtu:
        self.result.is_skipped(f"{self.__class__.name} did not run because mtu was not supplied")
        return

    if ignored_interfaces is None:
        ignored_interfaces = self.NOT_SUPPORTED_INTERFACES

    # Parameter to save incorrect interface settings
    wrong_l3mtu_intf: List[Dict[str, int]] = []

    command_output = self.instance_commands[0].json_output

    # Set list of interfaces with specific settings
    specific_interfaces: List[str] = []
    if specific_mtu is not None:
        for d in specific_mtu:
            specific_interfaces.extend(d)
    # Set default value if there is no specific settings.
    else:
        specific_mtu = []

    for interface, values in command_output["interfaces"].items():
        if re.findall(r"[a-z]+", interface, re.IGNORECASE)[0] not in ignored_interfaces and values["forwardingModel"] == "routed":
            if interface in specific_interfaces:
                wrong_l3mtu_intf.extend({interface: values["mtu"]} for custom_data in specific_mtu if values["mtu"] != custom_data[interface])
            # Comparison with generic setting
            elif values["mtu"] != mtu:
                wrong_l3mtu_intf.append({interface: values["mtu"]})

    if wrong_l3mtu_intf:
        self.result.is_failure(f"Some interfaces do not have correct MTU configured:\n{wrong_l3mtu_intf}")
    else:
        self.result.is_success()

VerifyLoopbackCount

Bases: AntaTest

Verifies the number of loopback interfaces on the device is the one we expect and if none of the loopback is down.

Source code in anta/tests/interfaces.py 
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
class VerifyLoopbackCount(AntaTest):
    """
    Verifies the number of loopback interfaces on the device is the one we expect and if none of the loopback is down.
    """

    name = "VerifyLoopbackCount"
    description = "Verifies the number of loopback interfaces on the device is the one we expect and if none of the loopback is down."
    categories = ["interfaces"]
    commands = [AntaCommand(command="show ip interface brief")]

    @AntaTest.anta_test
    def test(self, number: Optional[int] = None) -> None:
        """
        Run VerifyLoopbackCount validation

        Args:
            number: Number of loopback interfaces expected to be present.
        """

        if number is None:
            self.result.is_skipped("VerifyLoopbackCount was not run as no number value was given.")
            return

        command_output = self.instance_commands[0].json_output

        loopback_count = 0
        down_loopback_interfaces = []

        for interface in command_output["interfaces"]:
            interface_dict = command_output["interfaces"][interface]
            if "Loopback" in interface:
                loopback_count += 1
                if not (interface_dict["lineProtocolStatus"] == "up" and interface_dict["interfaceStatus"] == "connected"):
                    down_loopback_interfaces.append(interface)

        if loopback_count == number and len(down_loopback_interfaces) == 0:
            self.result.is_success()
        else:
            self.result.is_failure()
            if loopback_count != number:
                self.result.is_failure(f"Found {loopback_count} Loopbacks when expecting {number}")
            elif len(down_loopback_interfaces) != 0:
                self.result.is_failure(f"The following Loopbacks are not up: {down_loopback_interfaces}")

test 

test(number: Optional[int] = None) -> None

Run VerifyLoopbackCount validation

Parameters:

Name Type Description Default
number Optional[int]

Number of loopback interfaces expected to be present.

 None
Source code in anta/tests/interfaces.py 
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
@AntaTest.anta_test
def test(self, number: Optional[int] = None) -> None:
    """
    Run VerifyLoopbackCount validation

    Args:
        number: Number of loopback interfaces expected to be present.
    """

    if number is None:
        self.result.is_skipped("VerifyLoopbackCount was not run as no number value was given.")
        return

    command_output = self.instance_commands[0].json_output

    loopback_count = 0
    down_loopback_interfaces = []

    for interface in command_output["interfaces"]:
        interface_dict = command_output["interfaces"][interface]
        if "Loopback" in interface:
            loopback_count += 1
            if not (interface_dict["lineProtocolStatus"] == "up" and interface_dict["interfaceStatus"] == "connected"):
                down_loopback_interfaces.append(interface)

    if loopback_count == number and len(down_loopback_interfaces) == 0:
        self.result.is_success()
    else:
        self.result.is_failure()
        if loopback_count != number:
            self.result.is_failure(f"Found {loopback_count} Loopbacks when expecting {number}")
        elif len(down_loopback_interfaces) != 0:
            self.result.is_failure(f"The following Loopbacks are not up: {down_loopback_interfaces}")

VerifyPortChannels

Bases: AntaTest

Verifies there is no inactive port in port channels.

Source code in anta/tests/interfaces.py 
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
class VerifyPortChannels(AntaTest):
    """
    Verifies there is no inactive port in port channels.
    """

    name = "VerifyPortChannels"
    description = "Verifies there is no inactive port in port channels."
    categories = ["interfaces"]
    commands = [AntaCommand(command="show port-channel")]

    @skip_on_platforms(["cEOSLab", "vEOS-lab"])
    @AntaTest.anta_test
    def test(self) -> None:
        """Run VerifyPortChannels validation"""

        command_output = self.instance_commands[0].json_output

        po_with_invactive_ports: List[Dict[str, str]] = []
        for portchannel, portchannel_dict in command_output["portChannels"].items():
            if len(portchannel_dict["inactivePorts"]) != 0:
                po_with_invactive_ports.extend({portchannel: portchannel_dict["inactivePorts"]})

        if not po_with_invactive_ports:
            self.result.is_success()
        else:
            self.result.is_failure(f"The following port-channels have inactive port(s): {po_with_invactive_ports}")

test 

test() -> None

Run VerifyPortChannels validation

Source code in anta/tests/interfaces.py 
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
@skip_on_platforms(["cEOSLab", "vEOS-lab"])
@AntaTest.anta_test
def test(self) -> None:
    """Run VerifyPortChannels validation"""

    command_output = self.instance_commands[0].json_output

    po_with_invactive_ports: List[Dict[str, str]] = []
    for portchannel, portchannel_dict in command_output["portChannels"].items():
        if len(portchannel_dict["inactivePorts"]) != 0:
            po_with_invactive_ports.extend({portchannel: portchannel_dict["inactivePorts"]})

    if not po_with_invactive_ports:
        self.result.is_success()
    else:
        self.result.is_failure(f"The following port-channels have inactive port(s): {po_with_invactive_ports}")

VerifySVI

Bases: AntaTest

Verifies there is no interface vlan down.

Source code in anta/tests/interfaces.py 
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
class VerifySVI(AntaTest):
    """
    Verifies there is no interface vlan down.
    """

    name = "VerifySVI"
    description = "Verifies there is no interface vlan down."
    categories = ["interfaces"]
    commands = [AntaCommand(command="show ip interface brief")]

    @AntaTest.anta_test
    def test(self) -> None:
        """Run VerifySVI validation"""

        command_output = self.instance_commands[0].json_output

        down_svis = []

        for interface in command_output["interfaces"]:
            interface_dict = command_output["interfaces"][interface]
            if "Vlan" in interface:
                if not (interface_dict["lineProtocolStatus"] == "up" and interface_dict["interfaceStatus"] == "connected"):
                    down_svis.append(interface)

        if len(down_svis) == 0:
            self.result.is_success()
        else:
            self.result.is_failure(f"The following SVIs are not up: {down_svis}")

test 

test() -> None

Run VerifySVI validation

Source code in anta/tests/interfaces.py 
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
@AntaTest.anta_test
def test(self) -> None:
    """Run VerifySVI validation"""

    command_output = self.instance_commands[0].json_output

    down_svis = []

    for interface in command_output["interfaces"]:
        interface_dict = command_output["interfaces"][interface]
        if "Vlan" in interface:
            if not (interface_dict["lineProtocolStatus"] == "up" and interface_dict["interfaceStatus"] == "connected"):
                down_svis.append(interface)

    if len(down_svis) == 0:
        self.result.is_success()
    else:
        self.result.is_failure(f"The following SVIs are not up: {down_svis}")

VerifyStormControlDrops

Bases: AntaTest

Verifies the device did not drop packets due its to storm-control configuration.

Source code in anta/tests/interfaces.py 
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
class VerifyStormControlDrops(AntaTest):
    """
    Verifies the device did not drop packets due its to storm-control configuration.
    """

    name = "VerifyStormControlDrops"
    description = "Verifies the device did not drop packets due its to storm-control configuration."
    categories = ["interfaces"]
    commands = [AntaCommand(command="show storm-control")]

    @skip_on_platforms(["cEOSLab", "vEOS-lab"])
    @AntaTest.anta_test
    def test(self) -> None:
        """Run VerifyStormControlDrops validation"""

        command_output = self.instance_commands[0].json_output

        storm_controlled_interfaces: Dict[str, Dict[str, Any]] = {}
        for interface, interface_dict in command_output["interfaces"].items():
            for traffic_type, traffic_type_dict in interface_dict["trafficTypes"].items():
                if "drop" in traffic_type_dict and traffic_type_dict["drop"] != 0:
                    storm_controlled_interface_dict = storm_controlled_interfaces.setdefault(interface, {})
                    storm_controlled_interface_dict.update({traffic_type: traffic_type_dict["drop"]})

        if not storm_controlled_interfaces:
            self.result.is_success()
        else:
            self.result.is_failure(f"The following interfaces have none 0 storm-control drop counters {storm_controlled_interfaces}")

test 

test() -> None

Run VerifyStormControlDrops validation

Source code in anta/tests/interfaces.py 
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
@skip_on_platforms(["cEOSLab", "vEOS-lab"])
@AntaTest.anta_test
def test(self) -> None:
    """Run VerifyStormControlDrops validation"""

    command_output = self.instance_commands[0].json_output

    storm_controlled_interfaces: Dict[str, Dict[str, Any]] = {}
    for interface, interface_dict in command_output["interfaces"].items():
        for traffic_type, traffic_type_dict in interface_dict["trafficTypes"].items():
            if "drop" in traffic_type_dict and traffic_type_dict["drop"] != 0:
                storm_controlled_interface_dict = storm_controlled_interfaces.setdefault(interface, {})
                storm_controlled_interface_dict.update({traffic_type: traffic_type_dict["drop"]})

    if not storm_controlled_interfaces:
        self.result.is_success()
    else:
        self.result.is_failure(f"The following interfaces have none 0 storm-control drop counters {storm_controlled_interfaces}")
Last update: July 19, 2023