Skip to content

Hardware

ANTA catalog for hardware tests

Test functions related to the hardware or environment

VerifyAdverseDrops

Bases: AntaTest

This test verifies if there are no adverse drops on DCS7280E and DCS7500E.

Expected Results
  • success: The test will pass if there are no adverse drops.
  • failure: The test will fail if there are adverse drops.
  • skipped: The test will be skipped if it’s run on a virtualized platform.
Source code in anta/tests/hardware.py 
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
class VerifyAdverseDrops(AntaTest):
    """
    This test verifies if there are no adverse drops on DCS7280E and DCS7500E.

    Expected Results:
      * success: The test will pass if there are no adverse drops.
      * failure: The test will fail if there are adverse drops.
      * skipped: The test will be skipped if it's run on a virtualized platform.
    """

    name = "VerifyAdverseDrops"
    description = "Verifies there are no adverse drops on DCS7280E and DCS7500E"
    categories = ["hardware"]
    commands = [AntaCommand(command="show hardware counter drop", ofmt="json")]

    @skip_on_platforms(["cEOSLab", "vEOS-lab"])
    @AntaTest.anta_test
    def test(self) -> None:
        """
        Run VerifyAdverseDrops validation
        """
        command_output = self.instance_commands[0].json_output
        total_adverse_drop = command_output["totalAdverseDrops"] if "totalAdverseDrops" in command_output.keys() else ""
        if total_adverse_drop == 0:
            self.result.is_success()
        else:
            self.result.is_failure(f"Device totalAdverseDrops counter is: '{total_adverse_drop}'")

test 

test() -> None

Run VerifyAdverseDrops validation

Source code in anta/tests/hardware.py 
240
241
242
243
244
245
246
247
248
249
250
251
@skip_on_platforms(["cEOSLab", "vEOS-lab"])
@AntaTest.anta_test
def test(self) -> None:
    """
    Run VerifyAdverseDrops validation
    """
    command_output = self.instance_commands[0].json_output
    total_adverse_drop = command_output["totalAdverseDrops"] if "totalAdverseDrops" in command_output.keys() else ""
    if total_adverse_drop == 0:
        self.result.is_success()
    else:
        self.result.is_failure(f"Device totalAdverseDrops counter is: '{total_adverse_drop}'")

VerifyEnvironmentCooling

Bases: AntaTest

This test verifies the fans status.

Expected Results
  • success: The test will pass if the fans status are within the accepted states list.
  • failure: The test will fail if some fans status is not within the accepted states list.
  • skipped: The test will be skipped if the accepted states list is not provided or if it’s run on a virtualized platform.
Source code in anta/tests/hardware.py 
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
class VerifyEnvironmentCooling(AntaTest):
    """
    This test verifies the fans status.

    Expected Results:
      * success: The test will pass if the fans status are within the accepted states list.
      * failure: The test will fail if some fans status is not within the accepted states list.
      * skipped: The test will be skipped if the accepted states list is not provided or if it's run on a virtualized platform.
    """

    name = "VerifyEnvironmentCooling"
    description = "Verifies if the fans status are within the accepted states list."
    categories = ["hardware"]
    commands = [AntaCommand(command="show system environment cooling", ofmt="json")]

    @skip_on_platforms(["cEOSLab", "vEOS-lab"])
    @AntaTest.anta_test
    def test(self, accepted_states: Optional[List[str]] = None) -> None:
        """
        Run VerifyEnvironmentCooling validation

        Args:
            accepted_states: Accepted states list for fan status.
        """
        if not accepted_states:
            self.result.is_skipped(f"{self.__class__.name} was not run because accepted_states list was not provided")
            return

        command_output = self.instance_commands[0].json_output
        self.result.is_success()
        # First go through power supplies fans
        for power_supply in command_output.get("powerSupplySlots", []):
            for fan in power_supply.get("fans", []):
                if (state := fan["status"]) not in accepted_states:
                    self.result.is_failure(f"Fan {fan['label']} on PowerSupply {power_supply['label']} is: '{state}'")
        # Then go through fan trays
        for fan_tray in command_output.get("fanTraySlots", []):
            for fan in fan_tray.get("fans", []):
                if (state := fan["status"]) not in accepted_states:
                    self.result.is_failure(f"Fan {fan['label']} on Fan Tray {fan_tray['label']} is: '{state}'")

test 

test(accepted_states: Optional[List[str]] = None) -> None

Run VerifyEnvironmentCooling validation

Parameters:

Name Type Description Default
accepted_states Optional[List[str]]

Accepted states list for fan status.

 None
Source code in anta/tests/hardware.py 
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
@skip_on_platforms(["cEOSLab", "vEOS-lab"])
@AntaTest.anta_test
def test(self, accepted_states: Optional[List[str]] = None) -> None:
    """
    Run VerifyEnvironmentCooling validation

    Args:
        accepted_states: Accepted states list for fan status.
    """
    if not accepted_states:
        self.result.is_skipped(f"{self.__class__.name} was not run because accepted_states list was not provided")
        return

    command_output = self.instance_commands[0].json_output
    self.result.is_success()
    # First go through power supplies fans
    for power_supply in command_output.get("powerSupplySlots", []):
        for fan in power_supply.get("fans", []):
            if (state := fan["status"]) not in accepted_states:
                self.result.is_failure(f"Fan {fan['label']} on PowerSupply {power_supply['label']} is: '{state}'")
    # Then go through fan trays
    for fan_tray in command_output.get("fanTraySlots", []):
        for fan in fan_tray.get("fans", []):
            if (state := fan["status"]) not in accepted_states:
                self.result.is_failure(f"Fan {fan['label']} on Fan Tray {fan_tray['label']} is: '{state}'")

VerifyEnvironmentPower

Bases: AntaTest

This test verifies the power supplies status.

Expected Results
  • success: The test will pass if the power supplies status are within the accepted states list.
  • failure: The test will fail if some power supplies status is not within the accepted states list.
  • skipped: The test will be skipped if the accepted states list is not provided or if it’s run on a virtualized platform.
Source code in anta/tests/hardware.py 
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
class VerifyEnvironmentPower(AntaTest):
    """
    This test verifies the power supplies status.

    Expected Results:
      * success: The test will pass if the power supplies status are within the accepted states list.
      * failure: The test will fail if some power supplies status is not within the accepted states list.
      * skipped: The test will be skipped if the accepted states list is not provided or if it's run on a virtualized platform.
    """

    name = "VerifyEnvironmentPower"
    description = "Verifies if the power supplies status are within the accepted states list."
    categories = ["hardware"]
    commands = [AntaCommand(command="show system environment power", ofmt="json")]

    @skip_on_platforms(["cEOSLab", "vEOS-lab"])
    @AntaTest.anta_test
    def test(self, accepted_states: Optional[List[str]] = None) -> None:
        """
        Run VerifyEnvironmentPower validation

        Args:
            accepted_states: Accepted states list for power supplies status.
        """
        if not accepted_states:
            self.result.is_skipped(f"{self.__class__.name} was not run because accepted_states list was not provided")
            return

        command_output = self.instance_commands[0].json_output
        power_supplies = command_output["powerSupplies"] if "powerSupplies" in command_output.keys() else "{}"
        wrong_power_supplies = {
            powersupply: {"state": value["state"]} for powersupply, value in dict(power_supplies).items() if value["state"] not in accepted_states
        }
        if not wrong_power_supplies:
            self.result.is_success()
        else:
            self.result.is_failure(f"The following power supplies status are not in the accepted states list: {wrong_power_supplies}")

test 

test(accepted_states: Optional[List[str]] = None) -> None

Run VerifyEnvironmentPower validation

Parameters:

Name Type Description Default
accepted_states Optional[List[str]]

Accepted states list for power supplies status.

 None
Source code in anta/tests/hardware.py 
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
@skip_on_platforms(["cEOSLab", "vEOS-lab"])
@AntaTest.anta_test
def test(self, accepted_states: Optional[List[str]] = None) -> None:
    """
    Run VerifyEnvironmentPower validation

    Args:
        accepted_states: Accepted states list for power supplies status.
    """
    if not accepted_states:
        self.result.is_skipped(f"{self.__class__.name} was not run because accepted_states list was not provided")
        return

    command_output = self.instance_commands[0].json_output
    power_supplies = command_output["powerSupplies"] if "powerSupplies" in command_output.keys() else "{}"
    wrong_power_supplies = {
        powersupply: {"state": value["state"]} for powersupply, value in dict(power_supplies).items() if value["state"] not in accepted_states
    }
    if not wrong_power_supplies:
        self.result.is_success()
    else:
        self.result.is_failure(f"The following power supplies status are not in the accepted states list: {wrong_power_supplies}")

VerifyEnvironmentSystemCooling

Bases: AntaTest

This test verifies the device’s system cooling.

Expected Results
  • success: The test will pass if the system cooling status is OK: ‘coolingOk’.
  • failure: The test will fail if the system cooling status is NOT OK.
  • skipped: The test will be skipped if it’s run on a virtualized platform.
Source code in anta/tests/hardware.py 
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
class VerifyEnvironmentSystemCooling(AntaTest):
    """
    This test verifies the device's system cooling.

    Expected Results:
      * success: The test will pass if the system cooling status is OK: 'coolingOk'.
      * failure: The test will fail if the system cooling status is NOT OK.
      * skipped: The test will be skipped if it's run on a virtualized platform.
    """

    name = "VerifyEnvironmentSystemCooling"
    description = "Verifies the system cooling status."
    categories = ["hardware"]
    commands = [AntaCommand(command="show system environment cooling", ofmt="json")]

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

        command_output = self.instance_commands[0].json_output
        sys_status = command_output["systemStatus"] if "systemStatus" in command_output.keys() else ""

        self.result.is_success()
        if sys_status != "coolingOk":
            self.result.is_failure(f"Device system cooling is not OK: '{sys_status}'")

test 

test() -> None

Run VerifyEnvironmentCooling validation

Source code in anta/tests/hardware.py 
129
130
131
132
133
134
135
136
137
138
139
140
141
@skip_on_platforms(["cEOSLab", "vEOS-lab"])
@AntaTest.anta_test
def test(self) -> None:
    """
    Run VerifyEnvironmentCooling validation
    """

    command_output = self.instance_commands[0].json_output
    sys_status = command_output["systemStatus"] if "systemStatus" in command_output.keys() else ""

    self.result.is_success()
    if sys_status != "coolingOk":
        self.result.is_failure(f"Device system cooling is not OK: '{sys_status}'")

VerifyTemperature

Bases: 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.
  • skipped: Test test will be skipped if it’s run on a virtualized platform.
Source code in anta/tests/hardware.py 
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
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.
      * skipped: Test test will be skipped if it's run on a virtualized platform.
    """

    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:
        """
        Run VerifyTemperature validation
        """
        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}'")

test 

test() -> None

Run VerifyTemperature validation

Source code in anta/tests/hardware.py 
63
64
65
66
67
68
69
70
71
72
73
74
@skip_on_platforms(["cEOSLab", "vEOS-lab"])
@AntaTest.anta_test
def test(self) -> None:
    """
    Run VerifyTemperature validation
    """
    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}'")

VerifyTransceiversManufacturers

Bases: AntaTest

This test verifies if all the transceivers come from approved manufacturers.

Expected Results
  • success: The test will pass if all transceivers are from approved manufacturers.
  • failure: The test will fail if some transceivers are from unapproved manufacturers.
  • skipped: The test will be skipped if a list of approved manufacturers is not provided or if it’s run on a virtualized platform.
Source code in anta/tests/hardware.py 
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
class VerifyTransceiversManufacturers(AntaTest):
    """
    This test verifies if all the transceivers come from approved manufacturers.

    Expected Results:
      * success: The test will pass if all transceivers are from approved manufacturers.
      * failure: The test will fail if some transceivers are from unapproved manufacturers.
      * skipped: The test will be skipped if a list of approved manufacturers is not provided or if it's run on a virtualized platform.
    """

    name = "VerifyTransceiversManufacturers"
    description = "Verifies the transceiver's manufacturer against a list of approved manufacturers."
    categories = ["hardware"]
    commands = [AntaCommand(command="show inventory", ofmt="json")]

    @skip_on_platforms(["cEOSLab", "vEOS-lab"])
    @AntaTest.anta_test
    def test(self, manufacturers: Optional[List[str]] = None) -> None:
        """
        Run VerifyTransceiversManufacturers validation

        Args:
            manufacturers: List of approved transceivers manufacturers.
        """
        if not manufacturers:
            self.result.is_skipped(f"{self.__class__.name} was not run because manufacturers list was not provided")
            return

        command_output = self.instance_commands[0].json_output
        wrong_manufacturers = {interface: value["mfgName"] for interface, value in command_output["xcvrSlots"].items() if value["mfgName"] not in manufacturers}
        if not wrong_manufacturers:
            self.result.is_success()
        else:
            self.result.is_failure(f"Some transceivers are from unapproved manufacturers: {wrong_manufacturers}")

test 

test(manufacturers: Optional[List[str]] = None) -> None

Run VerifyTransceiversManufacturers validation

Parameters:

Name Type Description Default
manufacturers Optional[List[str]]

List of approved transceivers manufacturers.

 None
Source code in anta/tests/hardware.py 
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
@skip_on_platforms(["cEOSLab", "vEOS-lab"])
@AntaTest.anta_test
def test(self, manufacturers: Optional[List[str]] = None) -> None:
    """
    Run VerifyTransceiversManufacturers validation

    Args:
        manufacturers: List of approved transceivers manufacturers.
    """
    if not manufacturers:
        self.result.is_skipped(f"{self.__class__.name} was not run because manufacturers list was not provided")
        return

    command_output = self.instance_commands[0].json_output
    wrong_manufacturers = {interface: value["mfgName"] for interface, value in command_output["xcvrSlots"].items() if value["mfgName"] not in manufacturers}
    if not wrong_manufacturers:
        self.result.is_success()
    else:
        self.result.is_failure(f"Some transceivers are from unapproved manufacturers: {wrong_manufacturers}")

VerifyTransceiversTemperature

Bases: AntaTest

This test verifies if all the transceivers are operating at an acceptable temperature.

Expected Results
  • success: The test will pass if all transceivers status are OK: ‘ok’.
  • failure: The test will fail if some transceivers are NOT OK.
  • skipped: Test test will be skipped if it’s run on a virtualized platform.
Source code in anta/tests/hardware.py 
 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
class VerifyTransceiversTemperature(AntaTest):
    """
    This test verifies if all the transceivers are operating at an acceptable temperature.

    Expected Results:
          * success: The test will pass if all transceivers status are OK: 'ok'.
          * failure: The test will fail if some transceivers are NOT OK.
          * skipped: Test test will be skipped if it's run on a virtualized platform.
    """

    name = "VerifyTransceiversTemperature"
    description = "Verifies that all transceivers are operating within the acceptable temperature range."
    categories = ["hardware"]
    commands = [AntaCommand(command="show system environment temperature transceiver", ofmt="json")]

    @skip_on_platforms(["cEOSLab", "vEOS-lab"])
    @AntaTest.anta_test
    def test(self) -> None:
        """
        Run VerifyTransceiversTemperature validation
        """
        command_output = self.instance_commands[0].json_output
        sensors = command_output["tempSensors"] if "tempSensors" in command_output.keys() else ""
        wrong_sensors = {
            sensor["name"]: {
                "hwStatus": sensor["hwStatus"],
                "alertCount": sensor["alertCount"],
            }
            for sensor in sensors
            if sensor["hwStatus"] != "ok" or sensor["alertCount"] != 0
        }
        if not wrong_sensors:
            self.result.is_success()
        else:
            self.result.is_failure(f"The following sensors are operating outside the acceptable temperature range or have raised alerts: {wrong_sensors}")

test 

test() -> None

Run VerifyTransceiversTemperature validation

Source code in anta/tests/hardware.py 
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
@skip_on_platforms(["cEOSLab", "vEOS-lab"])
@AntaTest.anta_test
def test(self) -> None:
    """
    Run VerifyTransceiversTemperature validation
    """
    command_output = self.instance_commands[0].json_output
    sensors = command_output["tempSensors"] if "tempSensors" in command_output.keys() else ""
    wrong_sensors = {
        sensor["name"]: {
            "hwStatus": sensor["hwStatus"],
            "alertCount": sensor["alertCount"],
        }
        for sensor in sensors
        if sensor["hwStatus"] != "ok" or sensor["alertCount"] != 0
    }
    if not wrong_sensors:
        self.result.is_success()
    else:
        self.result.is_failure(f"The following sensors are operating outside the acceptable temperature range or have raised alerts: {wrong_sensors}")
Last update: July 19, 2023