Skip to content

BGP

ANTA catalog for routing-bgp tests

BGP test functions

VerifyBGPEVPNCount

Bases: AntaTest

Verifies all EVPN BGP sessions are established (default VRF) and the actual number of BGP EVPN neighbors is the one we expect (default VRF).

  • self.result = “skipped” if the number parameter is missing
  • self.result = “success” if all EVPN BGP sessions are Established and if the actual number of BGP EVPN neighbors is the one we expect.
  • self.result = “failure” otherwise.
Source code in anta/tests/routing/bgp.py 
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
class VerifyBGPEVPNCount(AntaTest):
    """
    Verifies all EVPN BGP sessions are established (default VRF)
    and the actual number of BGP EVPN neighbors is the one we expect (default VRF).

    * self.result = "skipped" if the `number` parameter is missing
    * self.result = "success" if all EVPN BGP sessions are Established and if the actual
                         number of BGP EVPN neighbors is the one we expect.
    * self.result = "failure" otherwise.
    """

    name = "VerifyBGPEVPNCount"
    description = "Verifies all EVPN BGP sessions are established (default VRF) and the actual number of BGP EVPN neighbors is the one we expect (default VRF)."
    categories = ["routing", "bgp"]
    commands = [AntaCommand(command="show bgp evpn summary")]

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

        Args:
            number: The expected number of BGP EVPN neighbors in the default VRF.
        """
        if not number:
            self.result.is_skipped("VerifyBGPEVPNCount could not run because number was not supplied.")
            return

        command_output = self.instance_commands[0].json_output

        peers = command_output["vrfs"]["default"]["peers"]
        non_established_peers = [peer for peer, peer_dict in peers.items() if peer_dict["peerState"] != "Established"]

        if not non_established_peers and len(peers) == number:
            self.result.is_success()
        else:
            self.result.is_failure()
            if len(peers) != number:
                self.result.is_failure(f"Expecting {number} BGP EVPN peers and got {len(peers)}")
            if non_established_peers:
                self.result.is_failure(f"The following EVPN peers are not established: {non_established_peers}")

test 

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

Run VerifyBGPEVPNCount validation

Parameters:

Name Type Description Default
number Optional[int]

The expected number of BGP EVPN neighbors in the default VRF.

 None
Source code in anta/tests/routing/bgp.py 
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
@check_bgp_family_enable("evpn")
@AntaTest.anta_test
def test(self, number: Optional[int] = None) -> None:
    """
    Run VerifyBGPEVPNCount validation

    Args:
        number: The expected number of BGP EVPN neighbors in the default VRF.
    """
    if not number:
        self.result.is_skipped("VerifyBGPEVPNCount could not run because number was not supplied.")
        return

    command_output = self.instance_commands[0].json_output

    peers = command_output["vrfs"]["default"]["peers"]
    non_established_peers = [peer for peer, peer_dict in peers.items() if peer_dict["peerState"] != "Established"]

    if not non_established_peers and len(peers) == number:
        self.result.is_success()
    else:
        self.result.is_failure()
        if len(peers) != number:
            self.result.is_failure(f"Expecting {number} BGP EVPN peers and got {len(peers)}")
        if non_established_peers:
            self.result.is_failure(f"The following EVPN peers are not established: {non_established_peers}")

VerifyBGPEVPNState

Bases: AntaTest

Verifies all EVPN BGP sessions are established (default VRF).

  • self.result = “skipped” if no BGP EVPN peers are returned by the device
  • self.result = “success” if all EVPN BGP sessions are established.
  • self.result = “failure” otherwise.
Source code in anta/tests/routing/bgp.py 
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
class VerifyBGPEVPNState(AntaTest):
    """
    Verifies all EVPN BGP sessions are established (default VRF).

    * self.result = "skipped" if no BGP EVPN peers are returned by the device
    * self.result = "success" if all EVPN BGP sessions are established.
    * self.result = "failure" otherwise.
    """

    name = "VerifyBGPEVPNState"
    description = "Verifies all EVPN BGP sessions are established (default VRF)."
    categories = ["routing", "bgp"]
    commands = [AntaCommand(command="show bgp evpn summary")]

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

        command_output = self.instance_commands[0].json_output

        bgp_vrfs = command_output["vrfs"]

        peers = bgp_vrfs["default"]["peers"]
        non_established_peers = [peer for peer, peer_dict in peers.items() if peer_dict["peerState"] != "Established"]

        if not non_established_peers:
            self.result.is_success()
        else:
            self.result.is_failure(f"The following EVPN peers are not established: {non_established_peers}")

test 

test() -> None

Run VerifyBGPEVPNState validation

Source code in anta/tests/routing/bgp.py 
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
@check_bgp_family_enable("evpn")
@AntaTest.anta_test
def test(self) -> None:
    """Run VerifyBGPEVPNState validation"""

    command_output = self.instance_commands[0].json_output

    bgp_vrfs = command_output["vrfs"]

    peers = bgp_vrfs["default"]["peers"]
    non_established_peers = [peer for peer, peer_dict in peers.items() if peer_dict["peerState"] != "Established"]

    if not non_established_peers:
        self.result.is_success()
    else:
        self.result.is_failure(f"The following EVPN peers are not established: {non_established_peers}")

VerifyBGPIPv4UnicastCount

Bases: AntaTest

Verifies all IPv4 unicast BGP sessions are established and all BGP messages queues for these sessions are empty and the actual number of BGP IPv4 unicast neighbors is the one we expect.

  • self.result = “skipped” if the number or vrf parameter is missing
  • self.result = “success” if all IPv4 unicast BGP sessions are established and if all BGP messages queues for these sessions are empty and if the actual number of BGP IPv4 unicast neighbors is equal to `number.
  • self.result = “failure” otherwise.
Source code in anta/tests/routing/bgp.py 
 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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
class VerifyBGPIPv4UnicastCount(AntaTest):
    """
    Verifies all IPv4 unicast BGP sessions are established
    and all BGP messages queues for these sessions are empty
    and the actual number of BGP IPv4 unicast neighbors is the one we expect.

    * self.result = "skipped" if the `number` or `vrf` parameter is missing
    * self.result = "success" if all IPv4 unicast BGP sessions are established
                         and if all BGP messages queues for these sessions are empty
                         and if the actual number of BGP IPv4 unicast neighbors is equal to `number.
    * self.result = "failure" otherwise.
    """

    name = "VerifyBGPIPv4UnicastCount"
    description = (
        "Verifies all IPv4 unicast BGP sessions are established and all their BGP messages queues are empty and "
        " the actual number of BGP IPv4 unicast neighbors is the one we expect."
    )
    categories = ["routing", "bgp"]
    template = AntaTemplate(template="show bgp ipv4 unicast summary vrf {vrf}")

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

        Args:
            number: The expected number of BGP IPv4 unicast neighbors.
            vrf: VRF to verify (template parameter)
        """

        if not number:
            self.result.is_skipped("VerifyBGPIPv4UnicastCount could not run because number was not supplied")
            return

        self.result.is_success()

        for command in self.instance_commands:
            if command.params and "vrf" in command.params:
                vrf = command.params["vrf"]

            peers = command.json_output["vrfs"][vrf]["peers"]
            state_issue = _check_bgp_vrfs(command.json_output["vrfs"])

            if len(peers) != number:
                self.result.is_failure(f"Expecting {number} BGP peer in vrf {vrf} and got {len(peers)}")
            if state_issue:
                self.result.is_failure(f"The following IPv4 peers are not established: {state_issue}")

test 

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

Run VerifyBGPIPv4UnicastCount validation

Parameters:

Name Type Description Default
number Optional[int]

The expected number of BGP IPv4 unicast neighbors.

 None
vrf

VRF to verify (template parameter)

 required
Source code in anta/tests/routing/bgp.py 
 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
@check_bgp_family_enable("ipv4")
@AntaTest.anta_test
def test(self, number: Optional[int] = None) -> None:
    """
    Run VerifyBGPIPv4UnicastCount validation

    Args:
        number: The expected number of BGP IPv4 unicast neighbors.
        vrf: VRF to verify (template parameter)
    """

    if not number:
        self.result.is_skipped("VerifyBGPIPv4UnicastCount could not run because number was not supplied")
        return

    self.result.is_success()

    for command in self.instance_commands:
        if command.params and "vrf" in command.params:
            vrf = command.params["vrf"]

        peers = command.json_output["vrfs"][vrf]["peers"]
        state_issue = _check_bgp_vrfs(command.json_output["vrfs"])

        if len(peers) != number:
            self.result.is_failure(f"Expecting {number} BGP peer in vrf {vrf} and got {len(peers)}")
        if state_issue:
            self.result.is_failure(f"The following IPv4 peers are not established: {state_issue}")

VerifyBGPIPv4UnicastState

Bases: AntaTest

Verifies all IPv4 unicast BGP sessions are established (for all VRF) and all BGP messages queues for these sessions are empty (for all VRF).

  • self.result = “skipped” if no BGP vrf are returned by the device
  • self.result = “success” if all IPv4 unicast BGP sessions are established (for all VRF) and all BGP messages queues for these sessions are empty (for all VRF).
  • self.result = “failure” otherwise.
Source code in anta/tests/routing/bgp.py 
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
class VerifyBGPIPv4UnicastState(AntaTest):
    """
    Verifies all IPv4 unicast BGP sessions are established (for all VRF)
    and all BGP messages queues for these sessions are empty (for all VRF).

    * self.result = "skipped" if no BGP vrf are returned by the device
    * self.result = "success" if all IPv4 unicast BGP sessions are established (for all VRF)
                         and all BGP messages queues for these sessions are empty (for all VRF).
    * self.result = "failure" otherwise.
    """

    name = "VerifyBGPIPv4UnicastState"
    description = "Verifies all IPv4 unicast BGP sessions are established (for all VRF) and all BGP messages queues for these sessions are empty (for all VRF)."
    categories = ["routing", "bgp"]
    commands = [AntaCommand(command="show bgp ipv4 unicast summary vrf all")]

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

        command_output = self.instance_commands[0].json_output
        state_issue = _check_bgp_vrfs(command_output["vrfs"])

        if not state_issue:
            self.result.is_success()
        else:
            self.result.is_failure(f"Some IPv4 Unicast BGP Peer are not up: {state_issue}")

test 

test() -> None

Run VerifyBGPIPv4UnicastState validation

Source code in anta/tests/routing/bgp.py 
53
54
55
56
57
58
59
60
61
62
63
64
@check_bgp_family_enable("ipv4")
@AntaTest.anta_test
def test(self) -> None:
    """Run VerifyBGPIPv4UnicastState validation"""

    command_output = self.instance_commands[0].json_output
    state_issue = _check_bgp_vrfs(command_output["vrfs"])

    if not state_issue:
        self.result.is_success()
    else:
        self.result.is_failure(f"Some IPv4 Unicast BGP Peer are not up: {state_issue}")

VerifyBGPIPv6UnicastState

Bases: AntaTest

Verifies all IPv6 unicast BGP sessions are established (for all VRF) and all BGP messages queues for these sessions are empty (for all VRF).

  • self.result = “skipped” if no BGP vrf are returned by the device
  • self.result = “success” if all IPv6 unicast BGP sessions are established (for all VRF) and all BGP messages queues for these sessions are empty (for all VRF).
  • self.result = “failure” otherwise.
Source code in anta/tests/routing/bgp.py 
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
class VerifyBGPIPv6UnicastState(AntaTest):
    """
    Verifies all IPv6 unicast BGP sessions are established (for all VRF)
    and all BGP messages queues for these sessions are empty (for all VRF).

    * self.result = "skipped" if no BGP vrf are returned by the device
    * self.result = "success" if all IPv6 unicast BGP sessions are established (for all VRF)
                         and all BGP messages queues for these sessions are empty (for all VRF).
    * self.result = "failure" otherwise.
    """

    name = "VerifyBGPIPv6UnicastState"
    description = "Verifies all IPv6 unicast BGP sessions are established (for all VRF) and all BGP messages queues for these sessions are empty (for all VRF)."
    categories = ["routing", "bgp"]
    commands = [AntaCommand(command="show bgp ipv6 unicast summary vrf all")]

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

        command_output = self.instance_commands[0].json_output

        state_issue = _check_bgp_vrfs(command_output["vrfs"])

        if not state_issue:
            self.result.is_success()
        else:
            self.result.is_failure(f"Some IPv4 Unicast BGP Peer are not up: {state_issue}")

test 

test() -> None

Run VerifyBGPIPv6UnicastState validation

Source code in anta/tests/routing/bgp.py 
134
135
136
137
138
139
140
141
142
143
144
145
146
@check_bgp_family_enable("ipv6")
@AntaTest.anta_test
def test(self) -> None:
    """Run VerifyBGPIPv6UnicastState validation"""

    command_output = self.instance_commands[0].json_output

    state_issue = _check_bgp_vrfs(command_output["vrfs"])

    if not state_issue:
        self.result.is_success()
    else:
        self.result.is_failure(f"Some IPv4 Unicast BGP Peer are not up: {state_issue}")

VerifyBGPRTCCount

Bases: AntaTest

Verifies all RTC BGP sessions are established (default VRF) and the actual number of BGP RTC neighbors is the one we expect (default VRF).

  • self.result = “skipped” if the number parameter is missing
  • self.result = “success” if all RTC BGP sessions are Established and if the actual number of BGP RTC neighbors is the one we expect.
  • self.result = “failure” otherwise.
Source code in anta/tests/routing/bgp.py 
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
class VerifyBGPRTCCount(AntaTest):
    """
    Verifies all RTC BGP sessions are established (default VRF)
    and the actual number of BGP RTC neighbors is the one we expect (default VRF).

    * self.result = "skipped" if the `number` parameter is missing
    * self.result = "success" if all RTC BGP sessions are Established and if the actual
                         number of BGP RTC neighbors is the one we expect.
    * self.result = "failure" otherwise.
    """

    name = "VerifyBGPRTCCount"
    description = "Verifies all RTC BGP sessions are established (default VRF) and the actual number of BGP RTC neighbors is the one we expect (default VRF)."
    categories = ["routing", "bgp"]
    commands = [AntaCommand(command="show bgp rt-membership summary")]

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

        Args:
            number: The expected number of BGP RTC neighbors (default VRF).
        """
        if not number:
            self.result.is_skipped("VerifyBGPRTCCount could not run because number was not supplied")
            return

        command_output = self.instance_commands[0].json_output

        peers = command_output["vrfs"]["default"]["peers"]
        non_established_peers = [peer for peer, peer_dict in peers.items() if peer_dict["peerState"] != "Established"]

        if not non_established_peers and len(peers) == number:
            self.result.is_success()
        else:
            self.result.is_failure()
            if len(peers) != number:
                self.result.is_failure(f"Expecting {number} BGP RTC peers and got {len(peers)}")
            if non_established_peers:
                self.result.is_failure(f"The following RTC peers are not established: {non_established_peers}")

test 

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

Run VerifyBGPRTCCount validation

Parameters:

Name Type Description Default
number Optional[int]

The expected number of BGP RTC neighbors (default VRF).

 None
Source code in anta/tests/routing/bgp.py 
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
@check_bgp_family_enable("rtc")
@AntaTest.anta_test
def test(self, number: Optional[int] = None) -> None:
    """
    Run VerifyBGPRTCCount validation

    Args:
        number: The expected number of BGP RTC neighbors (default VRF).
    """
    if not number:
        self.result.is_skipped("VerifyBGPRTCCount could not run because number was not supplied")
        return

    command_output = self.instance_commands[0].json_output

    peers = command_output["vrfs"]["default"]["peers"]
    non_established_peers = [peer for peer, peer_dict in peers.items() if peer_dict["peerState"] != "Established"]

    if not non_established_peers and len(peers) == number:
        self.result.is_success()
    else:
        self.result.is_failure()
        if len(peers) != number:
            self.result.is_failure(f"Expecting {number} BGP RTC peers and got {len(peers)}")
        if non_established_peers:
            self.result.is_failure(f"The following RTC peers are not established: {non_established_peers}")

VerifyBGPRTCState

Bases: AntaTest

Verifies all RTC BGP sessions are established (default VRF).

  • self.result = “skipped” if no BGP RTC peers are returned by the device
  • self.result = “success” if all RTC BGP sessions are established.
  • self.result = “failure” otherwise.
Source code in anta/tests/routing/bgp.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
252
253
254
class VerifyBGPRTCState(AntaTest):
    """
    Verifies all RTC BGP sessions are established (default VRF).

    * self.result = "skipped" if no BGP RTC peers are returned by the device
    * self.result = "success" if all RTC BGP sessions are established.
    * self.result = "failure" otherwise.
    """

    name = "VerifyBGPRTCState"
    description = "Verifies all RTC BGP sessions are established (default VRF)."
    categories = ["routing", "bgp"]
    commands = [AntaCommand(command="show bgp rt-membership summary")]

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

        command_output = self.instance_commands[0].json_output

        bgp_vrfs = command_output["vrfs"]

        peers = bgp_vrfs["default"]["peers"]
        non_established_peers = [peer for peer, peer_dict in peers.items() if peer_dict["peerState"] != "Established"]

        if not non_established_peers:
            self.result.is_success()
        else:
            self.result.is_failure(f"The following RTC peers are not established: {non_established_peers}")

test 

test() -> None

Run VerifyBGPRTCState validation

Source code in anta/tests/routing/bgp.py 
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
@check_bgp_family_enable("rtc")
@AntaTest.anta_test
def test(self) -> None:
    """Run VerifyBGPRTCState validation"""

    command_output = self.instance_commands[0].json_output

    bgp_vrfs = command_output["vrfs"]

    peers = bgp_vrfs["default"]["peers"]
    non_established_peers = [peer for peer, peer_dict in peers.items() if peer_dict["peerState"] != "Established"]

    if not non_established_peers:
        self.result.is_success()
    else:
        self.result.is_failure(f"The following RTC peers are not established: {non_established_peers}")
Last update: July 19, 2023