ANTA is a Python library that can be used in user applications. This section describes how you can leverage ANTA Python modules to help you create your own NRFU solution.
+Tip
+If you are unfamiliar with asyncio, refer to the Python documentation relevant to your Python version - https://docs.python.org/3/library/asyncio.html
+A device is represented in ANTA as a instance of a subclass of the AntaDevice abstract class. +There are few abstract methods that needs to be implemented by child classes:
+The copy() coroutine is used to copy files to and from the device. It does not need to be implemented if tests are not using it.
+The AsyncEOSDevice class is an implementation of AntaDevice for Arista EOS. +It uses the aio-eapi eAPI client and the AsyncSSH library.
+is_online attribute accordingly. If the TCP connection succeeds, it sends a show version command to gather the hardware model of the device and updates the established and hw_model attributes.The AntaInventory class is a subclass of the standard Python type dict. The keys of this dictionary are the device names, the values are AntaDevice instances.
+AntaInventory provides methods to interact with the ANTA inventory:
+To parse a YAML inventory file and print the devices connection status:
+"""
+Example
+"""
+import asyncio
+
+from anta.inventory import AntaInventory
+
+
+async def main(inv: AntaInventory) -> None:
+ """
+ Take an AntaInventory and:
+ 1. try to connect to every device in the inventory
+ 2. print a message for every device connection status
+ """
+ await inv.connect_inventory()
+
+ for device in inv.values():
+ if device.established:
+ print(f"Device {device.name} is online")
+ else:
+ print(f"Could not connect to device {device.name}")
+
+if __name__ == "__main__":
+ # Create the AntaInventory instance
+ inventory = AntaInventory.parse(
+ filename="inv.yml",
+ username="arista",
+ password="@rista123",
+ timeout=15,
+ )
+
+ # Run the main coroutine
+ res = asyncio.run(main(inventory))
+Please visit this dedicated section for how to use inventory and catalog files.
+To run an EOS commands list on the reachable devices from the inventory: +
"""
+Example
+"""
+# This is needed to run the script for python < 3.10 for typing annotations
+from __future__ import annotations
+
+import asyncio
+from pprint import pprint
+
+from anta.inventory import AntaInventory
+from anta.models import AntaCommand
+
+
+async def main(inv: AntaInventory, commands: list[str]) -> dict[str, list[AntaCommand]]:
+ """
+ Take an AntaInventory and a list of commands as string and:
+ 1. try to connect to every device in the inventory
+ 2. collect the results of the commands from each device
+
+ Returns:
+ a dictionary where key is the device name and the value is the list of AntaCommand ran towards the device
+ """
+ await inv.connect_inventory()
+
+ # Make a list of coroutine to run commands towards each connected device
+ coros = []
+ # dict to keep track of the commands per device
+ result_dict = {}
+ for name, device in inv.get_inventory(established_only=True).items():
+ anta_commands = [AntaCommand(command=command, ofmt="json") for command in commands]
+ result_dict[name] = anta_commands
+ coros.append(device.collect_commands(anta_commands))
+
+ # Run the coroutines
+ await asyncio.gather(*coros)
+
+ return result_dict
+
+
+if __name__ == "__main__":
+ # Create the AntaInventory instance
+ inventory = AntaInventory.parse(
+ filename="inv.yml",
+ username="arista",
+ password="@rista123",
+ timeout=15,
+ )
+
+ # Create a list of commands with json output
+ commands = ["show version", "show ip bgp summary"]
+
+ # Run the main asyncio entry point
+ res = asyncio.run(main(inventory, commands))
+
+ pprint(res)
+All the test classes inherit from the same abstract Base Class AntaTest. The Class definition indicates which commands are required for the test and the user should focus only on writing the test function with optional keywords argument. The instance of the class upon creation instantiates a TestResult object that can be accessed later on to check the status of the test ([unset, skipped, success, failure, error]).
All tests are built on a class named AntaTest which provides a complete toolset for a test:
This approach means each time you create a test it will be based on this AntaTest class. Besides that, you will have to provide some elements:
name: Name of the testdescription: A human readable description of your testcategories: a list of categories to sort test.commands: a list of command to run. This list must be a list of AntaCommand which is described in the next part of this document.Here is an example of a hardware test related to device temperature:
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Optional, cast
+
+from anta.models import AntaTest, AntaCommand
+
+
+class VerifyTemperature(AntaTest):
+ """
+ Verifies device temparture is currently OK.
+ """
+
+ # The test name
+ name = "VerifyTemperature"
+ # A small description of the test, usually the first line of the class docstring
+ description = "Verifies device temparture is currently OK"
+ # The category of the test, usually the module name
+ categories = ["hardware"]
+ # The command(s) used for the test. Could be a template instead
+ commands = [AntaCommand(command="show system environment temperature", ofmt="json")]
+
+ # Decorator
+ @AntaTest.anta_test
+ # abstract method that must be defined by the child Test class
+ def test(self) -> None:
+ """Run VerifyTemperature validation"""
+ command_output = cast(Dict[str, Dict[Any, Any]], self.instance_commands[0].output)
+ temperature_status = command_output["systemStatus"] if "systemStatus" in command_output.keys() else ""
+ if temperature_status == "temperatureOk":
+ self.result.is_success()
+ else:
+ self.result.is_failure(f"Device temperature is not OK, systemStatus: {temperature_status }")
+When you run the test, object will automatically call its anta.models.AntaTest.collect() method to get device output for each command if no pre-collected data was given to the test. This method does a loop to call anta.inventory.models.InventoryDevice.collect() methods which is in charge of managing device connection and how to get data.
You can also pass eos data directly to your test if you want to validate data collected in a different workflow. An example is provided below just for information:
+test = VerifyTemperature(device, eos_data=test_data["eos_data"])
+asyncio.run(test.test())
+The test function is always the same and must be defined with the @AntaTest.anta_test decorator. This function takes at least one argument which is a anta.inventory.models.InventoryDevice object.
+In some cases a test would rely on some additional inputs from the user, for instance the number of expected peers or some expected numbers. All parameters must come with a default value and the test function should validate the parameters values (at this stage this is the only place where validation can be done but there are future plans to make this better).
class VerifyTemperature(AntaTest):
+ ...
+ @AntaTest.anta_test
+ def test(self) -> None:
+ pass
+
+class VerifyTransceiversManufacturers(AntaTest):
+ ...
+ @AntaTest.anta_test
+ def test(self, manufacturers: Optional[List[str]] = None) -> None:
+ # validate the manufactures parameter
+ pass
+The test itself does not return any value, but the result is directly availble from your AntaTest object and exposes a anta.result_manager.models.TestResult object with result, name of the test and optional messages:
name (str): Device name where the test has run.test (str): Test name runs on the device.categories (List[str]): List of categories the TestResult belongs to, by default the AntaTest categories.description (str): TestResult description, by default the AntaTest description.results (str): Result of the test. Can be one of [“unset”, “success”, “failure”, “error”, “skipped”].message (str, optional): Message to report after the test if any.custom_field (str, optional): Custom field to store a string for flexibility in integrating with ANTAfrom anta.tests.hardware import VerifyTemperature
+
+test = VerifyTemperature(device, eos_data=test_data["eos_data"])
+asyncio.run(test.test())
+assert test.result.result == "success"
+To make it easier to get data, ANTA defines 2 different classes to manage commands to send to devices:
+Represent a command with following information:
+Usage example:
+from anta.models import AntaCommand
+
+cmd1 = AntaCommand(command="show zerotouch")
+cmd2 = AntaCommand(command="show running-config diffs", ofmt="text")
+Command revision and version
+text outformat sometimes.1 and latest.version=1 in eAPI calls.ANTA uses by default version="latest" in AntaCommand. For some commands, you may want to run them with a different revision or version.
For instance the VerifyRoutingTableSize test leverages the first revision of show bfd peers:
# revision 1 as later revision introduce additional nesting for type
+commands = [AntaCommand(command="show bfd peers", revision=1)]
+Because some command can require more dynamic than just a command with no parameter provided by user, ANTA supports command template: you define a template in your test class and user provide parameters when creating test object.
+class RunArbitraryTemplateCommand(AntaTest):
+ """
+ Run an EOS command and return result
+ Based on AntaTest to build relevant output for pytest
+ """
+
+ name = "Run aributrary EOS command"
+ description = "To be used only with anta debug commands"
+ template = AntaTemplate(template="show interfaces {ifd}")
+ categories = ["debug"]
+
+ @AntaTest.anta_test
+ def test(self) -> None:
+ errdisabled_interfaces = [interface for interface, value in response["interfaceStatuses"].items() if value["linkStatus"] == "errdisabled"]
+ ...
+
+
+params = [{"ifd": "Ethernet2"}, {"ifd": "Ethernet49/1"}]
+run_command1 = RunArbitraryTemplateCommand(device_anta, params)
+In this example, test waits for interfaces to check from user setup and will only check for interfaces in params
ANTA is a streamlined Python framework designed for efficient interaction with network devices. This section outlines how ANTA incorporates caching mechanisms to collect command outputs from network devices.
+By default, ANTA utilizes aiocache’s memory cache backend, also called SimpleMemoryCache. This library aims for simplicity and supports asynchronous operations to go along with Python asyncio used in ANTA.
The _init_cache() method of the AntaDevice abstract class initializes the cache. Child classes can override this method to tweak the cache configuration:
def _init_cache(self) -> None:
+ """
+ Initialize cache for the device, can be overridden by subclasses to manipulate how it works
+ """
+ self.cache = Cache(cache_class=Cache.MEMORY, ttl=60, namespace=self.name, plugins=[HitMissRatioPlugin()])
+ self.cache_locks = defaultdict(asyncio.Lock)
+The cache is also configured with aiocache’s HitMissRatioPlugin plugin to calculate the ratio of hits the cache has and give useful statistics for logging purposes in ANTA.
The cache is initialized per AntaDevice and uses the following cache key design:
<device_name>:<uid>
The uid is an attribute of AntaCommand, which is a unique identifier generated from the command, version, revision and output format.
Each UID has its own asyncio lock. This design allows coroutines that need to access the cache for different UIDs to do so concurrently. The locks are managed by the self.cache_locks dictionary.
By default, once the cache is initialized, it is used in the collect() method of AntaDevice. The collect() method prioritizes retrieving the output of the command from the cache. If the output is not in the cache, the private _collect() method will retrieve and then store it for future access.
Caching is enabled by default in ANTA following the previous configuration and mechanisms.
+There might be scenarios where caching is not wanted. You can disable caching in multiple ways in ANTA:
+--disable-cache global flag when invoking anta at the CLI:
+ anta --disable-cache --username arista --password arista nrfu table
+Caching can be disabled per device, network or range by setting the disable_cache key to True when definining the ANTA Inventory file:
+
anta_inventory:
+ hosts:
+ - host: 172.20.20.101
+ name: DC1-SPINE1
+ tags: ["SPINE", "DC1"]
+ disable_cache: True # Set this key to True
+ - host: 172.20.20.102
+ name: DC1-SPINE2
+ tags: ["SPINE", "DC1"]
+ disable_cache: False # Optional since it's the default
+
+ networks:
+ - network: "172.21.21.0/24"
+ disable_cache: True
+
+ ranges:
+ - start: 172.22.22.10
+ end: 172.22.22.19
+ disable_cache: True
+disable_cache key.
+For tests developpers, caching can be disabled for a specific AntaCommand or AntaTemplate by setting the use_cache attribute to False. That means the command output will always be collected on the device and therefore, never use caching.
AntaDevice¶Since caching is implemented at the AntaDevice abstract class level, all subclasses will inherit that default behavior. As a result, if you need to disable caching in any custom implementation of AntaDevice outside of the ANTA framework, you must initialize AntaDevice with disable_cache set to True:
class AnsibleEOSDevice(AntaDevice):
+ """
+ Implementation of an AntaDevice using Ansible HttpApi plugin for EOS.
+ """
+ def __init__(self, name: str, connection: ConnectionBase, tags: list = None) -> None:
+ super().__init__(name, tags, disable_cache=True)
+This documentation applies for both creating tests in ANTA or creating your own test package.
+ANTA is not only a Python library with a CLI and a collection of built-in tests, it is also a framework you can extend by building your own tests.
+A test is a Python class where a test function is defined and will be run by the framework.
+ANTA provides an abstract class AntaTest. This class does the heavy lifting and provide the logic to define, collect and test data. The code below is an example of a simple test in ANTA, which is an AntaTest subclass:
+from anta.models import AntaTest, AntaCommand
+from anta.decorators import skip_on_platforms
+
+
+class VerifyTemperature(AntaTest):
+ """
+ This test verifies if the device temperature is within acceptable limits.
+
+ Expected Results:
+ * success: The test will pass if the device temperature is currently OK: 'temperatureOk'.
+ * failure: The test will fail if the device temperature is NOT OK.
+ """
+
+ name = "VerifyTemperature"
+ description = "Verifies if the device temperature is within the acceptable range."
+ categories = ["hardware"]
+ commands = [AntaCommand(command="show system environment temperature", ofmt="json")]
+
+ @skip_on_platforms(["cEOSLab", "vEOS-lab"])
+ @AntaTest.anta_test
+ def test(self) -> None:
+ command_output = self.instance_commands[0].json_output
+ temperature_status = command_output["systemStatus"] if "systemStatus" in command_output.keys() else ""
+ if temperature_status == "temperatureOk":
+ self.result.is_success()
+ else:
+ self.result.is_failure(f"Device temperature exceeds acceptable limits. Current system status: '{temperature_status}'")
+AntaTest also provide more advanced capabilities like AntaCommand templating using the AntaTemplate class or test inputs definition and validation using AntaTest.Input pydantic model. This will be discussed in the sections below.
+name (str): Name of the test. Used during reporting.description (str): A human readable description of your test.categories (list[str]): A list of categories in which the test belongs.commands (list[Union[AntaTemplate, AntaCommand]]): A list of command to collect from devices. This list must be a list of AntaCommand or AntaTemplate instances. Rendering AntaTemplate instances will be discussed later.Info
+All these class attributes are mandatory. If any attribute is missing, a NotImplementedError exception will be raised during class instantiation.
Info
+You can access an instance attribute in your code using the self reference. E.g. you can access the test input values using self.inputs.
Logger object
+ANTA already provides comprehensive logging at every steps of a test execution. The AntaTest class also provides a logger attribute that is a Python logger specific to the test instance. See Python documentation for more information.
AntaDevice object
+Even if device is not a private attribute, you should not need to access this object in your code.
AntaTest.Input is a pydantic model that allow test developers to define their test inputs. pydantic provides out of the box error handling for test input validation based on the type hints defined by the test developer.
+The base definition of AntaTest.Input provides common test inputs for all AntaTest instances:
+Attributes:
+| Name | +Type | +Description | +
|---|---|---|
description |
+
+ Optional[str]
+ |
+
+
+
+ overwrite TestResult.description + |
+
categories |
+
+ Optional[List[str]]
+ |
+
+
+
+ overwrite TestResult.categories + |
+
custom_field |
+
+ Optional[str]
+ |
+
+
+
+ a free string that will be included in the TestResult object + |
+
Note
+The pydantic model is configured using the extra=forbid that will fail input validation if extra fields are provided.
instance_commands instance attribute, access the test inputs using the inputs instance attribute and must set the result instance attribute accordingly. It must be implemented using the AntaTest.anta_test decorator that provides logging and will collect commands before executing the test() method.commands class attribute. It will be called for every AntaTemplate occurence and must return a list of AntaCommand using the AntaTemplate.render() method. It can access test inputs using the inputs instance attribute.Below is a high level description of the test execution flow in ANTA:
+ANTA will parse the test catalog to get the list of AntaTest subclasses to instantiate and their associated input values. We consider a single AntaTest subclass in the following steps.
+ANTA will instantiate the AntaTest subclass and a single device will be provided to the test instance. The Input model defined in the class will also be instantiated at this moment. If any ValidationError is raised, the test execution will be stopped.
If there is any AntaTemplate instance in the commands class attribute, render() will be called for every occurrence. At this moment, the instance_commands attribute has been initialized. If any rendering error occurs, the test execution will be stopped.
The AntaTest.anta_test decorator will collect the commands from the device and update the instance_commands attribute with the outputs. If any collection error occurs, the test execution will be stopped.
The test() method is executed.
+In this section, we will go into all the details of writing an AntaTest subclass.
+Import anta.models.AntaTest and define your own class. +Define the mandatory class attributes using anta.models.AntaCommand, anta.models.AntaTemplate or both.
+Info
+Caching can be disabled per AntaCommand or AntaTemplate by setting the use_cache argument to False. For more details about how caching is implemented in ANTA, please refer to Caching in ANTA.
from anta.models import AntaTest, AntaCommand, AntaTemplate
+
+
+class <YourTestName>(AntaTest):
+ """
+ <a docstring description of your test>
+ """
+
+ name = "YourTestName" # should be your class name
+ description = "<test description in human reading format>"
+ categories = ["<arbitrary category>", "<another arbitrary category>"]
+ commands = [
+ AntaCommand(
+ command="<EOS command to run>",
+ ofmt="<command format output>",
+ version="<eAPI version to use>",
+ revision="<revision to use for the command>", # revision has precedence over version
+ use_cache="<Use cache for the command>",
+ ),
+ AntaTemplate(
+ template="<Python f-string to render an EOS command>",
+ ofmt="<command format output>",
+ version="<eAPI version to use>",
+ revision="<revision to use for the command>", # revision has precedence over version
+ use_cache="<Use cache for the command>",
+ )
+ ]
+If the user needs to provide inputs for your test, you need to define a pydantic model that defines the schema of the test inputs:
+class <YourTestName>(AntaTest):
+ ...
+ class Input(AntaTest.Input): # pylint: disable=missing-class-docstring
+ <input field name>: <input field type>
+ """<input field docstring>"""
+To define an input field type, refer to the pydantic documentation about types. +You can also leverage anta.custom_types that provides reusable types defined in ANTA tests.
+Regarding required, optional and nullable fields, refer to this documentation on how to define them.
+Note
+All the pydantic features are supported. For instance you can define validators for complex input validation.
Define the render() method if you have AntaTemplate instances in your commands class attribute:
class <YourTestName>(AntaTest):
+ ...
+ def render(self, template: AntaTemplate) -> list[AntaCommand]:
+ return [template.render(<template param>=input_value) for input_value in self.inputs.<input_field>]
+You can access test inputs and render as many AntaCommand as desired.
+Implement the test() method with your test logic:
class <YourTestName>(AntaTest):
+ ...
+ @AntaTest.anta_test
+ def test(self) -> None:
+ pass
+The logic usually includes the following different stages:
+1. Parse the command outputs using the self.instance_commands instance attribute.
+2. If needed, access the test inputs using the self.inputs instance attribute and write your conditional logic.
+3. Set the result instance attribute to reflect the test result by either calling self.result.is_success() or self.result.is_failure("<FAILURE REASON>"). Sometimes, setting the test result to skipped using self.result.is_skipped("<SKIPPED REASON>") can make sense (e.g. testing the OSPF neighbor states but no neighbor was found). However, you should not need to catch any exception and set the test result to error since the error handling is done by the framework, see below.
The example below is based on the VerifyTemperature test.
+class VerifyTemperature(AntaTest):
+ ...
+ @AntaTest.anta_test
+ def test(self) -> None:
+ # Grab output of the collected command
+ command_output = self.instance_commands[0].json_output
+
+ # Do your test: In this example we check a specific field of the JSON output from EOS
+ temperature_status = command_output["systemStatus"] if "systemStatus" in command_output.keys() else ""
+ if temperature_status == "temperatureOk":
+ self.result.is_success()
+ else:
+ self.result.is_failure(f"Device temperature exceeds acceptable limits. Current system status: '{temperature_status}'")
+As you can see there is no error handling to do in your code. Everything is packaged in the AntaTest.anta_tests decorator and below is a simple example of error captured when trying to access a dictionary with an incorrect key:
class VerifyTemperature(AntaTest):
+ ...
+ @AntaTest.anta_test
+ def test(self) -> None:
+ # Grab output of the collected command
+ command_output = self.instance_commands[0].json_output
+
+ # Access the dictionary with an incorrect key
+ command_output['incorrectKey']
+ERROR Exception raised for test VerifyTemperature (on device 192.168.0.10) - KeyError ('incorrectKey')
+Get stack trace for debugging
+If you want to access to the full exception stack, you can run ANTA in debug mode by setting the ANTA_DEBUG environment variable to true. Example:
+
$ ANTA_DEBUG=true anta nrfu --catalog test_custom.yml text
+In addition to the required AntaTest.anta_tests decorator, ANTA offers a set of optional decorators for further test customization:
anta.decorators.deprecated_test: Use this to log a message of WARNING severity when a test is deprecated.anta.decorators.skip_on_platforms: Use this to skip tests for functionalities that are not supported on specific platforms.from anta.decorators import skip_on_platforms
+
+class VerifyTemperature(AntaTest):
+ ...
+ @skip_on_platforms(["cEOSLab", "vEOS-lab"])
+ @AntaTest.anta_test
+ def test(self) -> None:
+ pass
+This section is required only if you are not merging your development into ANTA. Otherwise, just follow contribution guide.
+For that, you need to create your own Python package as described in this hitchhiker’s guide to package Python code. We assume it is well known and we won’t focus on this aspect. Thus, your package must be impartable by ANTA hence available in the module search path sys.path (you can use PYTHONPATH for example).
It is very similar to what is documented in catalog section but you have to use your own package name.2
+Let say the custom Python package is anta_titom73 and the test is defined in anta_titom73.dc_project Python module, the test catalog would look like:
anta_titom73.dc_project:
+ - VerifyFeatureX:
+ minimum: 1
+anta nrfu text --catalog test_custom.yml
+spine01 :: verify_dynamic_vlan :: FAILURE (Device has 0 configured, we expect at least 1)
+spine02 :: verify_dynamic_vlan :: FAILURE (Device has 0 configured, we expect at least 1)
+leaf01 :: verify_dynamic_vlan :: SUCCESS
+leaf02 :: verify_dynamic_vlan :: SUCCESS
+leaf03 :: verify_dynamic_vlan :: SUCCESS
+leaf04 :: verify_dynamic_vlan :: SUCCESS
+AntaCatalog(tests: list[AntaTestDefinition] | None = None, filename: str | Path | None = None)
+Class representing an ANTA Catalog.
+It can be instantiated using its contructor or one of the static methods: parse(), from_list() or from_dict()
Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
tests |
+
+ list[AntaTestDefinition] | None
+ |
+
+
+
+ A list of AntaTestDefinition instances. + |
+
+ None
+ |
+
filename |
+
+ str | Path | None
+ |
+
+
+
+ The path from which the catalog is loaded. + |
+
+ None
+ |
+
anta/catalog.py179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 | |
property
+
+
+¶filename: Path | None
+Path of the file used to create this AntaCatalog instance
+property
+ writable
+
+
+¶tests: list[AntaTestDefinition]
+List of AntaTestDefinition in this catalog
+staticmethod
+
+
+¶from_dict(data: RawCatalogInput, filename: str | Path | None = None) -> AntaCatalog
+Create an AntaCatalog instance from a dictionary data structure.
+See RawCatalogInput type alias for details.
+It is the data structure returned by yaml.load() function of a valid
+YAML Test Catalog file.
Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
data |
+
+ RawCatalogInput
+ |
+
+
+
+ Python dictionary used to instantiate the AntaCatalog instance + |
+ + required + | +
filename |
+
+ str | Path | None
+ |
+
+
+
+ value to be set as AntaCatalog instance attribute + |
+
+ None
+ |
+
anta/catalog.py234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 | |
staticmethod
+
+
+¶from_list(data: ListAntaTestTuples) -> AntaCatalog
+Create an AntaCatalog instance from a list data structure. +See ListAntaTestTuples type alias for details.
+ + + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
data |
+
+ ListAntaTestTuples
+ |
+
+
+
+ Python list used to instantiate the AntaCatalog instance + |
+ + required + | +
anta/catalog.py263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 | |
get_tests_by_tags(tags: list[str], strict: bool = False) -> list[AntaTestDefinition]
+Return all the tests that have matching tags in their input filters. +If strict=True, returns only tests that match all the tags provided as input. +If strict=False, return all the tests that match at least one tag provided as input.
+ +anta/catalog.py280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 | |
staticmethod
+
+
+¶parse(filename: str | Path) -> AntaCatalog
+Create an AntaCatalog instance from a test catalog file.
+ + + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
filename |
+
+ str | Path
+ |
+
+
+
+ Path to test catalog YAML file + |
+ + required + | +
anta/catalog.py216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 | |
AntaTestDefinition(**data: Any)
+
+ Bases: BaseModel
Define a test with its associated inputs.
+test: An AntaTest concrete subclass +inputs: The associated AntaTest.Input subclass instance
+ +anta/catalog.py45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 | |
check_inputs() -> 'AntaTestDefinition'
+The inputs class attribute needs to be an instance of the AntaTest.Input subclass defined in the class test.
anta/catalog.py81 +82 +83 +84 +85 +86 +87 +88 | |
classmethod
+
+
+¶instantiate_inputs(data: AntaTest.Input | dict[str, Any] | None, info: ValidationInfo) -> AntaTest.Input
+If the test has no inputs, allow the user to omit providing the inputs field.
+If the test has inputs, allow the user to provide a valid dictionary of the input fields.
+This model validator will instantiate an Input class from the test class field.
anta/catalog.py57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 | |
+ Bases: RootModel[Dict[ImportString[Any], List[AntaTestDefinition]]]
This model represents an ANTA Test Catalog File.
+A valid test catalog file must have the following structure:
+
classmethod
+
+
+¶check_tests(data: Any) -> Any
+Allow the user to provide a Python data structure that only has string values. +This validator will try to flatten and import Python modules, check if the tests classes +are actually defined in their respective Python module and instantiate Input instances +with provided value to validate test inputs.
+ +anta/catalog.py103 +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 +166 +167 +168 +169 | |
AntaDevice(name: str, tags: Optional[list[str]] = None, disable_cache: bool = False)
+
+ Bases: ABC
Abstract class representing a device in ANTA.
+An implementation of this class must override the abstract coroutines _collect() and
+refresh().
Attributes:
+| Name | +Type | +Description | +
|---|---|---|
name |
+
+ str
+ |
+
+
+
+ Device name + |
+
is_online |
+
+ bool
+ |
+
+
+
+ True if the device IP is reachable and a port can be open + |
+
established |
+
+ bool
+ |
+
+
+
+ True if remote command execution succeeds + |
+
hw_model |
+
+ Optional[str]
+ |
+
+
+
+ Hardware model of the device + |
+
tags |
+
+ list[str]
+ |
+
+
+
+ List of tags for this device + |
+
cache |
+
+ Optional[Cache]
+ |
+
+
+
+ In-memory cache from aiocache library for this device (None if cache is disabled) + |
+
cache_locks |
+
+ Optional[defaultdict[str, Lock]]
+ |
+
+
+
+ Dictionary mapping keys to asyncio locks to guarantee exclusive access to the cache if not disabled + |
+
Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
name |
+
+ str
+ |
+
+
+
+ Device name + |
+ + required + | +
tags |
+
+ Optional[list[str]]
+ |
+
+
+
+ List of tags for this device + |
+
+ None
+ |
+
disable_cache |
+
+ bool
+ |
+
+
+
+ Disable caching for all commands for this device. Defaults to False. + |
+
+ False
+ |
+
anta/device.py45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 | |
property
+
+
+¶cache_statistics: dict[str, Any] | None
+Returns the device cache statistics for logging purposes
+__hash__() -> int
+Implement hashing for AntaDevice objects.
+ +anta/device.py81 +82 +83 +84 +85 | |
async
+
+
+¶collect(command: AntaCommand) -> None
+Collects the output for a specified command.
+When caching is activated on both the device and the command, +this method prioritizes retrieving the output from the cache. In cases where the output isn’t cached yet, +it will be freshly collected and then stored in the cache for future access. +The method employs asynchronous locks based on the command’s UID to guarantee exclusive access to the cache.
+When caching is NOT enabled, either at the device or command level, the method directly collects the output
+via the private _collect method without interacting with the cache.
Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
command |
+
+ AntaCommand
+ |
+
+
+
+ The command to process. + |
+ + required + | +
anta/device.py136 +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 | |
async
+
+
+¶collect_commands(commands: list[AntaCommand]) -> None
+Collect multiple commands.
+ + + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
commands |
+
+ list[AntaCommand]
+ |
+
+
+
+ the commands to collect + |
+ + required + | +
anta/device.py166 +167 +168 +169 +170 +171 +172 +173 | |
async
+
+
+¶copy(sources: list[Path], destination: Path, direction: Literal['to', 'from'] = 'from') -> None
+Copy files to and from the device, usually through SCP. +It is not mandatory to implement this for a valid AntaDevice subclass.
+ + + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
sources |
+
+ list[Path]
+ |
+
+
+
+ List of files to copy to or from the device. + |
+ + required + | +
destination |
+
+ Path
+ |
+
+
+
+ Local or remote destination when copying the files. Can be a folder. + |
+ + required + | +
direction |
+
+ Literal['to', 'from']
+ |
+
+
+
+ Defines if this coroutine copies files to or from the device. + |
+
+ 'from'
+ |
+
anta/device.py194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 | |
abstractmethod
+ async
+
+
+¶refresh() -> None
+Update attributes of an AntaDevice instance.
+ +is_online: When the device IP is reachable and a port can be openestablished: When a command execution succeedshw_model: The hardware model of the deviceanta/device.py183 +184 +185 +186 +187 +188 +189 +190 +191 +192 | |
supports(command: AntaCommand) -> bool
+Returns True if the command is supported on the device hardware platform, False otherwise.
+ +anta/device.py175 +176 +177 +178 +179 +180 +181 | |
AsyncEOSDevice(host: str, username: str, password: str, name: Optional[str] = None, enable: bool = False, enable_password: Optional[str] = None, port: Optional[int] = None, ssh_port: Optional[int] = 22, tags: Optional[list[str]] = None, timeout: Optional[float] = None, insecure: bool = False, proto: Literal['http', 'https'] = 'https', disable_cache: bool = False)
+
+ Bases: AntaDevice
Implementation of AntaDevice for EOS using aio-eapi.
+ + + +Attributes:
+| Name | +Type | +Description | +
|---|---|---|
name |
+ + | +
+
+
+ Device name + |
+
is_online |
+ + | +
+
+
+ True if the device IP is reachable and a port can be open + |
+
established |
+ + | +
+
+
+ True if remote command execution succeeds + |
+
hw_model |
+ + | +
+
+
+ Hardware model of the device + |
+
tags |
+ + | +
+
+
+ List of tags for this device + |
+
Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
host |
+
+ str
+ |
+
+
+
+ Device FQDN or IP + |
+ + required + | +
username |
+
+ str
+ |
+
+
+
+ Username to connect to eAPI and SSH + |
+ + required + | +
password |
+
+ str
+ |
+
+
+
+ Password to connect to eAPI and SSH + |
+ + required + | +
name |
+
+ Optional[str]
+ |
+
+
+
+ Device name + |
+
+ None
+ |
+
enable |
+
+ bool
+ |
+
+
+
+ Device needs privileged access + |
+
+ False
+ |
+
enable_password |
+
+ Optional[str]
+ |
+
+
+
+ Password used to gain privileged access on EOS + |
+
+ None
+ |
+
port |
+
+ Optional[int]
+ |
+
+
+
+ eAPI port. Defaults to 80 is proto is ‘http’ or 443 if proto is ‘https’. + |
+
+ None
+ |
+
ssh_port |
+
+ Optional[int]
+ |
+
+
+
+ SSH port + |
+
+ 22
+ |
+
tags |
+
+ Optional[list[str]]
+ |
+
+
+
+ List of tags for this device + |
+
+ None
+ |
+
timeout |
+
+ Optional[float]
+ |
+
+
+
+ Timeout value in seconds for outgoing connections. Default to 10 secs. + |
+
+ None
+ |
+
insecure |
+
+ bool
+ |
+
+
+
+ Disable SSH Host Key validation + |
+
+ False
+ |
+
proto |
+
+ Literal['http', 'https']
+ |
+
+
+
+ eAPI protocol. Value can be ‘http’ or ‘https’ + |
+
+ 'https'
+ |
+
disable_cache |
+
+ bool
+ |
+
+
+
+ Disable caching for all commands for this device. Defaults to False. + |
+
+ False
+ |
+
anta/device.py219 +220 +221 +222 +223 +224 +225 +226 +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 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 | |
async
+
+
+¶copy(sources: list[Path], destination: Path, direction: Literal['to', 'from'] = 'from') -> None
+Copy files to and from the device using asyncssh.scp().
+ + + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
sources |
+
+ list[Path]
+ |
+
+
+
+ List of files to copy to or from the device. + |
+ + required + | +
destination |
+
+ Path
+ |
+
+
+
+ Local or remote destination when copying the files. Can be a folder. + |
+ + required + | +
direction |
+
+ Literal['to', 'from']
+ |
+
+
+
+ Defines if this coroutine copies files to or from the device. + |
+
+ 'from'
+ |
+
anta/device.py382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 | |
async
+
+
+¶refresh() -> None
+Update attributes of an AsyncEOSDevice instance.
+This coroutine must update the following attributes of AsyncEOSDevice: +- is_online: When a device IP is reachable and a port can be open +- established: When a command execution succeeds +- hw_model: The hardware model of the device
+ +anta/device.py349 +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 | |
+ Bases: BaseModel
User’s inventory model.
+ + + +Attributes:
+| Name | +Type | +Description | +
|---|---|---|
networks |
+
+ (list[AntaInventoryNetwork], Optional)
+ |
+
+
+
+ List of AntaInventoryNetwork objects for networks. + |
+
hosts |
+
+ (list[AntaInventoryHost], Optional)
+ |
+
+
+
+ List of AntaInventoryHost objects for hosts. + |
+
range |
+
+ (list[AntaInventoryRange], Optional)
+ |
+
+
+
+ List of AntaInventoryRange objects for ranges. + |
+
+ Bases: BaseModel
Host definition for user’s inventory.
+ + + +Attributes:
+| Name | +Type | +Description | +
|---|---|---|
host |
+
+ IPvAnyAddress
+ |
+
+
+
+ IPv4 or IPv6 address of the device + |
+
port |
+
+ int
+ |
+
+
+
+ (Optional) eAPI port to use Default is 443. + |
+
name |
+
+ str
+ |
+
+
+
+ (Optional) Name to display during tests report. Default is hostname:port + |
+
tags |
+
+ list[str]
+ |
+
+
+
+ List of attached tags read from inventory file. + |
+
disable_cache |
+
+ bool
+ |
+
+
+
+ Disable cache per host. Defaults to False. + |
+
+ Bases: BaseModel
Network definition for user’s inventory.
+ + + +Attributes:
+| Name | +Type | +Description | +
|---|---|---|
network |
+
+ IPvAnyNetwork
+ |
+
+
+
+ Subnet to use for testing. + |
+
tags |
+
+ list[str]
+ |
+
+
+
+ List of attached tags read from inventory file. + |
+
disable_cache |
+
+ bool
+ |
+
+
+
+ Disable cache per network. Defaults to False. + |
+
+ Bases: BaseModel
IP Range definition for user’s inventory.
+ + + +Attributes:
+| Name | +Type | +Description | +
|---|---|---|
start |
+
+ IPvAnyAddress
+ |
+
+
+
+ IPv4 or IPv6 address for the begining of the range. + |
+
stop |
+
+ IPvAnyAddress
+ |
+
+
+
+ IPv4 or IPv6 address for the end of the range. + |
+
tags |
+
+ list[str]
+ |
+
+
+
+ List of attached tags read from inventory file. + |
+
disable_cache |
+
+ bool
+ |
+
+
+
+ Disable cache per range of hosts. Defaults to False. + |
+
+ Bases: dict
Inventory abstraction for ANTA framework.
+ + + + +add_device(device: AntaDevice) -> None
+Add a device to final inventory.
+ + + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
device |
+
+ AntaDevice
+ |
+
+
+
+ Device object to be added + |
+ + required + | +
anta/inventory/__init__.py260 +261 +262 +263 +264 +265 +266 | |
async
+
+
+¶connect_inventory() -> None
+Run refresh() coroutines for all AntaDevice objects in this inventory.
anta/inventory/__init__.py272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 | |
get_inventory(established_only: bool = False, tags: Optional[list[str]] = None) -> AntaInventory
+Returns a filtered inventory.
+ + + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
established_only |
+
+ bool
+ |
+
+
+
+ Whether or not to include only established devices. Default False. + |
+
+ False
+ |
+
tags |
+
+ Optional[list[str]]
+ |
+
+
+
+ List of tags to filter devices. + |
+
+ None
+ |
+
Returns:
+| Name | Type | +Description | +
|---|---|---|
AntaInventory |
+ AntaInventory
+ |
+
+
+
+ An inventory with filtered AntaDevice objects. + |
+
anta/inventory/__init__.py224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 | |
staticmethod
+
+
+¶parse(filename: str | Path, username: str, password: str, enable: bool = False, enable_password: Optional[str] = None, timeout: Optional[float] = None, insecure: bool = False, disable_cache: bool = False) -> AntaInventory
+Create an AntaInventory instance from an inventory file. +The inventory devices are AsyncEOSDevice instances.
+ + + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
filename |
+
+ str
+ |
+
+
+
+ Path to device inventory YAML file + |
+ + required + | +
username |
+
+ str
+ |
+
+
+
+ Username to use to connect to devices + |
+ + required + | +
password |
+
+ str
+ |
+
+
+
+ Password to use to connect to devices + |
+ + required + | +
enable |
+
+ bool
+ |
+
+
+
+ Whether or not the commands need to be run in enable mode towards the devices + |
+
+ False
+ |
+
enable_password |
+
+ str
+ |
+
+
+
+ Enable password to use if required + |
+
+ None
+ |
+
timeout |
+
+ float
+ |
+
+
+
+ timeout in seconds for every API call. + |
+
+ None
+ |
+
insecure |
+
+ bool
+ |
+
+
+
+ Disable SSH Host Key validation + |
+
+ False
+ |
+
disable_cache |
+
+ bool
+ |
+
+
+
+ Disable cache globally + |
+
+ False
+ |
+
Raises:
+| Type | +Description | +
|---|---|
+ InventoryRootKeyError
+ |
+
+
+
+ Root key of inventory is missing. + |
+
+ InventoryIncorrectSchema
+ |
+
+
+
+ Inventory file is not following AntaInventory Schema. + |
+
anta/inventory/__init__.py140 +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 +167 +168 +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 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 | |
AntaTest(device: AntaDevice, inputs: dict[str, Any] | AntaTest.Input | None = None, eos_data: list[dict[Any, Any] | str] | None = None)
+
+ Bases: ABC
Abstract class defining a test in ANTA
+The goal of this class is to handle the heavy lifting and make +writing a test as simple as possible.
+ + + +Examples:
+ +The following is an example of an AntaTest subclass implementation: +
class VerifyReachability(AntaTest):
+ name = "VerifyReachability"
+ description = "Test the network reachability to one or many destination IP(s)."
+ categories = ["connectivity"]
+ commands = [AntaTemplate(template="ping vrf {vrf} {dst} source {src} repeat 2")]
+
+ class Input(AntaTest.Input):
+ hosts: list[Host]
+ class Host(BaseModel):
+ dst: IPv4Address
+ src: IPv4Address
+ vrf: str = "default"
+
+ def render(self, template: AntaTemplate) -> list[AntaCommand]:
+ return [template.render({"dst": host.dst, "src": host.src, "vrf": host.vrf}) for host in self.inputs.hosts]
+
+ @AntaTest.anta_test
+ def test(self) -> None:
+ failures = []
+ for command in self.instance_commands:
+ if command.params and ("src" and "dst") in command.params:
+ src, dst = command.params["src"], command.params["dst"]
+ if "2 received" not in command.json_output["messages"][0]:
+ failures.append((str(src), str(dst)))
+ if not failures:
+ self.result.is_success()
+ else:
+ self.result.is_failure(f"Connectivity test failed for the following source-destination pairs: {failures}")
+Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
device |
+
+ AntaDevice
+ |
+
+
+
+ AntaDevice instance on which the test will be run + |
+ + required + | +
inputs |
+
+ dict[str, Any] | Input | None
+ |
+
+
+
+ dictionary of attributes used to instantiate the AntaTest.Input instance + |
+
+ None
+ |
+
eos_data |
+
+ list[dict[Any, Any] | str] | None
+ |
+
+
+
+ Populate outputs of the test commands instead of collecting from devices.
+ This list must have the same length and order than the |
+
+ None
+ |
+
anta/models.py295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 | |
property
+
+
+¶blocked: bool
+Check if CLI commands contain a blocked keyword.
+property
+
+
+¶collected: bool
+Returns True if all commands for this test have been collected.
+property
+
+
+¶failed_commands: list[AntaCommand]
+Returns a list of all the commands that have failed.
+
+ Bases: BaseModel
Class defining inputs for a test in ANTA.
+ + + +Examples:
+ +A valid test catalog will look like the following: +
<Python module>:
+- <AntaTest subclass>:
+ result_overwrite:
+ categories:
+ - "Overwritten category 1"
+ description: "Test with overwritten description"
+ custom_field: "Test run by John Doe"
+
+ Bases: BaseModel
Test inputs model to overwrite result fields
+ + + +Attributes:
+| Name | +Type | +Description | +
|---|---|---|
description |
+
+ Optional[str]
+ |
+
+
+
+ overwrite TestResult.description + |
+
categories |
+
+ Optional[List[str]]
+ |
+
+
+
+ overwrite TestResult.categories + |
+
custom_field |
+
+ Optional[str]
+ |
+
+
+
+ a free string that will be included in the TestResult object + |
+
__hash__() -> int
+Implement generic hashing for AntaTest.Input. +This will work in most cases but this does not consider 2 lists with different ordering as equal.
+ +anta/models.py264 +265 +266 +267 +268 +269 | |
staticmethod
+
+
+¶anta_test(function: F) -> Callable[..., Coroutine[Any, Any, TestResult]]
+Decorator for the test() method.
This decorator implements (in this order):
+eos_data is provided to the test() methodtest() methodtest() user code and set the result instance attributeanta/models.py440 +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 +506 +507 +508 +509 +510 +511 +512 +513 +514 | |
async
+
+
+¶collect() -> None
+Method used to collect outputs of all commands of this test class from the device of this test instance.
+ +anta/models.py425 +426 +427 +428 +429 +430 +431 +432 +433 +434 +435 +436 +437 +438 | |
render(template: AntaTemplate) -> list[AntaCommand]
+Render an AntaTemplate instance of this AntaTest using the provided + AntaTest.Input instance at self.inputs.
+This is not an abstract method because it does not need to be implemented if there is +no AntaTemplate for this test.
+ +anta/models.py405 +406 +407 +408 +409 +410 +411 | |
save_commands_data(eos_data: list[dict[str, Any] | str]) -> None
+Populate output of all AntaCommand instances in instance_commands
anta/models.py377 +378 +379 +380 +381 +382 +383 +384 +385 +386 | |
abstractmethod
+
+
+¶test() -> Coroutine[Any, Any, TestResult]
+This abstract method is the core of the test logic.
+It must set the correct status of the result instance attribute
+with the appropriate outcome of the test.
Examples:
+ +It must be implemented using the AntaTest.anta_test decorator:
+
@AntaTest.anta_test
+def test(self) -> None:
+ self.result.is_success()
+ for command in self.instance_commands:
+ if not self._test_command(command): # _test_command() is an arbitrary test logic
+ self.result.is_failure("Failure reson")
+anta/models.py524 +525 +526 +527 +528 +529 +530 +531 +532 +533 +534 +535 +536 +537 +538 +539 +540 +541 | |
+
+ Bases: BaseModel
Class to define a command.
+Info
+eAPI models are revisioned, this means that if a model is modified in a non-backwards compatible way, then its revision will be bumped up +(revisions are numbers, default value is 1).
+By default an eAPI request will return revision 1 of the model instance, +this ensures that older management software will not suddenly stop working when a switch is upgraded. +A revision applies to a particular CLI command whereas a version is global and is internally +translated to a specific revision for each CLI command in the RPC.
+Revision has precedence over version.
+Attributes:
+| Name | +Type | +Description | +
|---|---|---|
command |
+
+ str
+ |
+
+
+
+ Device command + |
+
version |
+
+ Literal[1, 'latest']
+ |
+
+
+
+ eAPI version - valid values are 1 or “latest” - default is “latest” + |
+
revision |
+
+ Optional[conint(ge=1, le=99)]
+ |
+
+
+
+ eAPI revision of the command. Valid values are 1 to 99. Revision has precedence over version. + |
+
ofmt |
+
+ Literal['json', 'text']
+ |
+
+
+
+ eAPI output - json or text - default is json + |
+
output |
+
+ Optional[Union[Dict[str, Any], str]]
+ |
+
+
+
+ Output of the command populated by the collect() function + |
+
template |
+
+ Optional[AntaTemplate]
+ |
+
+
+
+ AntaTemplate object used to render this command + |
+
params |
+
+ Dict[str, Any]
+ |
+
+
+
+ Dictionary of variables with string values to render the template + |
+
errors |
+
+ List[str]
+ |
+
+
+
+ If the command execution fails, eAPI returns a list of strings detailing the error + |
+
use_cache |
+
+ bool
+ |
+
+
+
+ Enable or disable caching for this AntaCommand if the AntaDevice supports it - default is True + |
+
property
+
+
+¶collected: bool
+Return True if the command has been collected
+property
+
+
+¶json_output: dict[str, Any]
+Get the command output as JSON
+property
+
+
+¶text_output: str
+Get the command output as a string
+property
+
+
+¶uid: str
+Generate a unique identifier for this command
+Warning
+CLI commands are protected to avoid execution of critical commands such as reload or write erase.
^reload\s*\w*^conf\w*\s*(terminal|session)*^wr\w*\s*\w+
+ Bases: BaseModel
Class to define a command template as Python f-string. +Can render a command from parameters.
+ + + +Attributes:
+| Name | +Type | +Description | +
|---|---|---|
template |
+
+ str
+ |
+
+
+
+ Python f-string. Example: ‘show vlan {vlan_id}’ + |
+
version |
+
+ Literal[1, 'latest']
+ |
+
+
+
+ eAPI version - valid values are 1 or “latest” - default is “latest” + |
+
revision |
+
+ Optional[conint(ge=1, le=99)]
+ |
+
+
+
+ Revision of the command. Valid values are 1 to 99. Revision has precedence over version. + |
+
ofmt |
+
+ Literal['json', 'text']
+ |
+
+
+
+ eAPI output - json or text - default is json + |
+
use_cache |
+
+ bool
+ |
+
+
+
+ Enable or disable caching for this AntaTemplate if the AntaDevice supports it - default is True + |
+
render(**params: dict[str, Any]) -> AntaCommand
+Render an AntaCommand from an AntaTemplate instance. +Keep the parameters used in the AntaTemplate instance.
+ + + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
params |
+
+ dict[str, Any]
+ |
+
+
+
+ dictionary of variables with string values to render the Python f-string + |
+
+ {}
+ |
+
Returns:
+| Name | Type | +Description | +
|---|---|---|
command |
+ AntaCommand
+ |
+
+
+
+ The rendered AntaCommand. + This AntaCommand instance have a template attribute that references this + AntaTemplate instance. + |
+
anta/models.py76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 | |
TableReport Generate a Table based on TestResult.
+ + + + +report_all(result_manager: ResultManager, host: Optional[str] = None, testcase: Optional[str] = None, title: str = 'All tests results') -> Table
+Create a table report with all tests for one or all devices.
+Create table with full output: Host / Test / Status / Message
+ + + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
result_manager |
+
+ ResultManager
+ |
+
+
+
+ A manager with a list of tests. + |
+ + required + | +
host |
+
+ str
+ |
+
+
+
+ IP Address of a host to search for. Defaults to None. + |
+
+ None
+ |
+
testcase |
+
+ str
+ |
+
+
+
+ A test name to search for. Defaults to None. + |
+
+ None
+ |
+
title |
+
+ str
+ |
+
+
+
+ Title for the report. Defaults to ‘All tests results’. + |
+
+ 'All tests results'
+ |
+
Returns:
+| Name | Type | +Description | +
|---|---|---|
Table |
+ Table
+ |
+
+
+
+ A fully populated rich Table + |
+
anta/reporter/__init__.py79 + 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 | |
report_summary_hosts(result_manager: ResultManager, host: Optional[str] = None, title: str = 'Summary per host') -> Table
+Create a table report with result agregated per host.
+Create table with full output: Host / Number of success / Number of failure / Number of error / List of nodes in error or failure
+ + + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
result_manager |
+
+ ResultManager
+ |
+
+
+
+ A manager with a list of tests. + |
+ + required + | +
host |
+
+ str
+ |
+
+
+
+ IP Address of a host to search for. Defaults to None. + |
+
+ None
+ |
+
title |
+
+ str
+ |
+
+
+
+ Title for the report. Defaults to ‘All tests results’. + |
+
+ 'Summary per host'
+ |
+
Returns:
+| Name | Type | +Description | +
|---|---|---|
Table |
+ Table
+ |
+
+
+
+ A fully populated rich Table + |
+
anta/reporter/__init__.py161 +162 +163 +164 +165 +166 +167 +168 +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 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 | |
report_summary_tests(result_manager: ResultManager, testcase: Optional[str] = None, title: str = 'Summary per test case') -> Table
+Create a table report with result agregated per test.
+Create table with full output: Test / Number of success / Number of failure / Number of error / List of nodes in error or failure
+ + + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
result_manager |
+
+ ResultManager
+ |
+
+
+
+ A manager with a list of tests. + |
+ + required + | +
testcase |
+
+ str
+ |
+
+
+
+ A test name to search for. Defaults to None. + |
+
+ None
+ |
+
title |
+
+ str
+ |
+
+
+
+ Title for the report. Defaults to ‘All tests results’. + |
+
+ 'Summary per test case'
+ |
+
Returns:
+| Name | Type | +Description | +
|---|---|---|
Table |
+ Table
+ |
+
+
+
+ A fully populated rich Table + |
+
anta/reporter/__init__.py113 +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 | |
ResultManager()
+Helper to manage Test Results and generate reports.
+Examples:
+Create Inventory:
+
+ inventory_anta = AntaInventory.parse(
+ filename='examples/inventory.yml',
+ username='ansible',
+ password='ansible',
+ timeout=0.5
+ )
+
+Create Result Manager:
+
+ manager = ResultManager()
+
+Run tests for all connected devices:
+
+ for device in inventory_anta.get_inventory():
+ manager.add_test_result(
+ VerifyNTP(device=device).test()
+ )
+ manager.add_test_result(
+ VerifyEOSVersion(device=device).test(version='4.28.3M')
+ )
+
+Print result in native format:
+
+ manager.get_results()
+ [
+ TestResult(
+ host=IPv4Address('192.168.0.10'),
+ test='VerifyNTP',
+ result='failure',
+ message="device is not running NTP correctly"
+ ),
+ TestResult(
+ host=IPv4Address('192.168.0.10'),
+ test='VerifyEOSVersion',
+ result='success',
+ message=None
+ ),
+ ]
+The status of the class is initialized to “unset”
+Then when adding a test with a status that is NOT ‘error’ the following +table shows the updated status:
+| Current Status | +Added test Status | +Updated Status | +
|---|---|---|
| unset | +Any | +Any | +
| skipped | +unset, skipped | +skipped | +
| skipped | +success | +success | +
| skipped | +failure | +failure | +
| success | +unset, skipped, success | +success | +
| success | +failure | +failure | +
| failure | +unset, skipped success, failure | +failure | +
If the status of the added test is error, the status is untouched and the +error_status is set to True.
+ +anta/result_manager/__init__.py68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 | |
add_test_result(entry: TestResult) -> None
+Add a result to the list
+ + + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
entry |
+
+ TestResult
+ |
+
+
+
+ TestResult data to add to the report + |
+ + required + | +
anta/result_manager/__init__.py117 +118 +119 +120 +121 +122 +123 +124 +125 | |
add_test_results(entries: list[TestResult]) -> None
+Add a list of results to the list
+ + + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
entries |
+
+ list[TestResult]
+ |
+
+
+
+ List of TestResult data to add to the report + |
+ + required + | +
anta/result_manager/__init__.py127 +128 +129 +130 +131 +132 +133 +134 | |
get_hosts() -> list[str]
+Get list of IP addresses in current manager.
+ + + +Returns:
+| Type | +Description | +
|---|---|
+ list[str]
+ |
+
+
+
+ list[str]: List of IP addresses. + |
+
anta/result_manager/__init__.py202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 | |
get_json_results() -> str
+Expose list of all test results in JSON
+ + + +Returns:
+| Name | Type | +Description | +
|---|---|---|
str |
+ str
+ |
+
+
+
+ JSON dumps of the list of results + |
+
anta/result_manager/__init__.py151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 | |
get_result_by_host(host_ip: str) -> list[TestResult]
+Get list of test result for a given host.
+ + + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
host_ip |
+
+ str
+ |
+
+
+
+ IP Address of the host to use to filter results. + |
+ + required + | +
output_format |
+
+ str
+ |
+
+
+
+ format selector. Can be either native/list. Defaults to ‘native’. + |
+ + required + | +
Returns:
+| Type | +Description | +
|---|---|
+ list[TestResult]
+ |
+
+
+
+ list[TestResult]: List of results related to the host. + |
+
anta/result_manager/__init__.py176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 | |
get_result_by_test(test_name: str) -> list[TestResult]
+Get list of test result for a given test.
+ + + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
test_name |
+
+ str
+ |
+
+
+
+ Test name to use to filter results + |
+ + required + | +
output_format |
+
+ str
+ |
+
+
+
+ format selector. Can be either native/list. Defaults to ‘native’. + |
+ + required + | +
Returns:
+| Type | +Description | +
|---|---|
+ list[TestResult]
+ |
+
+
+
+ list[TestResult]: List of results related to the test. + |
+
anta/result_manager/__init__.py163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 | |
get_results() -> list[TestResult]
+Expose list of all test results in different format
+ + + +Returns:
+| Name | Type | +Description | +
|---|---|---|
any |
+ list[TestResult]
+ |
+
+
+
+ List of results. + |
+
anta/result_manager/__init__.py142 +143 +144 +145 +146 +147 +148 +149 | |
get_status(ignore_error: bool = False) -> str
+Returns the current status including error_status if ignore_error is False
+ +anta/result_manager/__init__.py136 +137 +138 +139 +140 | |
get_testcases() -> list[str]
+Get list of name of all test cases in current manager.
+ + + +Returns:
+| Type | +Description | +
|---|---|
+ list[str]
+ |
+
+
+
+ list[str]: List of names for all tests. + |
+
anta/result_manager/__init__.py189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 | |
+ Bases: BaseModel
Describe the result of a test from a single device.
+ + + +Attributes:
+| Name | +Type | +Description | +
|---|---|---|
name |
+
+ str
+ |
+
+
+
+ Device name where the test has run. + |
+
test |
+
+ str
+ |
+
+
+
+ Test name runs on the device. + |
+
categories |
+
+ List[str]
+ |
+
+
+
+ List of categories the TestResult belongs to, by default the AntaTest categories. + |
+
description |
+
+ str
+ |
+
+
+
+ TestResult description, by default the AntaTest description. + |
+
result |
+
+ TestStatus
+ |
+
+
+
+ Result of the test. Can be one of “unset”, “success”, “failure”, “error” or “skipped”. + |
+
messages |
+
+ List[str]
+ |
+
+
+
+ Message to report after the test if any. + |
+
custom_field |
+
+ Optional[str]
+ |
+
+
+
+ Custom field to store a string for flexibility in integrating with ANTA + |
+
is_error(message: str | None = None) -> None
+Helper to set status to error
+ +anta/result_manager/models.py64 +65 +66 +67 +68 | |
is_failure(message: str | None = None) -> None
+Helper to set status to failure
+ + + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
message |
+
+ str | None
+ |
+
+
+
+ Optional message related to the test + |
+
+ None
+ |
+
anta/result_manager/models.py46 +47 +48 +49 +50 +51 +52 +53 | |
is_skipped(message: str | None = None) -> None
+Helper to set status to skipped
+ + + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
message |
+
+ str | None
+ |
+
+
+
+ Optional message related to the test + |
+
+ None
+ |
+
anta/result_manager/models.py55 +56 +57 +58 +59 +60 +61 +62 | |
is_success(message: str | None = None) -> None
+Helper to set status to success
+ + + +Parameters:
+| Name | +Type | +Description | +Default | +
|---|---|---|---|
message |
+
+ str | None
+ |
+
+
+
+ Optional message related to the test + |
+
+ None
+ |
+
anta/result_manager/models.py37 +38 +39 +40 +41 +42 +43 +44 | |
Test functions related to the EOS various AAA settings
+ + + +
+ Bases: AntaTest
Verifies the AAA accounting console method lists for different accounting types (system, exec, commands, dot1x).
+ +anta/tests/aaa.py251 +252 +253 +254 +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 | |
+ Bases: Input
anta/tests/aaa.py265 +266 +267 +268 +269 | |
instance-attribute
+
+
+¶methods: List[AAAAuthMethod]
+List of AAA accounting console methods. Methods should be in the right order
+instance-attribute
+
+
+¶types: Set[Literal['commands', 'exec', 'system', 'dot1x']]
+List of accounting console types to verify
+
+ Bases: AntaTest
Verifies the AAA accounting default method lists for different accounting types (system, exec, commands, dot1x).
+ +anta/tests/aaa.py207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 | |
+ Bases: Input
anta/tests/aaa.py221 +222 +223 +224 +225 | |
instance-attribute
+
+
+¶methods: List[AAAAuthMethod]
+List of AAA accounting methods. Methods should be in the right order
+instance-attribute
+
+
+¶types: Set[Literal['commands', 'exec', 'system', 'dot1x']]
+List of accounting types to verify
+
+ Bases: AntaTest
Verifies the AAA authentication method lists for different authentication types (login, enable, dot1x).
+ +anta/tests/aaa.py124 +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 +166 | |
+ Bases: Input
anta/tests/aaa.py138 +139 +140 +141 +142 | |
instance-attribute
+
+
+¶methods: List[AAAAuthMethod]
+List of AAA authentication methods. Methods should be in the right order
+instance-attribute
+
+
+¶types: Set[Literal['login', 'enable', 'dot1x']]
+List of authentication types to verify
+
+ Bases: AntaTest
Verifies the AAA authorization method lists for different authorization types (commands, exec).
+ +anta/tests/aaa.py169 +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 +197 +198 +199 +200 +201 +202 +203 +204 | |
+ Bases: Input
anta/tests/aaa.py183 +184 +185 +186 +187 | |
instance-attribute
+
+
+¶methods: List[AAAAuthMethod]
+List of AAA authorization methods. Methods should be in the right order
+instance-attribute
+
+
+¶types: Set[Literal['commands', 'exec']]
+List of authorization types to verify
+
+ Bases: AntaTest
Verifies if the provided TACACS server group(s) are configured.
+ +anta/tests/aaa.py92 + 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 | |
+ Bases: Input
anta/tests/aaa.py106 +107 +108 | |
instance-attribute
+
+
+¶groups: List[str]
+List of TACACS server group
+
+ Bases: AntaTest
Verifies TACACS servers are configured for a specified VRF.
+ +anta/tests/aaa.py52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 | |
+ Bases: Input
anta/tests/aaa.py66 +67 +68 +69 +70 | |
instance-attribute
+
+
+¶servers: List[IPv4Address]
+List of TACACS servers
+class-attribute
+ instance-attribute
+
+
+¶vrf: str = 'default'
+The name of the VRF to transport TACACS messages
+
+ Bases: AntaTest
Verifies TACACS source-interface for a specified VRF.
+ +anta/tests/aaa.py20 +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 | |
+ Bases: Input
anta/tests/aaa.py34 +35 +36 +37 +38 | |
instance-attribute
+
+
+¶intf: str
+Source-interface to use as source IP of TACACS messages
+class-attribute
+ instance-attribute
+
+
+¶vrf: str = 'default'
+The name of the VRF to transport TACACS messages
+Test functions related to the device configuration
+ + + +
+ Bases: AntaTest
Verifies there is no difference between the running-config and the startup-config
+ +anta/tests/configuration.py34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 | |
+ Bases: AntaTest
Verifies ZeroTouch is disabled
+ +anta/tests/configuration.py14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 | |
Test functions related to various connectivity checks
+ + + +
+ Bases: AntaTest
This test verifies that the provided LLDP neighbors are present and connected with the correct configuration.
+ +anta/tests/connectivity.py75 + 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 | |
+ Bases: Input
anta/tests/connectivity.py91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 | |
instance-attribute
+
+
+¶neighbors: List[Neighbor]
+List of LLDP neighbors
+
+ Bases: BaseModel
LLDP neighbor
+ +anta/tests/connectivity.py95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 | |
+ Bases: AntaTest
Test network reachability to one or many destination IP(s).
+ +anta/tests/connectivity.py22 +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 | |
+ Bases: Input
anta/tests/connectivity.py36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 | |
instance-attribute
+
+
+¶hosts: List[Host]
+List of hosts to ping
+
+ Bases: BaseModel
Remote host to ping
+ +anta/tests/connectivity.py40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 | |
instance-attribute
+
+
+¶destination: IPv4Address
+IPv4 address to ping
+class-attribute
+ instance-attribute
+
+
+¶repeat: int = 2
+Number of ping repetition (default=2)
+instance-attribute
+
+
+¶source: Union[IPv4Address, Interface]
+IPv4 address source IP or Egress interface to use
+class-attribute
+ instance-attribute
+
+
+¶vrf: str = 'default'
+VRF context
+Test functions to flag field notices
+ + + +
+ Bases: AntaTest
Verifies the device is using an Aboot version that fix the bug discussed +in the field notice 44 (Aboot manages system settings prior to EOS initialization).
+https://www.arista.com/en/support/advisories-notices/field-notice/8756-field-notice-44
+ +anta/tests/field_notices.py12 + 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 + 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 + 73 + 74 + 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 | |
+ Bases: AntaTest
Checks if the device is potentially exposed to Field Notice 72, and if the issue has been mitigated.
+https://www.arista.com/en/support/advisories-notices/field-notice/17410-field-notice-0072
+ +anta/tests/field_notices.py103 +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 | |
Test functions related to the hardware or environment
+ + + +
+ Bases: AntaTest
This test verifies if there are no adverse drops on DCS7280E and DCS7500E.
+ +anta/tests/hardware.py198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 | |
+ Bases: AntaTest
This test verifies the fans status.
+ +anta/tests/hardware.py131 +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 | |
+ Bases: Input
anta/tests/hardware.py145 +146 +147 | |
instance-attribute
+
+
+¶states: List[str]
+Accepted states list for fan status
+
+ Bases: AntaTest
This test verifies the power supplies status.
+ +anta/tests/hardware.py166 +167 +168 +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 | |
+ Bases: Input
anta/tests/hardware.py180 +181 +182 | |
instance-attribute
+
+
+¶states: List[str]
+Accepted states list for power supplies status
+
+ Bases: AntaTest
This test verifies the device’s system cooling.
+ +anta/tests/hardware.py107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 | |
+ Bases: AntaTest
This test verifies if the device temperature is within acceptable limits.
+ +anta/tests/hardware.py49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 | |
+ Bases: AntaTest
This test verifies if all the transceivers come from approved manufacturers.
+ +anta/tests/hardware.py18 +19 +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 | |
+ Bases: Input
anta/tests/hardware.py32 +33 +34 | |
instance-attribute
+
+
+¶manufacturers: List[str]
+List of approved transceivers manufacturers
+
+ Bases: AntaTest
This test verifies if all the transceivers are operating at an acceptable temperature.
+ +anta/tests/hardware.py74 + 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 | |
Test functions related to the device interfaces
+ + + +
+ Bases: AntaTest
Verifies if Proxy-ARP is enabled for the provided list of interface(s).
+ +anta/tests/interfaces.py360 +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 | |
+ Bases: Input
anta/tests/interfaces.py374 +375 +376 | |
instance-attribute
+
+
+¶interfaces: List[str]
+list of interfaces to be tested
+
+ Bases: AntaTest
Verifies there is no illegal LACP packets received.
+ +anta/tests/interfaces.py228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 | |
+ Bases: AntaTest
Verifies interfaces packet discard counters are equal to zero.
+ +anta/tests/interfaces.py80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 | |
+ Bases: AntaTest
Verifies there is no interface in error disable state.
+ +anta/tests/interfaces.py102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 | |
+ Bases: AntaTest
This test verifies that interfaces error counters are equal to zero.
+ +anta/tests/interfaces.py53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 | |
+ Bases: AntaTest
Verifies interfaces utilization is below 75%.
+ +anta/tests/interfaces.py24 +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 | |
+ Bases: AntaTest
This test verifies if the provided list of interfaces are all in the expected state.
+ +anta/tests/interfaces.py122 +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 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 | |
+ Bases: Input
anta/tests/interfaces.py136 +137 +138 +139 +140 +141 +142 +143 | |
instance-attribute
+
+
+¶interfaces: List[InterfaceStatus]
+List of interfaces to validate with the expected state
+
+ 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.
+ +anta/tests/interfaces.py395 +396 +397 +398 +399 +400 +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 +435 +436 +437 +438 +439 +440 | |
+ Bases: Input
anta/tests/interfaces.py412 +413 +414 +415 +416 +417 +418 | |
class-attribute
+ instance-attribute
+
+
+¶ignored_interfaces: List[str] = ['Management', 'Loopback', 'Vxlan', 'Tunnel']
+A list of L2 interfaces to ignore
+class-attribute
+ instance-attribute
+
+
+¶mtu: int = 9214
+Default MTU we should have configured on all non-excluded interfaces
+class-attribute
+ instance-attribute
+
+
+¶specific_mtu: List[Dict[str, int]] = []
+A list of dictionary of L2 interfaces with their specific MTU configured
+
+ 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.
+ +anta/tests/interfaces.py312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +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 | |
+ Bases: Input
anta/tests/interfaces.py329 +330 +331 +332 +333 +334 +335 | |
class-attribute
+ instance-attribute
+
+
+¶ignored_interfaces: List[str] = ['Management', 'Loopback', 'Vxlan', 'Tunnel']
+A list of L3 interfaces to ignore
+class-attribute
+ instance-attribute
+
+
+¶mtu: int = 1500
+Default MTU we should have configured on all non-excluded interfaces
+class-attribute
+ instance-attribute
+
+
+¶specific_mtu: List[Dict[str, int]] = []
+A list of dictionary of L3 interfaces with their specific MTU configured
+
+ Bases: AntaTest
Verifies the number of loopback interfaces on the device is the one we expect and if none of the loopback is down.
+ +anta/tests/interfaces.py252 +253 +254 +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 | |
+ Bases: Input
anta/tests/interfaces.py262 +263 +264 | |
instance-attribute
+
+
+¶number: conint(ge=0)
+Number of loopback interfaces expected to be present
+
+ Bases: AntaTest
Verifies there is no inactive port in port channels.
+ +anta/tests/interfaces.py204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 | |
+ Bases: AntaTest
Verifies there is no interface vlan down.
+ +anta/tests/interfaces.py287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 | |
+ Bases: AntaTest
Verifies the device did not drop packets due its to storm-control configuration.
+ +anta/tests/interfaces.py178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 | |
Test functions related to the EOS various logging settings
+NOTE: ‘show logging’ does not support json output yet
+ + + +
+ Bases: AntaTest
Verifies if AAA accounting logs are generated.
+ +anta/tests/logging.py231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 | |
+ Bases: AntaTest
This test verifies there are no syslog messages with a severity of ERRORS or higher.
+ +anta/tests/logging.py255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 | |
test() -> None
+Run VerifyLoggingWarning validation
+ +anta/tests/logging.py269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 | |
+ Bases: AntaTest
Verifies if logs are generated with the device FQDN.
+ +anta/tests/logging.py161 +162 +163 +164 +165 +166 +167 +168 +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 | |
+ Bases: AntaTest
Verifies logging hosts (syslog servers) for a specified VRF.
+ +anta/tests/logging.py97 + 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 | |
+ Bases: Input
anta/tests/logging.py111 +112 +113 +114 +115 | |
instance-attribute
+
+
+¶hosts: List[IPv4Address]
+List of hosts (syslog servers) IP addresses
+class-attribute
+ instance-attribute
+
+
+¶vrf: str = 'default'
+The name of the VRF to transport log messages
+
+ Bases: AntaTest
Verifies if logs are generated.
+ +anta/tests/logging.py132 +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 | |
+ Bases: AntaTest
Verifies if logging persistent is enabled and logs are saved in flash.
+ +anta/tests/logging.py36 +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 | |
+ Bases: AntaTest
Verifies logging source-interface for a specified VRF.
+ +anta/tests/logging.py67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 | |
+ Bases: Input
anta/tests/logging.py81 +82 +83 +84 +85 | |
instance-attribute
+
+
+¶interface: str
+Source-interface to use as source IP of log messages
+class-attribute
+ instance-attribute
+
+
+¶vrf: str = 'default'
+The name of the VRF to transport log messages
+
+ Bases: AntaTest
Verifies if logs are generated with the approprate timestamp.
+ +anta/tests/logging.py197 +198 +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 +225 +226 +227 +228 | |
Test functions related to Multi-chassis Link Aggregation (MLAG)
+ + + +
+ Bases: AntaTest
This test verifies there are no MLAG config-sanity inconsistencies.
+ +anta/tests/mlag.py80 + 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 | |
+ Bases: AntaTest
This test verifies the dual-primary detection and its parameters of the MLAG configuration.
+ +anta/tests/mlag.py149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +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 | |
+ Bases: Input
anta/tests/mlag.py164 +165 +166 +167 +168 +169 +170 +171 +172 | |
instance-attribute
+
+
+¶detection_delay: conint(ge=0)
+Delay detection (seconds)
+class-attribute
+ instance-attribute
+
+
+¶errdisabled: bool = False
+Errdisabled all interfaces when dual-primary is detected
+instance-attribute
+
+
+¶recovery_delay: conint(ge=0)
+Delay (seconds) after dual-primary detection resolves until non peer-link ports that are part of an MLAG are enabled
+instance-attribute
+
+
+¶recovery_delay_non_mlag: conint(ge=0)
+Delay (seconds) after dual-primary detection resolves until ports that are not part of an MLAG are enabled
+
+ Bases: AntaTest
This test verifies there are no inactive or active-partial MLAG ports.
+ +anta/tests/mlag.py53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 | |
+ Bases: AntaTest
This test verifies the reload-delay parameters of the MLAG configuration.
+ +anta/tests/mlag.py113 +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 | |
+ Bases: Input
anta/tests/mlag.py128 +129 +130 +131 +132 | |
instance-attribute
+
+
+¶reload_delay: conint(ge=0)
+Delay (seconds) after reboot until non peer-link ports that are part of an MLAG are enabled
+instance-attribute
+
+
+¶reload_delay_non_mlag: conint(ge=0)
+Delay (seconds) after reboot until ports that are not part of an MLAG are enabled
+
+ Bases: AntaTest
This test verifies the health status of the MLAG configuration.
+ +anta/tests/mlag.py17 +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 +43 +44 +45 +46 +47 +48 +49 +50 | |
Test functions related to multicast
+ + + +
+ Bases: AntaTest
Verifies the IGMP snooping global configuration.
+ +anta/tests/multicast.py46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 | |
+ Bases: Input
anta/tests/multicast.py56 +57 +58 | |
instance-attribute
+
+
+¶enabled: bool
+Expected global IGMP snooping configuration (True=enabled, False=disabled)
+
+ Bases: AntaTest
Verifies the IGMP snooping configuration for some VLANs.
+ +anta/tests/multicast.py18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 | |
+ Bases: Input
anta/tests/multicast.py28 +29 +30 | |
instance-attribute
+
+
+¶vlans: Dict[Vlan, bool]
+Dictionary of VLANs with associated IGMP configuration status (True=enabled, False=disabled)
+Test functions related to ASIC profiles
+ + + +
+ Bases: AntaTest
Verifies the device is using the configured TCAM profile.
+ +anta/tests/profiles.py41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 | |
+ Bases: Input
anta/tests/profiles.py51 +52 +53 | |
instance-attribute
+
+
+¶profile: str
+Expected TCAM profile
+
+ Bases: AntaTest
Verifies the device is using the expected Unified Forwarding Table mode.
+ +anta/tests/profiles.py17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 | |
+ Bases: Input
anta/tests/profiles.py27 +28 +29 | |
instance-attribute
+
+
+¶mode: Literal[0, 1, 2, 3, 4, 'flexible']
+Expected UFT mode
+BGP test functions
+ + + +
+ Bases: AntaTest
This test verifies the count of BGP peers for a given address family.
+It supports multiple types of address families (AFI) and subsequent service families (SAFI). +Please refer to the Input class attributes below for details.
+ +anta/tests/routing/bgp.py135 +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 +167 +168 +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 +197 +198 +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 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 | |
+ Bases: Input
anta/tests/routing/bgp.py155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +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 | |
instance-attribute
+
+
+¶address_families: List[BgpAfi]
+List of BGP address families (BgpAfi)
+
+ Bases: BaseModel
anta/tests/routing/bgp.py161 +162 +163 +164 +165 +166 +167 +168 +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 | |
instance-attribute
+
+
+¶afi: Afi
+BGP address family (AFI)
+instance-attribute
+
+
+¶num_peers: PositiveInt
+Number of expected BGP peer(s)
+class-attribute
+ instance-attribute
+
+
+¶safi: Optional[Safi] = None
+Optional BGP subsequent service family (SAFI).
+If the input afi is ipv4 or ipv6, a valid safi must be provided.
class-attribute
+ instance-attribute
+
+
+¶vrf: str = 'default'
+Optional VRF for IPv4 and IPv6. If not provided, it defaults to default.
If the input afi is not ipv4 or ipv6, e.g. evpn, vrf must be default.
validate_inputs() -> BaseModel
+Validate the inputs provided to the BgpAfi class.
+If afi is either ipv4 or ipv6, safi must be provided.
+If afi is not ipv4 or ipv6, safi must not be provided and vrf must be default.
+ +anta/tests/routing/bgp.py178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 | |
+ Bases: AntaTest
This test verifies the health of BGP peers.
+It will validate that all BGP sessions are established and all message queues for these BGP sessions are empty for a given address family.
+It supports multiple types of address families (AFI) and subsequent service families (SAFI). +Please refer to the Input class attributes below for details.
+ +anta/tests/routing/bgp.py237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +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 +298 +299 +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 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 | |
+ Bases: Input
anta/tests/routing/bgp.py259 +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 | |
instance-attribute
+
+
+¶address_families: List[BgpAfi]
+List of BGP address families (BgpAfi)
+
+ Bases: BaseModel
anta/tests/routing/bgp.py265 +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 | |
instance-attribute
+
+
+¶afi: Afi
+BGP address family (AFI)
+class-attribute
+ instance-attribute
+
+
+¶safi: Optional[Safi] = None
+Optional BGP subsequent service family (SAFI).
+If the input afi is ipv4 or ipv6, a valid safi must be provided.
class-attribute
+ instance-attribute
+
+
+¶vrf: str = 'default'
+Optional VRF for IPv4 and IPv6. If not provided, it defaults to default.
If the input afi is not ipv4 or ipv6, e.g. evpn, vrf must be default.
validate_inputs() -> BaseModel
+Validate the inputs provided to the BgpAfi class.
+If afi is either ipv4 or ipv6, safi must be provided.
+If afi is not ipv4 or ipv6, safi must not be provided and vrf must be default.
+ +anta/tests/routing/bgp.py280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 | |
+ Bases: AntaTest
This test verifies the health of specific BGP peer(s).
+It will validate that the BGP session is established and all message queues for this BGP session are empty for the given peer(s).
+It supports multiple types of address families (AFI) and subsequent service families (SAFI). +Please refer to the Input class attributes below for details.
+ +anta/tests/routing/bgp.py343 +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 +399 +400 +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 +435 +436 +437 +438 +439 +440 +441 +442 +443 +444 +445 +446 +447 +448 +449 | |
+ Bases: Input
anta/tests/routing/bgp.py365 +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 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 | |
instance-attribute
+
+
+¶address_families: List[BgpAfi]
+List of BGP address families (BgpAfi)
+
+ Bases: BaseModel
anta/tests/routing/bgp.py371 +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 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 | |
instance-attribute
+
+
+¶afi: Afi
+BGP address family (AFI)
+instance-attribute
+
+
+¶peers: List[Union[IPv4Address, IPv6Address]]
+List of BGP IPv4 or IPv6 peer
+class-attribute
+ instance-attribute
+
+
+¶safi: Optional[Safi] = None
+Optional BGP subsequent service family (SAFI).
+If the input afi is ipv4 or ipv6, a valid safi must be provided.
class-attribute
+ instance-attribute
+
+
+¶vrf: str = 'default'
+Optional VRF for IPv4 and IPv6. If not provided, it defaults to default.
all is NOT supported.
If the input afi is not ipv4 or ipv6, e.g. evpn, vrf must be default.
validate_inputs() -> BaseModel
+Validate the inputs provided to the BgpAfi class.
+If afi is either ipv4 or ipv6, safi must be provided and vrf must NOT be all.
+If afi is not ipv4 or ipv6, safi must not be provided and vrf must be default.
+ +anta/tests/routing/bgp.py390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 | |
Generic routing test functions
+ + + +
+ Bases: AntaTest
Verifies there is no BFD peer in down state (all VRF, IPv4 neighbors).
+ +anta/tests/routing/generic.py84 + 85 + 86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 | |
+ Bases: AntaTest
Verifies the configured routing protocol model is the one we expect. +And if there is no mismatch between the configured and operating routing protocol model.
+ +anta/tests/routing/generic.py22 +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 | |
+ Bases: Input
anta/tests/routing/generic.py35 +36 +37 | |
class-attribute
+ instance-attribute
+
+
+¶model: Literal['multi-agent', 'ribd'] = 'multi-agent'
+Expected routing protocol model
+
+ Bases: AntaTest
This test verifies that the provided routes are present in the routing table of a specified VRF.
+ +anta/tests/routing/generic.py109 +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 | |
+ Bases: Input
anta/tests/routing/generic.py123 +124 +125 +126 +127 | |
+ Bases: AntaTest
Verifies the size of the IP routing table (default VRF). +Should be between the two provided thresholds.
+ +anta/tests/routing/generic.py50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 | |
+ Bases: Input
anta/tests/routing/generic.py61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 | |
instance-attribute
+
+
+¶maximum: int
+Expected maximum routing table (default VRF) size
+instance-attribute
+
+
+¶minimum: int
+Expected minimum routing table (default VRF) size
+check_min_max() -> AntaTest.Input
+Validate that maximum is greater than minimum
+ +anta/tests/routing/generic.py67 +68 +69 +70 +71 +72 | |
OSPF test functions
+ + + +
+ Bases: AntaTest
Verifies the number of OSPF neighbors in FULL state is the one we expect.
+ +anta/tests/routing/ospf.py69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 | |
+ Bases: Input
anta/tests/routing/ospf.py79 +80 +81 | |
instance-attribute
+
+
+¶number: int
+The expected number of OSPF neighbors in FULL state
+
+ Bases: AntaTest
Verifies all OSPF neighbors are in FULL state.
+ +anta/tests/routing/ospf.py47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 | |
Test functions related to the EOS various security settings
+ + + +
+ Bases: AntaTest
Verifies if eAPI HTTP server is disabled globally.
+ +anta/tests/security.py142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 | |
+ Bases: AntaTest
Verifies if eAPI HTTPS server SSL profile is configured and valid.
+ +anta/tests/security.py165 +166 +167 +168 +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 | |
+ Bases: Input
anta/tests/security.py179 +180 +181 | |
instance-attribute
+
+
+¶profile: str
+SSL profile to verify
+
+ Bases: AntaTest
Verifies if eAPI has the right number IPv4 ACL(s) configured for a specified VRF.
+ +anta/tests/security.py196 +197 +198 +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 +225 +226 +227 +228 +229 +230 +231 | |
+ Bases: Input
anta/tests/security.py210 +211 +212 +213 +214 | |
instance-attribute
+
+
+¶number: conint(ge=0)
+The number of expected IPv4 ACL(s)
+class-attribute
+ instance-attribute
+
+
+¶vrf: str = 'default'
+The name of the VRF in which to check for eAPI
+
+ Bases: AntaTest
Verifies if eAPI has the right number IPv6 ACL(s) configured for a specified VRF.
+ +anta/tests/security.py234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 | |
+ Bases: Input
anta/tests/security.py249 +250 +251 +252 +253 | |
instance-attribute
+
+
+¶number: conint(ge=0)
+The number of expected IPv6 ACL(s)
+class-attribute
+ instance-attribute
+
+
+¶vrf: str = 'default'
+The name of the VRF in which to check for eAPI
+
+ Bases: AntaTest
Verifies if the SSHD agent has the right number IPv4 ACL(s) configured for a specified VRF.
+ +anta/tests/security.py43 +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 +73 +74 +75 +76 +77 +78 | |
+ Bases: Input
anta/tests/security.py57 +58 +59 +60 +61 | |
instance-attribute
+
+
+¶number: conint(ge=0)
+The number of expected IPv4 ACL(s)
+class-attribute
+ instance-attribute
+
+
+¶vrf: str = 'default'
+The name of the VRF in which to check for the SSHD agent
+
+ Bases: AntaTest
Verifies if the SSHD agent has the right number IPv6 ACL(s) configured for a specified VRF.
+ +anta/tests/security.py81 + 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 | |
+ Bases: Input
anta/tests/security.py95 +96 +97 +98 +99 | |
instance-attribute
+
+
+¶number: conint(ge=0)
+The number of expected IPv6 ACL(s)
+class-attribute
+ instance-attribute
+
+
+¶vrf: str = 'default'
+The name of the VRF in which to check for the SSHD agent
+
+ Bases: AntaTest
Verifies if the SSHD agent is disabled in the default VRF.
+ +anta/tests/security.py16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 | |
+ Bases: AntaTest
Verifies if Telnet is disabled in the default VRF.
+ +anta/tests/security.py119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 | |
Test functions related to the EOS various SNMP settings
+ + + +
+ Bases: AntaTest
Verifies if the SNMP agent has the right number IPv4 ACL(s) configured for a specified VRF.
+ +anta/tests/snmp.py43 +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 +73 +74 +75 +76 +77 +78 | |
+ Bases: Input
anta/tests/snmp.py57 +58 +59 +60 +61 | |
instance-attribute
+
+
+¶number: conint(ge=0)
+The number of expected IPv4 ACL(s)
+class-attribute
+ instance-attribute
+
+
+¶vrf: str = 'default'
+The name of the VRF in which to check for the SNMP agent
+
+ Bases: AntaTest
Verifies if the SNMP agent has the right number IPv6 ACL(s) configured for a specified VRF.
+ +anta/tests/snmp.py81 + 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 | |
+ Bases: Input
anta/tests/snmp.py95 +96 +97 +98 +99 | |
instance-attribute
+
+
+¶number: conint(ge=0)
+The number of expected IPv6 ACL(s)
+class-attribute
+ instance-attribute
+
+
+¶vrf: str = 'default'
+The name of the VRF in which to check for the SNMP agent
+
+ Bases: AntaTest
Verifies whether the SNMP agent is enabled in a specified VRF.
+ +anta/tests/snmp.py16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 | |
+ Bases: Input
anta/tests/snmp.py30 +31 +32 | |
class-attribute
+ instance-attribute
+
+
+¶vrf: str = 'default'
+The name of the VRF in which to check for the SNMP agent
+Test functions related to the EOS software
+ + + +
+ Bases: AntaTest
Verifies all EOS extensions installed on the device are enabled for boot persistence.
+ +anta/tests/software.py64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 | |
+ Bases: AntaTest
Verifies the device is running one of the allowed EOS version.
+ +anta/tests/software.py17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 | |
+ Bases: Input
anta/tests/software.py27 +28 +29 | |
instance-attribute
+
+
+¶versions: List[str]
+List of allowed EOS versions
+
+ Bases: AntaTest
Verifies the device is running one of the allowed TerminAttr version.
+ +anta/tests/software.py40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 | |
+ Bases: Input
anta/tests/software.py50 +51 +52 | |
instance-attribute
+
+
+¶versions: List[str]
+List of allowed TerminAttr versions
+Test functions related to various Spanning Tree Protocol (STP) settings
+ + + +
+ Bases: AntaTest
Verifies there is no STP blocked ports.
+ +anta/tests/stp.py61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 | |
+ Bases: AntaTest
Verifies there is no errors in STP BPDU packets.
+ +anta/tests/stp.py86 + 87 + 88 + 89 + 90 + 91 + 92 + 93 + 94 + 95 + 96 + 97 + 98 + 99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 | |
+ Bases: AntaTest
Verifies that all interfaces are in a forwarding state for a provided list of VLAN(s).
+ +anta/tests/stp.py112 +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 | |
+ Bases: Input
anta/tests/stp.py126 +127 +128 | |
instance-attribute
+
+
+¶vlans: List[Vlan]
+List of VLAN on which to verify forwarding states
+
+ Bases: AntaTest
Verifies the configured STP mode for a provided list of VLAN(s).
+ +anta/tests/stp.py19 +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 | |
+ Bases: Input
anta/tests/stp.py33 +34 +35 +36 +37 | |
class-attribute
+ instance-attribute
+
+
+¶mode: Literal['mstp', 'rstp', 'rapidPvst'] = 'mstp'
+STP mode to verify
+instance-attribute
+
+
+¶vlans: List[Vlan]
+List of VLAN on which to verify STP mode
+
+ Bases: AntaTest
Verifies the STP root priority for a provided list of VLAN or MST instance ID(s).
+ +anta/tests/stp.py156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +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 +197 +198 | |
+ Bases: Input
anta/tests/stp.py170 +171 +172 +173 +174 | |
class-attribute
+ instance-attribute
+
+
+¶instances: List[Vlan] = []
+List of VLAN or MST instance ID(s). If empty, ALL VLAN or MST instance ID(s) will be verified.
+instance-attribute
+
+
+¶priority: int
+STP root priority to verify
+Test functions related to system-level features and protocols
+ + + +
+ Bases: AntaTest
This test verifies that no agent crash reports are present on the device.
+ +anta/tests/system.py110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 | |
+ Bases: AntaTest
This test verifies whether the CPU utilization is below 75%.
+ +anta/tests/system.py135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 | |
+ Bases: AntaTest
This test verifies if there are core dump files in the /var/core directory.
+ +anta/tests/system.py81 + 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 | |
+ Bases: AntaTest
This test verifies that no partition is utilizing more than 75% of its disk space.
+ +anta/tests/system.py183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 | |
+ Bases: AntaTest
This test verifies whether the memory utilization is below 75%.
+ +anta/tests/system.py159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 | |
+ Bases: AntaTest
This test verifies that the Network Time Protocol (NTP) is synchronized.
+ +anta/tests/system.py206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 | |
+ Bases: AntaTest
This test verifies the last reload cause of the device.
+ +anta/tests/system.py45 +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 +74 +75 +76 +77 +78 | |
+ Bases: AntaTest
This test verifies if the device uptime is higher than the provided minimum uptime value.
+ +anta/tests/system.py18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 | |
+ Bases: Input
anta/tests/system.py32 +33 +34 | |
instance-attribute
+
+
+¶minimum: conint(ge=0)
+Minimum uptime in seconds
+Test functions related to VXLAN
+ + + +
+ Bases: AntaTest
This test verifies if the Vxlan1 interface is configured and ‘up/up’.
+Warning
+The name of this test has been updated from ‘VerifyVxlan’ for better representation.
+anta/tests/vxlan.py20 +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 | |
+ Bases: AntaTest
This test verifies that no issues are detected with the VXLAN configuration.
+ +anta/tests/vxlan.py55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 | |
+ Bases: AntaTest
This test verifies the VNI-VLAN bindings of the Vxlan1 interface.
+ +anta/tests/vxlan.py87 + 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 | |
+ Bases: Input
anta/tests/vxlan.py102 +103 +104 | |
instance-attribute
+
+
+¶bindings: Dict[Vni, Vlan]
+VNI to VLAN bindings to verify
+
+ Bases: AntaTest
This test verifies the VTEP peers of the Vxlan1 interface.
+ +anta/tests/vxlan.py137 +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 +167 +168 +169 +170 +171 +172 +173 | |
+ Bases: Input
anta/tests/vxlan.py152 +153 +154 | |
instance-attribute
+
+
+¶vteps: List[IPv4Address]
+List of VTEP peers to verify
+This section describes all the available tests provided by ANTA package.
+All these tests can be imported in a catalog to be used by the anta cli or in your own framework
+ + + + + + + + + + + + + + + + + + + + +Module that provides predefined types for AntaTest.Input instances
+ + + +module-attribute
+
+
+¶AAAAuthMethod = Annotated[str, AfterValidator(aaa_group_prefix)]
+module-attribute
+
+
+¶Afi = Literal['ipv4', 'ipv6', 'vpn-ipv4', 'vpn-ipv6', 'evpn', 'rt-membership']
+module-attribute
+
+
+¶Interface = Annotated[str, Field(pattern='^(Dps|Ethernet|Fabric|Loopback|Management|Port-Channel|Tunnel|Vlan|Vxlan)[0-9]+(\\/[0-9]+)*(\\.[0-9]+)?$'), BeforeValidator(interface_autocomplete), BeforeValidator(interface_case_sensitivity)]
+module-attribute
+
+
+¶Safi = Literal['unicast', 'multicast', 'labeled-unicast']
+module-attribute
+
+
+¶TestStatus = Literal['unset', 'success', 'failure', 'error', 'skipped']
+module-attribute
+
+
+¶Vlan = Annotated[int, Field(ge=0, le=4094)]
+module-attribute
+
+
+¶Vni = Annotated[int, Field(ge=1, le=16777215)]
+aaa_group_prefix(v: str) -> str
+Prefix the AAA method with ‘group’ if it is known
+ +anta/custom_types.py15 +16 +17 +18 | |
interface_autocomplete(v: str) -> str
+Allow the user to only provide the beginning of an interface name.
+ +et, eth will be changed to Ethernetpo will be changed to Port-Channelanta/custom_types.py21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 | |
interface_case_sensitivity(v: str) -> str
+Reformat interface name to match expected case sensitivity.
+ + + +Examples:
+anta/custom_types.py39 +40 +41 +42 +43 +44 +45 +46 +47 +48 | |