def test_statistics(self, env): """ @brief Work with Statistics """ # Get available TG ports from the environment ports = env.get_ports([ ['tg1', 'sw1', 4], ]) tg_ports = list(ports[('tg1', 'sw1')].values()) # Set necessary ports in Up state helpers.set_ports_admin_enabled(env.switch, ports) self.suite_logger.debug("Create simple streams") # Create packet definition in format # list[dict{LAYER_NAME: dict{LAYER_ATTR: VAL}}] packet_definition = [{ 'Ethernet': { 'src': '00:00:33:33:33:33', 'dst': '00:00:44:44:44:44' } }, { 'IP': { 'src': '20.20.0.12', 'dst': '20.20.0.15' } }] # Configure stream: send 5 packets from link 1 stream = env.tg[1].set_stream(packet_definition, iface=tg_ports[0], count=5) # 1. Clear Ports statistics env.tg[1].clear_statistics(tg_ports) # Start capture on TG ports for 5 seconds env.tg[1].start_sniff(tg_ports, sniffing_time=5, filter_layer='IP') # Send stream env.tg[1].send_stream(stream) # Stop capture data = env.tg[1].stop_sniff(tg_ports) # Print captured frames in DEBUG mode helpers.print_sniffed_data_brief(data) # Verify received frames params = [{ "layer": "Ethernet", "field": 'src', "value": '00:00:33:33:33:33' }, { "layer": "Ethernet", "field": 'dst', "value": '00:00:44:44:44:44' }] assert len(helpers.get_packet_from_the_port(sniff_port=tg_ports[1], params=params, sniff_data=data, tg=env.tg[1])) == 5, \ "Packets are not received" # 2. Get sent statistics sent_cont = env.tg[1].get_sent_frames_count(tg_ports[0]) assert sent_cont == 5 # 3. Get received frames count (filtered + unfiltered) received_count = env.tg[1].get_received_frames_count(tg_ports[1]) assert received_count >= 5 # 4. Get filtered frames count filtered_count = env.tg[1].get_filtered_frames_count(tg_ports[1]) assert filtered_count == 5
def test_mirroring_traffic(self, env): """ @brief Verify that simple Mirroring session can be created and deleted @steps -# Create simple mirroring session. -# Create static Fdb entry -# Send traffic that match created Fdb. -# Verify traffic is forwarded. -# Verify traffic is mirrored. @endsteps """ # Get active ports: use four ports for test case active_ports = env.get_ports([['tg1', 'sw1', 3], ]) device_ports = list(active_ports[('sw1', 'tg1')].values()) sniff_ports = list(active_ports[('tg1', 'sw1')].values()) # Disable all ports and enabling only necessary ones: helpers.set_all_ports_admin_disabled(env.switch) helpers.set_ports_admin_enabled(env.switch, active_ports) self.suite_logger.debug("Disable STP.") env.switch[1].ui.configure_spanning_tree(enable='Disabled') self.suite_logger.debug("Create Static FDB") # Create static Fdb record for second port mac = "00:00:00:11:11:11" env.switch[1].ui.create_static_macs(port=device_ports[1], vlans=[1], macs=[mac]) # Create simple mirroring session env.switch[1].ui.create_mirror_session(device_ports[0], device_ports[2], 'IngressAndEgress') # Generate test traffic packet = ({"Ethernet": {"dst": "00:00:00:11:11:11", "src": "00:00:00:02:02:02", "type": 0x8100}}, {"Dot1Q": {"vlan": 1}}, {"IP": {}}, {"TCP": {}}) # Send packets to the first port stream = env.tg[1].set_stream(packet, count=1, iface=sniff_ports[0]) self.suite_logger.debug("Start the capture and send the test traffic") # Start capture env.tg[1].start_sniff(sniff_ports, sniffing_time=10) # Send generated streams env.tg[1].send_stream(stream) # Stop capture data = env.tg[1].stop_sniff(sniff_ports) # Print captured data helpers.print_sniffed_data_brief(data) self.suite_logger.debug("Verify traffic is processed according to the FDB record") # Get packets from the captured data # Verify first packet is sent only to second port params_1 = [{"layer": "Ethernet", "field": 'dst', "value": '00:00:00:11:11:11'}, {"layer": "Ethernet", "field": 'src', "value": '00:00:00:02:02:02'}] assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[1], params=params_1, sniff_data=data, tg=env.tg[1])) == 1, \ "Packet is not received" # Verify ingress packet is mirrored params_2 = [{"layer": "Ethernet", "field": 'dst', "value": '00:00:00:11:11:11'}, {"layer": "Ethernet", "field": 'src', "value": '00:00:00:02:02:02'}, {"layer": "Dot1Q", "field": 'vlan', "value": 1}] assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[2], params=params_2, sniff_data=data, tg=env.tg[1])) == 1, \ "Packet is not received"
def test_vlan_traffic(self, env): """ @brief Verify that traffic is processed according to the configured Vlan @steps -# Create new Vlan. -# Add two ports into Vlan -# Send traffic to the first Vlan port. -# Verify traffic is forwarded only from second Vlan port. @endsteps """ # Get active ports: use four ports for test case active_ports = env.get_ports([ ['tg1', 'sw1', 3], ]) device_ports = list(active_ports[('sw1', 'tg1')].values()) sniff_ports = list(active_ports[('tg1', 'sw1')].values()) # Disable all ports and enabling only necessary ones: helpers.set_all_ports_admin_disabled(env.switch) helpers.set_ports_admin_enabled(env.switch, active_ports) self.suite_logger.debug("Disable STP.") env.switch[1].ui.configure_spanning_tree(enable='Disabled') # Create new Vlan env.switch[1].ui.create_vlans(vlans=[ 20, ]) # Add port into the Vlan env.switch[1].ui.create_vlan_ports(ports=device_ports[:2], vlans=[20], tagged='Untagged') # Generate test traffic packet = ({ "Ethernet": { "dst": "00:00:11:11:11:11", "src": "00:00:02:02:02:02", "type": 0x8100 } }, { 'Dot1Q': { 'vlan': 20 } }, { "IP": {} }, { "TCP": {} }) # Send packets to the first port stream = env.tg[1].set_stream(packet, count=1, iface=sniff_ports[0]) self.suite_logger.debug("Start the capture and send the test traffic") # Start capture env.tg[1].start_sniff(sniff_ports, sniffing_time=5) # Send generated streams env.tg[1].send_stream(stream) # Stop capture data = env.tg[1].stop_sniff(sniff_ports) # Print captured data helpers.print_sniffed_data_brief(data) # Get packets from the captured data # Verify first packet is sent only to second port params = [{ "layer": "Ethernet", "field": 'dst', "value": '00:00:11:11:11:11' }, { "layer": "Ethernet", "field": 'src', "value": '00:00:02:02:02:02' }] #Traffic should be forwarded from Vlan ports assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[1], params=params, sniff_data=data, tg=env.tg[1])) == 1, \ "Packet is not received" # Traffic should not be forwarded from non-Vlan ports assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[2], params=params, sniff_data=data, tg=env.tg[1])) == 0, \ "Packet is received"
def test_capture(self, env): """ @brief Capture configuration """ # Get available TG ports from the environment ports = env.get_ports([ ['tg1', 'sw1', 4], ]) tg_ports = list(ports[('tg1', 'sw1')].values()) # Set necessary ports in Up state helpers.set_ports_admin_enabled(env.switch, ports) self.suite_logger.debug("Create simple streams") # Create packet definition in format # list[dict{LAYER_NAME: dict{LAYER_ATTR: VAL}}] packet_definition_1 = [{ 'Ethernet': { 'src': '00:00:00:11:11:11', 'dst': '00:00:00:22:22:22' } }, { 'IP': {} }] packet_definition_2 = [{ 'Ethernet': { 'src': '00:00:00:33:33:33', 'dst': '00:00:00:44:44:44' } }, { 'IP': { 'src': '192.168.0.12', 'dst': '192.168.0.15' } }] # Configure stream: send 5 packets from link 1 stream_1 = env.tg[1].set_stream(packet_definition_1, iface=tg_ports[0], count=5) stream_2 = env.tg[1].set_stream(packet_definition_2, iface=tg_ports[0], count=5) # 1. Start capture on TG ports for 5 seconds env.tg[1].start_sniff(tg_ports, sniffing_time=5) # Send stream env.tg[1].start_streams([stream_1, stream_2]) # Stop capture # TAF will wait 'sniffing_time' to stop capture data = env.tg[1].stop_sniff(tg_ports) # Print captured frames in DEBUG mode helpers.print_sniffed_data_brief(data) env.tg[1].stop_streams([stream_1, stream_2]) # Verify received frames params_1 = [{ "layer": "Ethernet", "field": 'src', "value": '00:00:00:11:11:11' }, { "layer": "Ethernet", "field": 'dst', "value": '00:00:00:22:22:22' }] assert len(helpers.get_packet_from_the_port(sniff_port=tg_ports[1], params=params_1, sniff_data=data, tg=env.tg[1])) == 5, \ "Packets are not received" params_2 = [{ "layer": "Ethernet", "field": 'src', "value": '00:00:00:33:33:33' }, { "layer": "Ethernet", "field": 'dst', "value": '00:00:00:44:44:44' }] assert len(helpers.get_packet_from_the_port(sniff_port=tg_ports[1], params=params_2, sniff_data=data, tg=env.tg[1])) == 5, \ "Packets are not received" # 2. Configure filter by layer: please see list of available # layers in testlib.packet_processor.flt_patterns . # Capture IP frames env.tg[1].start_sniff(tg_ports, sniffing_time=5, filter_layer='IP') # Send stream env.tg[1].start_streams([stream_1, stream_2]) # Stop capture data = env.tg[1].stop_sniff(tg_ports) # Print captured frames helpers.print_sniffed_data_brief(data) env.tg[1].stop_streams([stream_1, stream_2]) # Verify received frames params_1 = [{ "layer": "Ethernet", "field": 'src', "value": '00:00:00:11:11:11' }, { "layer": "Ethernet", "field": 'dst', "value": '00:00:00:22:22:22' }] assert len(helpers.get_packet_from_the_port(sniff_port=tg_ports[1], params=params_1, sniff_data=data, tg=env.tg[1])) == 0, \ "non IP packets were received" params_2 = [{ "layer": "Ethernet", "field": 'src', "value": '00:00:00:33:33:33' }, { "layer": "Ethernet", "field": 'dst', "value": '00:00:00:44:44:44' }] assert len(helpers.get_packet_from_the_port(sniff_port=tg_ports[1], params=params_2, sniff_data=data, tg=env.tg[1])) == 5, \ "Packets are not received" # 3. Configure filter by Ethernet.src env.tg[1].start_sniff(tg_ports, sniffing_time=5, src_filter='00:00:00:33:33:33') # Send stream env.tg[1].start_streams([stream_1, stream_2]) # Stop capture data = env.tg[1].stop_sniff(tg_ports) # Print captured frames helpers.print_sniffed_data_brief(data) env.tg[1].stop_streams([stream_1, stream_2]) # Verify received frames params_1 = [{ "layer": "Ethernet", "field": 'src', "value": '00:00:00:11:11:11' }, { "layer": "Ethernet", "field": 'dst', "value": '00:00:00:22:22:22' }] assert len(helpers.get_packet_from_the_port(sniff_port=tg_ports[1], params=params_1, sniff_data=data, tg=env.tg[1])) == 0, \ "non IP packets were received" params_2 = [{ "layer": "Ethernet", "field": 'src', "value": '00:00:00:33:33:33' }, { "layer": "Ethernet", "field": 'dst', "value": '00:00:00:44:44:44' }] assert len(helpers.get_packet_from_the_port(sniff_port=tg_ports[1], params=params_2, sniff_data=data, tg=env.tg[1])) == 5, \ "Packets are not received" # 4. Configure filter by Ethernet.dst env.tg[1].start_sniff(tg_ports, sniffing_time=5, dst_filter='00:00:00:44:44:44') # Send stream env.tg[1].start_streams([stream_1, stream_2]) # Stop capture data = env.tg[1].stop_sniff(tg_ports) # Print captured frames helpers.print_sniffed_data_brief(data) env.tg[1].stop_streams([stream_1, stream_2]) # Verify received frames params_1 = [{ "layer": "Ethernet", "field": 'src', "value": '00:00:00:11:11:11' }, { "layer": "Ethernet", "field": 'dst', "value": '00:00:00:22:22:22' }] assert len(helpers.get_packet_from_the_port(sniff_port=tg_ports[1], params=params_1, sniff_data=data, tg=env.tg[1])) == 0, \ "non IP packets were received" params_2 = [{ "layer": "Ethernet", "field": 'src', "value": '00:00:00:33:33:33' }, { "layer": "Ethernet", "field": 'dst', "value": '00:00:00:44:44:44' }] assert len(helpers.get_packet_from_the_port(sniff_port=tg_ports[1], params=params_2, sniff_data=data, tg=env.tg[1])) == 5, \ "Packets are not received" # 5. User can combine filter_layer with src and dst filters # Configure filter by Ethernet.dst and IP layer env.tg[1].start_sniff(tg_ports, sniffing_time=5, dst_filter='00:00:00:44:44:44', filter_layer='IP') # Send stream env.tg[1].start_streams([stream_1, stream_2]) # Stop capture data = env.tg[1].stop_sniff(tg_ports) # Print captured frames helpers.print_sniffed_data_brief(data) env.tg[1].stop_streams([stream_1, stream_2]) # Verify received frames params_1 = [{ "layer": "Ethernet", "field": 'src', "value": '00:00:00:11:11:11' }, { "layer": "Ethernet", "field": 'dst', "value": '00:00:00:22:22:22' }] assert len(helpers.get_packet_from_the_port(sniff_port=tg_ports[1], params=params_1, sniff_data=data, tg=env.tg[1])) == 0, \ "non IP packets were received" params_2 = [{ "layer": "Ethernet", "field": 'src', "value": '00:00:00:33:33:33' }, { "layer": "Ethernet", "field": 'dst', "value": '00:00:00:44:44:44' }] assert len(helpers.get_packet_from_the_port(sniff_port=tg_ports[1], params=params_2, sniff_data=data, tg=env.tg[1])) == 5, \ "Packets are not received" # 6. Capture certain number of frames # However filtering works after packets were received, # so real number of frames could be less than expected env.tg[1].env.tg[1].start_sniff([tg_ports[1], tg_ports[2]], packets_count=3, filter_layer='IP') env.tg[1].start_streams([stream_1, stream_2]) # Stop capture data = env.tg[1].stop_sniff([tg_ports[1], tg_ports[2]]) # Print captured frames helpers.print_sniffed_data_brief(data) env.tg[1].stop_streams([stream_1, stream_2]) # Verify received frames params_1 = [{ "layer": "Ethernet", "field": 'src', "value": '00:00:00:11:11:11' }, { "layer": "Ethernet", "field": 'dst', "value": '00:00:00:22:22:22' }] assert len(helpers.get_packet_from_the_port(sniff_port=tg_ports[1], params=params_1, sniff_data=data, tg=env.tg[1])) == 0, \ "non IP packets were received" params_2 = [{ "layer": "Ethernet", "field": 'src', "value": '00:00:00:33:33:33' }, { "layer": "Ethernet", "field": 'dst', "value": '00:00:00:44:44:44' }] assert len(helpers.get_packet_from_the_port(sniff_port=tg_ports[1], params=params_2, sniff_data=data, tg=env.tg[1])) <= 3, \ "Packets are not received" # 7. Stop capture immediately env.tg[1].start_sniff(tg_ports, sniffing_time=30) time.sleep(5) env.tg[1].stop_sniff(tg_ports, force=True) # 8. Change captured buffer size (1000 frames by default) env.tg[1].start_sniff(tg_ports, sniffing_time=3) # TAF will return only 5 frames from buffer for each port env.tg[1].stop_sniff(tg_ports, sniff_packet_count=5) # 9. Ignore frames in the captured buffer # use in case test doesn't process captured frames, but # makes decisions based on statistics values env.tg[1].start_sniff(tg_ports, sniffing_time=3) # TAF will return only 5 frames from buffer for each port env.tg[1].stop_sniff(tg_ports, drop_packets=True)
def test_acl_traffic(self, env): """ @brief Simple ACL test with traffic @steps -# Configure ACL: drop all packets. -# Configure ACL: allow packets with Ethernet.dst=00:00:00:01:01:01. -# Create stream with Ethernet.dst=00:00:00:01:01:01. -# Create stream with Ethernet.dst=00:00:00:03:03:03. -# Send streams. -# Verify first stream is flooded. -# Verify second stream is discarded. @endsteps """ # Get active ports: use four ports for test case active_ports = env.get_ports([ ['tg1', 'sw1', 4], ]) device_ports = list(active_ports[('sw1', 'tg1')].values()) sniff_ports = list(active_ports[('tg1', 'sw1')].values()) # Disable all ports and enabling only necessary ones: helpers.set_all_ports_admin_disabled(env.switch) helpers.set_ports_admin_enabled(env.switch, active_ports) self.suite_logger.debug("Disable STP.") env.switch[1].ui.configure_spanning_tree(enable='Disabled') # Configure ACL: drop all packets; # allow only packets with Ethernet.dst=00:00:00:01:01:01 # Configure ACL Expression in format (id, expression, mask, value) self.suite_logger.debug("Create ACLs") expressions = [(1, 'SrcMac', '00:00:00:00:00:00', '00:00:00:00:00:00'), (2, 'DstMac', 'FF:FF:FF:FF:FF:FF', '00:00:00:01:01:01')] # Configure ACL Action in format (id, action, params) actions = [(1, 'Drop', ''), (2, 'Allow', '')] # Configure ACL Rule in format # (id, expression_id, action_id, stage, enabled, priority) rules = [(1, 1, 1, 'Ingress', 'Enabled', 0), (2, 2, 2, 'Ingress', 'Enabled', 0)] # Create ACLs on device's ports try: env.switch[1].ui.create_acl(ports=device_ports, expressions=expressions, actions=actions, rules=rules) except Exception as err: # Exception in configuration self.suite_logger.debug('ACL configuration failed: %s' % err) pytest.fail('ACL configuration failed') # Wait some time for proper switch behavior time.sleep(1) # Generate test traffic packet_1 = ({ "Ethernet": { "dst": "00:00:00:01:01:01", "src": "00:00:00:02:02:02" } }, { "IP": {} }, { "TCP": {} }) packet_2 = ({ "Ethernet": { "dst": "00:00:00:03:03:03", "src": "00:00:00:04:04:04" } }, { "IP": {} }, { "TCP": {} }) # Send packets to the first port stream_1 = env.tg[1].set_stream(packet_1, count=1, iface=sniff_ports[0]) stream_2 = env.tg[1].set_stream(packet_2, count=1, iface=sniff_ports[0]) streams = [stream_1, stream_2] # Start capture self.suite_logger.debug("Start the capture and send the test traffic") env.tg[1].start_sniff(sniff_ports, sniffing_time=10) # Send generated streams env.tg[1].start_streams(streams) # Stop capture data = env.tg[1].stop_sniff(sniff_ports) # Stop traffic env.tg[1].stop_streams() # Print captured data helpers.print_sniffed_data_brief(data) # Get packets from the captured data self.suite_logger.debug( "Verify traffic is processed according to the ACLs") # Verify first packet is flooded params_1 = [{ "layer": "Ethernet", "field": 'dst', "value": '00:00:00:01:01:01' }, { "layer": "Ethernet", "field": 'src', "value": '00:00:00:02:02:02' }] assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[1], params=params_1, sniff_data=data, tg=env.tg[1])) == 1, \ "Packet is not received" assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[2], params=params_1, sniff_data=data, tg=env.tg[1])) == 1, \ "Packet is not received" assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[3], params=params_1, sniff_data=data, tg=env.tg[1])) == 1, \ "Packet is not received" # Verify second packet is dropped params_1 = [{ "layer": "Ethernet", "field": 'dst', "value": '00:00:00:03:03:03' }, { "layer": "Ethernet", "field": 'src', "value": '00:00:00:04:04:04' }] assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[1], params=params_1, sniff_data=data, tg=env.tg[1])) == 0, \ "Packet is flooded" assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[2], params=params_1, sniff_data=data, tg=env.tg[1])) == 0, \ "Packet is flooded" assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[3], params=params_1, sniff_data=data, tg=env.tg[1])) == 0, \ "Packet is flooded"
def test_sent_pause_frames(self, env): """ @brief Verify that device doesn't flood received pause frames when flow control mode is configured. @steps -# Configure FlowControl on switch ports. -# Send PFC frames to the switch. -# Verify PFC frames are not flooded. @endsteps """ # Define active ports ports = env.get_ports([['tg1', 'sw1', 3], ]) # Disable all ports and enabling only necessary ones: helpers.set_all_ports_admin_disabled(env.switch) helpers.set_ports_admin_enabled(env.switch, ports) # Wait until ports will be in forwarding state. helpers.wait_until_stp_state(switch_instance=env.switch[1], mode="RSTP", state="Forwarding", port=ports[('sw1', 'tg1')][1], timeout=120) helpers.wait_until_stp_state(switch_instance=env.switch[1], mode="RSTP", state="Forwarding", port=ports[('sw1', 'tg1')][2], timeout=120) helpers.wait_until_stp_state(switch_instance=env.switch[1], mode="RSTP", state="Forwarding", port=ports[('sw1', 'tg1')][3], timeout=120) # Configure stream of pause frame. pause_frame = ({"Ethernet": {"dst": "01:80:C2:00:00:01", "src": "00:00:00:00:01:44", "type": 0x8808}}, {"Pause": {"opcode": 0x0001, "ptime": 1}}) stream = env.tg[1].set_stream(pause_frame, count=10, iface=ports[('tg1', 'sw1')][1]) sniff_ports = list(ports[('tg1', 'sw1')].values()) # Configure flow control values for all active ports. env.switch[1].ui.set_flow_control_type([ports[('sw1', 'tg1')][1], ports[('sw1', 'tg1')][2], ports[('sw1', 'tg1')][3]], control_type='RxTx') # Start capture env.tg[1].start_sniff(sniff_ports, sniffing_time=5) # Send pause frame from the TG port 1. env.tg[1].send_stream(stream) data = env.tg[1].stop_sniff(sniff_ports) helpers.print_sniffed_data_brief(data) # Verify that Pause Frames are not forwarded from tested ports. params = ({'layer': "Ethernet", 'field': "dst", 'value': "01:80:C2:00:00:01".lower()}, ) assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[0], params=params, sniff_data=data, tg=env.tg[1])) == 0, \ "Pause Frames are forwarded from port 1 when PF traffic is sent" assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[1], params=params, sniff_data=data, tg=env.tg[1])) == 0, \ "Pause Frames are forwarded from port 2 when PF traffic is sent" assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[2], params=params, sniff_data=data, tg=env.tg[1])) == 0, \ "Pause Frames are forwarded from port 3 when PF traffic is sent"
def test_static_route_two_ports_in_one_vlan(self, env): """ @brief Verify traffic forwarding upon two port on one VLAN and one Router Interface. @steps -# Configure Vlan 10 on ports 1 and 2. -# Create Route Interface 20.0.10.1/24 on Vlan 10. -# Create Static Route 10.10.10.0/24 with nexthop 20.0.10.2. -# Verify ARP request 'who has 20.0.10.2' received on port 2. -# Send ARP reply. -# Send IP packet with IP.dst 10.10.10.101 to the port 1. -# Verify IP packet is routed to the port 2. @endsteps """ # Define active ports. ports = env.get_ports([['tg1', 'sw1', 2], ]) port_1 = ports[('sw1', 'tg1')][1] port_2 = ports[('sw1', 'tg1')][2] # Disabling all ports and enabling only necessary ones: helpers.set_all_ports_admin_disabled(env.switch, wait_status=True) helpers.set_ports_admin_enabled(env.switch, ports, wait_status=True) # Define active ports for sniffing. sniff_ports = [ports[('tg1', 'sw1')][1], ports[('tg1', 'sw1')][2]] # Disable STP env.switch[1].ui.configure_spanning_tree(enable='Disabled') # Enable Routing. env.switch[1].ui.configure_routing(routing='Enabled', ospf=None) # Create test VLAN 10. env.switch[1].ui.create_vlans(vlans=[10]) # Add port 1 and port 3 to created test VLAN. env.switch[1].ui.create_vlan_ports(ports=[port_1, port_2], vlans=[10], tagged='Tagged') # Add route interface. env.switch[1].ui.create_route_interface(10, '20.0.10.1/24', ip_type='InterVlan', bandwidth=1000, mtu=1500, status='Enabled', vrf=0, mode='ip') # Start sniffer env.tg[1].start_sniff(sniff_ports, sniffing_time=10) # Add Static route. env.switch[1].ui.create_static_route(ip='10.10.10.0/24', nexthop='20.0.10.2', network='20.0.10.1/24', distance=-1, mode='ip') # Get sniffer data data = env.tg[1].stop_sniff(sniff_ports) helpers.print_sniffed_data_brief(data) # Verify who-has "20.0.10.2" ARP requests received. params_1 = [{"layer": "Ethernet", "field": 'dst', "value": 'ff:ff:ff:ff:ff:ff'}, {"layer": "ARP", "field": 'tpa', "value": '20.0.10.2'}] assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[1], params=params_1, sniff_data=data, tg=env.tg[1])) >= 1, \ "Packet is not received" # Get routers MAC. route_mac = env.switch[1].ui.get_table_route_interface()[0]['mac'] # Send ARP reply to port 2. arp_reply = ({"Ethernet": {"src": "00:00:14:00:0a:02", "dst": route_mac.lower(), "type": 0x8100}}, {"Dot1Q": {"vlan": 10}}, {"ARP": {"op": 2, "sha": "00:00:14:00:0a:02", "tha": route_mac, "tpa": "20.0.10.1", "spa": "20.0.10.2"}}, ) stream_id = env.tg[1].set_stream(arp_reply, count=1, iface=ports[('tg1', 'sw1')][2]) env.tg[1].send_stream(stream_id) time.sleep(2) # Verify ARP entry has been added arp_table = env.switch[1].ui.get_table_arp(mode='arp') assert self.is_arp_added(arps=arp_table, mac='00:00:14:00:0a:02', ip='20.0.10.2'), 'ARP entry was not added' # Start sniffer env.tg[1].start_sniff(sniff_ports, sniffing_time=10) # Send packet with source IP 20.0.10.101 and destination IP 10.10.10.101. packet_definition = ({"Ethernet": {"src": "00:00:10:00:02:65", "dst": route_mac, "type": 0x8100}}, {"Dot1Q": {"vlan": 10}}, {"IP": {"src": "20.0.10.101", "dst": "10.10.10.101", "p": 17}}, {"UDP": {"dport": 23, "sport": 23}}) stream_id = env.tg[1].set_stream(packet_definition, count=1, iface=ports[('tg1', 'sw1')][1]) env.tg[1].send_stream(stream_id) # Stop sniffer data = env.tg[1].stop_sniff(sniff_ports) helpers.print_sniffed_data_brief(data) # Verify packet with destination 10.10.10.101 is not forwarded back to port 1. params_2 = [{"layer": "IP", "field": 'dst', "value": '10.10.10.101'}, {"layer": "IP", "field": 'src', "value": '20.0.10.101'}, {"layer": "Ethernet", "field": 'src', "value": route_mac.lower()}] assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[0], params=params_2, sniff_data=data, tg=env.tg[1])) == 0, \ "Packet is received" # Verify packet is received from port 2. assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[1], params=params_2, sniff_data=data, tg=env.tg[1])) == 1, \ "Packet is not received"
def test_switch_ports_operations(self, env): """ @brief Simple operations with ports. """ # Get active ports. # JSON setup file contain info about links between devices # env.get_ports - returns dictionary of ports in format # {link_key: ports_dict} # where # link_key is a list of device's acronymes # ports_dict contains real port names (IDs) from JSON file # Example: # {('sw1', 'tg1'): {1: 24, 2: 25}, ('tg1', 'sw1'): {1: 'eth1', 2: 'eth2'}} # where switch's port 24 is connected to the traffic generator's port 'eth1', etc. # Get 4 links between switch and tg active_ports = env.get_ports([['tg1', 'sw1', 4], ]) # Disable all ports and enabling only necessary ports: # helpers module contains special methods to operate with ports # Set all switch ports into Admin Down state # in order to omit traffic from other connections helpers.set_all_ports_admin_disabled(env.switch) # Enable only links used in current test case helpers.set_ports_admin_enabled(env.switch, active_ports) self.suite_logger.debug("Create Static FDB") # Create static Fdb record for second port in configuration mac = "00:00:00:11:11:11" # Get second port of device port_2 = active_ports[('sw1', 'tg1')][2] env.switch[1].ui.create_static_macs(port=port_2, vlans=[1], macs=[mac]) # Generate test traffic packet_1 = ({"Ethernet": {"dst": "00:00:00:11:11:11", "src": "00:00:00:02:02:02"}}, {"IP": {}}, {"TCP": {}}) packet_2 = ({"Ethernet": {"dst": "00:00:00:03:03:03", "src": "00:00:00:04:04:04"}}, {"IP": {}}, {"TCP": {}}) # Send packets to the first port # Get first port of TG port_tg_2 = active_ports[('tg1', 'sw1')][1] stream_1 = env.tg[1].set_stream(packet_1, count=1, iface=port_tg_2) stream_2 = env.tg[1].set_stream(packet_2, count=1, iface=port_tg_2) streams = [stream_1, stream_2] self.suite_logger.debug("Start the capture and send the test traffic") # Start capture # Configure ports for capture (get all TG ports sniff_ports = list(active_ports[('tg1', 'sw1')].values()) env.tg[1].start_sniff(sniff_ports, sniffing_time=10) # Send generated streams env.tg[1].start_streams(streams) # Stop capture data = env.tg[1].stop_sniff(sniff_ports) # Stop traffic env.tg[1].stop_streams(streams) # Print captured data helpers.print_sniffed_data_brief(data) self.suite_logger.debug("Verify traffic is processed according to the FDB records") # Get packets from the captured data # Verify first packet is sent only to second port params_1 = [{"layer": "Ethernet", "field": 'dst', "value": '00:00:00:11:11:11'}, {"layer": "Ethernet", "field": 'src', "value": '00:00:00:02:02:02'}] assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[1], params=params_1, sniff_data=data, tg=env.tg[1])) == 1, \ "Packet is not received" assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[2], params=params_1, sniff_data=data, tg=env.tg[1])) == 0, \ "Packet is received" assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[3], params=params_1, sniff_data=data, tg=env.tg[1])) == 0, \ "Packet is received" # Verify second packet is flooded params_1 = [{"layer": "Ethernet", "field": 'dst', "value": '00:00:00:03:03:03'}, {"layer": "Ethernet", "field": 'src', "value": '00:00:00:04:04:04'}] assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[1], params=params_1, sniff_data=data, tg=env.tg[1])) == 1, \ "Packet is not received" assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[2], params=params_1, sniff_data=data, tg=env.tg[1])) == 1, \ "Packet is not received" assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[3], params=params_1, sniff_data=data, tg=env.tg[1])) == 1, \ "Packet is not received"
def test_lacp_frames(self, env): """ @brief Verify that correct LACP frames are transmitted from the configured dynamic LAG @steps -# Add each pair of device ports to separate LAGs -# Wait time until LAG transit to defaulted state -# Sniff for LACP frames on each LAG port -# Verify that device transmits properly formed LACP DUs @endsteps """ slow_protocols_mac = "01:80:c2:00:00:02" ports = env.get_ports([ ['tg1', 'sw1', 4], ]) # Disable all ports and enabling only necessary ones: helpers.set_all_ports_admin_disabled(env.switch) helpers.set_ports_admin_enabled(env.switch, ports) # Disable STP env.switch[1].ui.configure_spanning_tree(enable='Disabled') dut_mac = env.switch[1].ui.get_table_bridge_info(param="macAddress") sysprio = env.switch[1].ui.get_table_link_aggregation()[0]["priority"] max_delay = env.switch[1].ui.get_table_link_aggregation( )[0]["collectorMaxDelay"] lacp_ethertype = 0x8809 # Configure LAGs lag_config = { ports[("sw1", "tg1")][1]: { 'key': 0, 'portprio': 4096 }, ports[("sw1", "tg1")][2]: { 'key': 0, 'portprio': 4096 }, ports[("sw1", "tg1")][3]: { 'key': 1, 'portprio': 8192 }, ports[("sw1", "tg1")][4]: { 'key': 1, 'portprio': 8192 } } env.switch[1].ui.create_lag(lag=3800, key=0, lag_type='Dynamic', hash_mode='None') env.switch[1].ui.create_lag_ports( ports=[ports[("sw1", "tg1")][1], ports[("sw1", "tg1")][2]], lag=3800, priority=4096, lag_mode='Active', key=0, timeout='Short') env.switch[1].ui.create_lag(lag=3801, key=1, lag_type='Dynamic', hash_mode='None') env.switch[1].ui.create_lag_ports( ports=[ports[("sw1", "tg1")][3], ports[("sw1", "tg1")][4]], lag=3801, priority=8192, lag_mode='Active', key=1, timeout='Short') self.suite_logger.debug("Wait time to transit to defaulted state") time.sleep(5) sniff_tg_ports = list(ports[("tg1", "sw1")].values()) env.tg[1].start_sniff(sniff_tg_ports, sniffing_time=30, dst_filter=slow_protocols_mac) self.suite_logger.debug("Get Actor and Partner operStates.") states = defaultdict(dict) states[ports[("sw1", "tg1")][1]]['actor'] = [ x for x in env.switch[1].ui.get_table_lags_local_ports(lag=3800) if x['portId'] == ports[("sw1", "tg1")][1] ][0]['actorOperPortState'] states[ports[("sw1", "tg1")][1]]['partner'] = [ x for x in env.switch[1].ui.get_table_lags_remote_ports(lag=3800) if x['portId'] == ports[("sw1", "tg1")][1] ][0]['partnerOperPortState'] states[ports[("sw1", "tg1")][2]]['actor'] = [ x for x in env.switch[1].ui.get_table_lags_local_ports(lag=3800) if x['portId'] == ports[("sw1", "tg1")][2] ][0]['actorOperPortState'] states[ports[("sw1", "tg1")][2]]['partner'] = [ x for x in env.switch[1].ui.get_table_lags_remote_ports(lag=3800) if x['portId'] == ports[("sw1", "tg1")][2] ][0]['partnerOperPortState'] states[ports[("sw1", "tg1")][3]]['actor'] = [ x for x in env.switch[1].ui.get_table_lags_local_ports(lag=3801) if x['portId'] == ports[("sw1", "tg1")][3] ][0]['actorOperPortState'] states[ports[("sw1", "tg1")][3]]['partner'] = [ x for x in env.switch[1].ui.get_table_lags_remote_ports(lag=3801) if x['portId'] == ports[("sw1", "tg1")][3] ][0]['partnerOperPortState'] states[ports[("sw1", "tg1")][4]]['actor'] = [ x for x in env.switch[1].ui.get_table_lags_local_ports(lag=3801) if x['portId'] == ports[("sw1", "tg1")][4] ][0]['actorOperPortState'] states[ports[("sw1", "tg1")][4]]['partner'] = [ x for x in env.switch[1].ui.get_table_lags_remote_ports(lag=3801) if x['portId'] == ports[("sw1", "tg1")][4] ][0]['partnerOperPortState'] data = env.tg[1].stop_sniff(sniff_tg_ports) helpers.print_sniffed_data_brief(data) self.suite_logger.debug( "Verify that correct LACP frames are sent from each LAG port.") for index in range(1, 5): tg_port = ports[("tg1", "sw1")][index] sw_port = ports[("sw1", "tg1")][index] try: assert data[ tg_port], "No LACP frames sniffed on %s port".format( tg_port) except KeyError: pytest.fail("No LACP frame sniffed on %s port" % tg_port) for lacp_frame in data[tg_port]: prt_state = [ int(bit_val) for bit_val in states[sw_port]["partner"] ] partner_tlv = { "type": 2, "length": 20, "sysprio": 32768, "sys": "00:00:00:00:00:00", "key": 0, "portprio": 32768, "port": 1, "expired": prt_state[0], "defaulted": prt_state[1], "distribute": prt_state[2], "collect": prt_state[3], "synch": prt_state[4], "aggregate": prt_state[5], "timeout": prt_state[6], "activity": prt_state[7], "reserved": "\x00" * 3 } act_state = [ int(bit_val) for bit_val in states[sw_port]["actor"] ] expected_layers = { "Ethernet": { "src": dut_mac, "type": lacp_ethertype }, "LACP": { "version": 1, "subtype": 1 }, "LACPActorInfoTlv": { "type": 1, "length": 20, "sysprio": sysprio, "sys": dut_mac, "key": lag_config[sw_port]['key'], "portprio": lag_config[sw_port]["portprio"], "port": sw_port, "expired": act_state[0], "defaulted": act_state[1], "distribute": act_state[2], "collect": act_state[3], "synch": act_state[4], "aggregate": act_state[5], "timeout": act_state[6], "activity": act_state[7], "reserved": "\x00" * 3 }, "LACPPartnerInfoTlv": partner_tlv, "LACPCollectorInfoTlv": { "type": 3, "length": 16, "maxdelay": max_delay, "reserved": "\x00" * 12 }, "LACPTerminatorTlv": { "type": 0, "length": 0 }, "LACPReserved": { "reserved": "\x00" * 50 } } failures = [] for layer in expected_layers: for field, expected_value in expected_layers[layer].items( ): pack_value = env.tg[1].get_packet_field( lacp_frame, layer, field) try: if isinstance(pack_value, str): assert pack_value.lower() == expected_value.lower(), \ "Incorrect {} field {} value transmitted in LACP frame: {}".format(layer[4:], field, pack_value) else: assert pack_value == expected_value, "Incorrect {} field {} value transmitted in LACP frame: {}".format( layer[4:], field, pack_value) except AssertionError as err: failures.append("%s" % err) if failures: pytest.fail("\n".join(failures))
def test_static_route_one_ports_two_vlans(self, env): """ @brief Verify static route behaviour upon one port with two VLANs. @steps -# Configure Vlans 12 and 34 on port 1. -# Set pvid 12 for port 1. -# Create Route Interface 20.0.12.1/24 on Vlan 12. -# Create Route Interface 20.0.34.1/24 on Vlan 34. -# Create Static Route 10.10.10.0/24 with nexthop 20.0.34.5. -# Verify ARP request 'who has 20.0.34.5' received. -# Send ARP reply. -# Send IP packet with IP.dst 10.10.10.101 to the port 1. -# Verify IP packet is routed to the port 1. @endsteps """ ports = env.get_ports([['tg1', 'sw1', 1], ]) port_1 = ports[('sw1', 'tg1')][1] # Disabling all ports and enabling only necessary ones: helpers.set_all_ports_admin_disabled(env.switch, wait_status=True) helpers.set_ports_admin_enabled(env.switch, ports, wait_status=True) # Disable STP env.switch[1].ui.configure_spanning_tree(enable='Disabled') # Define active ports for sniffing. sniff_ports = [ports[('tg1', 'sw1')][1], ] # Enable Routing. env.switch[1].ui.configure_routing(routing='Enabled', ospf=None) # Create test VLAN 10. env.switch[1].ui.create_vlans(vlans=[12, 34]) # Delete port 1 from default VLAN. env.switch[1].ui.delete_vlan_ports(ports=[port_1], vlans=[1]) # Add port 1 to created test VLANs. env.switch[1].ui.create_vlan_ports(ports=[port_1], vlans=[12, 34], tagged='Tagged') # Set proper pvid for port 1 env.switch[1].ui.modify_ports(ports=[port_1], pvid=12) # Add route interfaces. env.switch[1].ui.create_route_interface(12, '20.0.12.1/24', ip_type='InterVlan', bandwidth=1000, mtu=1500, status='Enabled', vrf=0, mode='ip') env.switch[1].ui.create_route_interface(34, '20.0.34.1/24', ip_type='InterVlan', bandwidth=1000, mtu=1500, status='Enabled', vrf=0, mode='ip') # Start sniffer env.tg[1].start_sniff(sniff_ports, sniffing_time=10) # Add Static route. env.switch[1].ui.create_static_route(ip='10.10.10.0/24', nexthop='20.0.34.5', network='20.0.34.1/24', distance=-1, mode='ip') # Get sniffer data data = env.tg[1].stop_sniff(sniff_ports) helpers.print_sniffed_data_brief(data) # Verify who-has "20.0.34.5" ARP requests received. params_1 = [{"layer": "Ethernet", "field": 'dst', "value": 'ff:ff:ff:ff:ff:ff'}, {"layer": "ARP", "field": 'pdst', "value": '20.0.34.5'}] assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[0], params=params_1, sniff_data=data, tg=env.tg[1])) >= 1, \ "Packet is not received" # Get routers MAC. route_mac = env.switch[1].ui.get_table_route_interface()[0]['mac'] # Send ARP reply to port 2. arp_reply = ({"Ethernet": {"src": "00:00:14:00:22:05", "dst": route_mac.lower(), "type": 0x8100}}, {"Dot1Q": {"vlan": 34}}, {"ARP": {"op": 2, "sha": "00:00:14:00:22:05", "tha": route_mac, "tpa": "20.0.34.1", "spa": "20.0.34.5"}}, ) stream_id = env.tg[1].set_stream(arp_reply, count=1, iface=ports[('tg1', 'sw1')][1]) env.tg[1].send_stream(stream_id) time.sleep(2) # Verify ARP entry has been added arp_table = env.switch[1].ui.get_table_arp(mode='arp') assert self.is_arp_added(arps=arp_table, mac='00:00:14:00:22:05', ip='20.0.34.5'), 'ARP entry was not added' # Start sniffer env.tg[1].start_sniff(sniff_ports, sniffing_time=10) # Send to switch port 1 untagged IP packet with destination IP 10.10.10.101. packet_definition = ({"Ethernet": {"src": "00:00:20:00:10:65", "dst": route_mac, "type": 0x0800}}, {"IP": {"src": "20.0.12.101", "dst": "10.10.10.101", "p": 17}}, {"UDP": {"dport": 23, "sport": 23}}) stream_id = env.tg[1].set_stream(packet_definition, count=1, iface=ports[('tg1', 'sw1')][1]) env.tg[1].send_stream(stream_id) # Stop sniffer data = env.tg[1].stop_sniff(sniff_ports) helpers.print_sniffed_data_brief(data) # Verify that TG port 1 receive IP packet with destination 10.10.10.101 params_2 = [{"layer": "Ethernet", "field": 'dst', "value": '00:00:14:00:22:05'}, {"layer": "Ethernet", "field": 'src', "value": route_mac.lower()}, {"layer": "IP", "field": 'src', "value": '20.0.12.101'}, {"layer": "IP", "field": 'dst', "value": '10.10.10.101'}, {"layer": "Dot1Q", "field": 'vlan', "value": 34}] assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[0], params=params_2, sniff_data=data, tg=env.tg[1])) == 1, \ "Packet is not received"
def test_multicast_traffic(self, env): """ @brief Verify that multicast traffic is forwarded according to the L2Multicast table. @steps -# Create Vlan 2. -# Add ports 1 and 2 into the created Vlan as Tagged. -# Create Multicast record with MAC '01:88:88:88:88:01' in Vlan 1 for port 2. -# Create Multicast record with MAC '01:88:88:88:88:02' in Vlan 2 for port 2. -# Send packet with Ethernet.dst '01:88:88:88:88:01' to the port 1 -# Verify packet is forwarded to the port 2 -# Send packet with Ethernet.dst '01:88:88:88:88:01' to the port 3 -# Verify packet is forwarded to the port 2 -# Send packet with Ethernet.dst '01:88:88:88:88:02' and Vlan 2 to the port 3 -# Verify packet is forwarded to the port 2 -# Send packet with Ethernet.dst '01:88:88:88:88:02' and Vlan 2 to the port 4 -# Verify packet is forwarded to the port 2 @endsteps """ # Set active ports ports = env.get_ports([ ['tg1', 'sw1', 4], ]) # Disable all ports and enabling only necessary ones: helpers.set_all_ports_admin_disabled(env.switch) helpers.set_ports_admin_enabled(env.switch, ports) self.suite_logger.debug("Disable STP.") env.switch[1].ui.configure_spanning_tree(enable='Disabled') # Add Vlans: env.switch[1].ui.create_vlans(vlans=[2]) # Add ports to vlans env.switch[1].ui.create_vlan_ports( ports=[ports[('sw1', 'tg1')][1], ports[('sw1', 'tg1')][2]], vlans=[2], tagged='Tagged') # Add multicast records env.switch[1].ui.create_multicast(port=ports[('sw1', 'tg1')][2], vlans=[1], macs=['01:88:88:88:88:01']) env.switch[1].ui.create_multicast(port=ports[('sw1', 'tg1')][2], vlans=[2], macs=['01:88:88:88:88:02']) # Configure multicast streams packet_1 = ({ 'Ethernet': { 'src': '00:11:11:11:11:11', 'dst': '01:88:88:88:88:01' } }, { 'IP': {} }) packet_2 = ({ 'Ethernet': { 'src': '00:11:11:11:11:11', 'dst': '01:88:88:88:88:02', 'type': 0x8100 } }, { 'Dot1Q': { 'vlan': 2 } }, { 'IP': {} }) stream_1 = env.tg[1].set_stream(packet_1, count=1, iface=ports[('tg1', 'sw1')][1]) stream_2 = env.tg[1].set_stream(packet_2, count=1, iface=ports[('tg1', 'sw1')][1]) stream_3 = env.tg[1].set_stream(packet_1, count=1, iface=ports[('tg1', 'sw1')][3]) stream_4 = env.tg[1].set_stream(packet_2, count=1, iface=ports[('tg1', 'sw1')][4]) sniff_ports = list(ports[('tg1', 'sw1')].values()) # Send stream 1 env.tg[1].start_sniff(sniff_ports, sniffing_time=5) env.tg[1].send_stream(stream_1) data = env.tg[1].stop_sniff(sniff_ports) # Print sniffed data helpers.print_sniffed_data_brief(data) # Verify that packet_1 is forwarded to the port 2 params = ({ "layer": 'Ethernet', "field": 'dst', "value": '01:88:88:88:88:01' }, ) assert len(helpers.get_packet_from_the_port(ports[('tg1', 'sw1')][2], params, data, env.tg[1])) == 1, \ "Multicast packet is not forwarded on port 2" assert len(helpers.get_packet_from_the_port(ports[('tg1', 'sw1')][3], params, data, env.tg[1])) == 0, \ "Multicast packet is forwarded on port 3" assert len(helpers.get_packet_from_the_port(ports[('tg1', 'sw1')][4], params, data, env.tg[1])) == 0, \ "Multicast packet is forwarded on port 4" # Send stream 2 env.tg[1].start_sniff(sniff_ports, sniffing_time=5) env.tg[1].send_stream(stream_2) data = env.tg[1].stop_sniff(sniff_ports) # Print sniffed data helpers.print_sniffed_data_brief(data) # Verify that packet_2 is forwarded to the port 2 params = ({ "layer": 'Ethernet', "field": 'dst', "value": '01:88:88:88:88:02' }, ) assert len(helpers.get_packet_from_the_port(ports[('tg1', 'sw1')][2], params, data, env.tg[1])) == 1, \ "Multicast packet is not forwarded on port 2" assert len(helpers.get_packet_from_the_port(ports[('tg1', 'sw1')][3], params, data, env.tg[1])) == 0, \ "Multicast packet is forwarded on port 3" assert len(helpers.get_packet_from_the_port(ports[('tg1', 'sw1')][4], params, data, env.tg[1])) == 0, \ "Multicast packet is forwarded on port 4" # Send stream 3 env.tg[1].start_sniff(sniff_ports, sniffing_time=5) env.tg[1].send_stream(stream_3) data = env.tg[1].stop_sniff(sniff_ports) # Print sniffed data helpers.print_sniffed_data_brief(data) # Verify that packet_3 is forwarded to the port 2 params = ({ "layer": 'Ethernet', "field": 'dst', "value": '01:88:88:88:88:01' }, ) assert len(helpers.get_packet_from_the_port(ports[('tg1', 'sw1')][2], params, data, env.tg[1])) == 1, \ "Multicast packet is not forwarded on port 2" assert len(helpers.get_packet_from_the_port(ports[('tg1', 'sw1')][1], params, data, env.tg[1])) == 0, \ "Multicast packet is forwarded on port 1" assert len(helpers.get_packet_from_the_port(ports[('tg1', 'sw1')][4], params, data, env.tg[1])) == 0, \ "Multicast packet is forwarded on port 4" # Send stream 4 env.tg[1].start_sniff(sniff_ports, sniffing_time=5) env.tg[1].send_stream(stream_4) data = env.tg[1].stop_sniff(sniff_ports) # Print sniffed data helpers.print_sniffed_data_brief(data) # Verify that packet_4 is forwarded to the port 2 params = ({ "layer": 'Ethernet', "field": 'dst', "value": '01:88:88:88:88:02' }, ) assert len(helpers.get_packet_from_the_port(ports[('tg1', 'sw1')][2], params, data, env.tg[1])) == 1, \ "Multicast packet is not forwarded on port 2" assert len(helpers.get_packet_from_the_port(ports[('tg1', 'sw1')][3], params, data, env.tg[1])) == 0, \ "Multicast packet is forwarded on port 3" assert len(helpers.get_packet_from_the_port(ports[('tg1', 'sw1')][1], params, data, env.tg[1])) == 0, \ "Multicast packet is forwarded on port 1"
def test_dynamic_arp_traffic(self, env): """ @brief Verify that traffic is processed according to the learned Dynamic ARP. @steps -# Perform device preconfiguration. -# Send IP traffic. -# Verify ARP request has been sent. -# Send ARP reply. -# Send IP packets, related to the ARP record, to the first port. -# Verify IP packet is routed. @endsteps """ # Perform device preconfiguration: add vlan and route interface # Get active ports: use two ports for test case ports = env.get_ports([['tg1', 'sw1', 2], ]) # Disable all ports and enabling only necessary ones: helpers.set_all_ports_admin_disabled(env.switch) helpers.set_ports_admin_enabled(env.switch, ports) self.suite_logger.debug("Disable STP.") env.switch[1].ui.configure_spanning_tree(enable='Disabled') self.suite_logger.debug("Perform test preconfiguration") env.switch[1].ui.create_vlans(vlans=[10, 20]) env.switch[1].ui.create_vlan_ports(ports=[ports[('sw1', 'tg1')][1], ], vlans=[10], tagged='Untagged') env.switch[1].ui.create_vlan_ports(ports=[ports[('sw1', 'tg1')][2], ], vlans=[20], tagged='Untagged') env.switch[1].ui.modify_ports(ports=[ports[('sw1', 'tg1')][1], ], pvid=10) env.switch[1].ui.modify_ports(ports=[ports[('sw1', 'tg1')][2], ], pvid=20) env.switch[1].ui.configure_routing(routing='Enabled', ospf=None) env.switch[1].ui.create_route_interface(10, '10.10.10.1/24', ip_type='InterVlan', bandwidth=1000, mtu=1500, status='Enabled', vrf=0, mode='ip') env.switch[1].ui.create_route_interface(20, '20.20.20.1/24', ip_type='InterVlan', bandwidth=1000, mtu=1500, status='Enabled', vrf=0, mode='ip') # Generate test traffic route_mac = env.switch[1].ui.get_table_route_interface()[0]['mac'] packet_1 = ({"Ethernet": {"dst": route_mac, "src": "00:00:0a:0a:0a:0a", "type": 0x8100}}, {"Dot1Q": {"vlan": 10}}, {"IP": {"dst": '20.20.20.20', "src": '10.10.10.10'}}, {"TCP": {}}) # Send packets to the first port stream = env.tg[1].set_stream(packet_1, count=1, iface=ports[('tg1', 'sw1')][1]) self.suite_logger.debug("Start the capture and send the test traffic") # Start capture env.tg[1].start_sniff([ports[('tg1', 'sw1')][2]], sniffing_time=10) # Send generated streams env.tg[1].send_stream(stream) # Stop capture data = env.tg[1].stop_sniff([ports[('tg1', 'sw1')][2]]) # Print captured data helpers.print_sniffed_data_brief(data) self.suite_logger.debug("Verify ARP request has been sent") # Get packets from the captured data params_1 = [{"layer": "Ethernet", "field": 'dst', "value": 'ff:ff:ff:ff:ff:ff'}, {"layer": "Ethernet", "field": 'src', "value": route_mac.lower()}, {"layer": "ARP", "field": 'op', "value": 1}, {"layer": "ARP", "field": 'tpa', "value": '20.20.20.20'}, {"layer": "ARP", "field": 'spa', "value": '20.20.20.1'}] assert len(helpers.get_packet_from_the_port(sniff_port=ports[('tg1', 'sw1')][2], params=params_1, sniff_data=data, tg=env.tg[1])) >= 1, \ "Packet is not received" # Send ARP reply arp_reply = ({"Ethernet": {"dst": route_mac, "src": "00:00:14:14:14:14", "type": 0x8100}}, {"Dot1Q": {"vlan": 20}}, {"ARP": {"op": 2, "sha": "00:00:14:14:14:14", "tha": route_mac, "spa": "20.20.20.20", "tpa": "20.20.20.1"}}) arp_stream = env.tg[1].set_stream(arp_reply, count=1, iface=ports[('tg1', 'sw1')][2]) env.tg[1].send_stream(arp_stream) # Verify ARP entry has been added arp_table = env.switch[1].ui.get_table_arp(mode='arp') assert self.is_arp_added(arps=arp_table, mac='00:00:14:14:14:14', ip='20.20.20.20'), 'ARP entry was not added' self.suite_logger.debug("Start the capture and send the test traffic") # Start capture env.tg[1].start_sniff([ports[('tg1', 'sw1')][2]], sniffing_time=10) # Send generated streams env.tg[1].send_stream(stream) # Stop capture data = env.tg[1].stop_sniff([ports[('tg1', 'sw1')][2]]) # Print captured data helpers.print_sniffed_data_brief(data) self.suite_logger.debug("Verify traffic is processed according to the ARP records") # Get packets from the captured data params_1 = [{"layer": "Ethernet", "field": 'dst', "value": '00:00:14:14:14:14'}, {"layer": "Ethernet", "field": 'src', "value": route_mac.lower()}, {"layer": "IP", "field": 'dst', "value": '20.20.20.20'}, {"layer": "IP", "field": 'src', "value": '10.10.10.10'}] assert len(helpers.get_packet_from_the_port(sniff_port=ports[('tg1', 'sw1')][2], params=params_1, sniff_data=data, tg=env.tg[1])) == 1, \ "Packet is not received"
def test_lag_traffic(self, env): """ @brief Verify that port can be added to(removed from) static LAG @steps -# Create static LAG. -# Add two ports into LAG -# Send traffic to the first LAG member. -# Verify traffic is forwarded only from non-LAG members. @endsteps """ # Get active ports: use four ports for test case active_ports = env.get_ports([['tg1', 'sw1', 3], ]) device_ports = list(active_ports[('sw1', 'tg1')].values()) sniff_ports = list(active_ports[('tg1', 'sw1')].values()) # Disable all ports and enabling only necessary ones: helpers.set_all_ports_admin_disabled(env.switch) # Disable STP globally in order to avoid traffic loop env.switch[1].ui.configure_spanning_tree(enable="Disabled") helpers.set_ports_admin_enabled(env.switch, active_ports) # Create static LAG entry env.switch[1].ui.create_lag(lag=3800, key=0, lag_type='Static', hash_mode='None') # Add port into the LAG env.switch[1].ui.create_lag_ports(ports=device_ports[:2], lag=3800, key=0) env.switch[1].ui.wait_for_port_value_to_change( ports=[3800] + device_ports[:2], port_parameter='operationalStatus', value='Up') # Generate test traffic packet = ({"Ethernet": {"dst": "00:00:11:11:11:11", "src": "00:00:02:02:02:02"}}, {"IP": {}}, {"TCP": {}}) # Send packets to the first port stream = env.tg[1].set_stream(packet, count=1, iface=sniff_ports[0]) self.suite_logger.debug("Start the capture and send the test traffic") # Start capture env.tg[1].start_sniff(sniff_ports, sniffing_time=5) # Send generated streams env.tg[1].send_stream(stream) # Stop capture data = env.tg[1].stop_sniff(sniff_ports) # Print captured data helpers.print_sniffed_data_brief(data) # Get packets from the captured data # Verify first packet is sent only to second port params = [{"layer": "Ethernet", "field": 'dst', "value": '00:00:11:11:11:11'}, {"layer": "Ethernet", "field": 'src', "value": '00:00:02:02:02:02'}] #Traffic should be forwarded from non-LAG members assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[2], params=params, sniff_data=data, tg=env.tg[1])) == 1, \ "Packet is not received" # Traffic should not be forwarded from LAG members assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[1], params=params, sniff_data=data, tg=env.tg[1])) == 0, \ "Packet is received"
def test_qinq_vlan_stacking(self, env): """ @brief Verify that packet sent without double-tag from one Vlan to another is received on the correct port with double-tag (Vlan Stacking) @steps -# Configure Vlan 10 on port 1. -# Configure Vlan 100 on ports 1 and 2. -# Configure port 1 as CustomerStacked. -# Configure port 2 as ProviderStacked. -# Configure Vlan Stacking for port 1, provider vlan 100. -# Send packet with vlan 10 to the port 1. -# Verify that packet is double tagged on port 2 @endsteps """ destination_mac = "01:00:5E:00:01:05" source_mac = "00:00:00:00:08:22" vlan_id_customer = 10 vlan_id_provider = 100 vlan_priority_customer = 5 vlan_priority_provider = 6 ports = env.get_ports([['tg1', 'sw1', 2], ]) sniff_ports = list(ports[('tg1', 'sw1')].values()) # Disable all ports and enabling only necessary ones helpers.set_all_ports_admin_disabled(env.switch) helpers.set_ports_admin_enabled(env.switch, ports) port_id_customer = ports[('sw1', 'tg1')][1] port_id_provider = ports[('sw1', 'tg1')][2] # Disable STP env.switch[1].ui.configure_spanning_tree(enable='Disabled') # Generate customer and provider vlans env.switch[1].ui.create_vlans(vlans=[vlan_id_customer, vlan_id_provider]) # Add port to customer vlan env.switch[1].ui.create_vlan_ports(ports=[port_id_customer], vlans=[vlan_id_customer], tagged='Tagged') # Add port to provider vlan env.switch[1].ui.create_vlan_ports(ports=[port_id_provider], vlans=[vlan_id_provider], tagged='Tagged') # Add customer port to provider vlan env.switch[1].ui.create_vlan_ports(ports=[port_id_customer], vlans=[vlan_id_provider], tagged='Untagged') # Add entries about customer and provider to ports table env.switch[1].ui.configure_qinq_ports([port_id_customer], mode='CustomerStacked') env.switch[1].ui.configure_qinq_ports([port_id_customer], tpid=33024) env.switch[1].ui.configure_qinq_ports([port_id_provider], mode='ProviderStacked') env.switch[1].ui.configure_qinq_ports([port_id_provider], tpid=37120) # Set options for vlan stacking env.switch[1].ui.configure_qinq_vlan_stacking([port_id_customer], vlan_id_provider, vlan_priority_provider) # Define packet without double tag packet_definition = ({"Ethernet": {"dst": destination_mac, "src": source_mac, "type": 0x8100}}, {"Dot1Q": {"vlan": vlan_id_customer, "type": 0x0800, "prio": vlan_priority_customer}}, {"IP": {}}) #Wait some time to add all rows to tables time.sleep(1) # Start sniffer env.tg[1].start_sniff(sniff_ports, sniffing_time=10) # Send one packet to the test port stream_id = env.tg[1].set_stream(packet_definition, count=1, iface=ports[('tg1', 'sw1')][1]) env.tg[1].send_stream(stream_id) data = env.tg[1].stop_sniff(sniff_ports) helpers.print_sniffed_data_brief(data) # Verify that packet is sending without double-tag from one Vlan # to another it will be received in correct port with double-tag assert sniff_ports[1] in list(data.keys()), "No packet on expected port" params = [{"layer": "Ethernet", "field": 'src', "value": source_mac.lower()}] packet = helpers.get_packet_from_the_port(sniff_port=sniff_ports[1], params=params, sniff_data=data, tg=env.tg[1])[0] assert env.tg[1].check_packet_field(packet=packet, layer="Ethernet", field="type", value=37120), \ "Field value isn't equal to expected" assert env.tg[1].check_packet_field(packet=packet, layer="Dot1Q", field="vlan", value=vlan_id_provider), \ "Vlan field value isn't equal to expected" assert env.tg[1].check_packet_field(packet=packet, layer="Dot1Q", field="prio", value=vlan_priority_provider), \ "Prio field value isn't equal to expected" layers = env.tg[1].packet_dictionary(packet) dot1q_counter = len([x for x in layers if "Dot1Q" in x]) assert dot1q_counter == 2
def test_qinq_vlan_mapping(self, env): """ @brief Verify that customer unmapped packet is received on correct port if provider mapped packet from one Vlan to another is send (Using Vlan Mapping) @steps -# Configure Vlans 200 and 300 on ports 1 and 2. -# Configure port 1 as CustomerMapped. -# Configure port 2 as ProviderMapped. -# Configure Vlan Mapping for port 1, customer vlan 20, provider vlan 200. -# Configure Vlan Mapping for port 1, customer vlan 30, provider vlan 300. -# Send packet with vlan 200 to the port 1. -# Send packet with vlan 300 to the port 1. -# Verify that packets are received on port 2 with correct customer Vlan IDs. @endsteps """ destination_mac = "00:80:C2:04:00:00" source_mac = "00:00:00:00:02:22" destination_mac1 = "00:80:C2:02:00:00" source_mac1 = "00:00:00:00:00:42" vlan_id_customer1 = 20 vlan_id_customer2 = 30 vlan_id_provider1 = 200 vlan_id_provider2 = 300 tp_id_2 = 33024 vlan_priority_customer = 2 vlan_priority_provider = 4 ports = env.get_ports([['tg1', 'sw1', 2], ]) sniff_ports = list(ports[('tg1', 'sw1')].values()) # Disable all ports and enable only necessary ones helpers.set_all_ports_admin_disabled(env.switch) helpers.set_ports_admin_enabled(env.switch, ports) port_id_customer = ports[('sw1', 'tg1')][1] port_id_provider = ports[('sw1', 'tg1')][2] # Disable STP env.switch[1].ui.configure_spanning_tree(enable='Disabled') # Generate two vlans env.switch[1].ui.create_vlans(vlans=[vlan_id_provider1, vlan_id_provider2]) # Add second port to provider vlans env.switch[1].ui.create_vlan_ports(ports=[port_id_provider], vlans=[vlan_id_provider1, vlan_id_provider2], tagged='Tagged') # Add customer port to provider vlans env.switch[1].ui.create_vlan_ports(ports=[port_id_customer], vlans=[vlan_id_provider1, vlan_id_provider2], tagged='Tagged') # Add entries about customer and provider in port table env.switch[1].ui.configure_qinq_ports([port_id_provider], mode='ProviderMapped') env.switch[1].ui.configure_qinq_ports([port_id_provider], tpid=37120) env.switch[1].ui.configure_qinq_ports([port_id_customer], mode='CustomerMapped') env.switch[1].ui.configure_qinq_ports([port_id_customer], tpid=33024) # Set options for vlan mapping env.switch[1].ui.configure_qinq_vlan_mapping([port_id_customer], vlan_id_customer1, vlan_priority_customer, vlan_id_provider1, vlan_priority_provider) env.switch[1].ui.configure_qinq_vlan_mapping([port_id_customer], vlan_id_customer2, vlan_priority_customer, vlan_id_provider2, vlan_priority_provider) # Define packets packet_definition = ({"Ethernet": {"dst": destination_mac, "src": source_mac, "type": 0x9100}}, {"Dot1Q": {"vlan": vlan_id_provider1, "type": 0x0800, "prio": vlan_priority_provider}}, {"IP": {}}) packet_definition1 = ({"Ethernet": {"dst": destination_mac1, "src": source_mac1, "type": 0x9100}}, {"Dot1Q": {"vlan": vlan_id_provider2, "type": 0x0800, "prio": vlan_priority_provider}}, {"IP": {}}) # Wait some time to add all rows to tables time.sleep(1) # Start sniffer env.tg[1].start_sniff(sniff_ports, sniffing_time=10) # Send one packet to the test port. stream_id = env.tg[1].set_stream(packet_definition, count=1, iface=ports[('tg1', 'sw1')][2]) stream_id_1 = env.tg[1].set_stream(packet_definition1, count=1, iface=ports[('tg1', 'sw1')][2]) env.tg[1].start_streams([stream_id, stream_id_1]) data = env.tg[1].stop_sniff(sniff_ports) env.tg[1].stop_streams([stream_id, stream_id_1]) helpers.print_sniffed_data_brief(data) # Verify that customer unmapped packet will be received # in correct port if it is send provider mapped packet assert sniff_ports[0] in list(data.keys()), "No packet on expected port" params = [{"layer": "Ethernet", "field": 'dst', "value": destination_mac.lower()}] packet = helpers.get_packet_from_the_port(sniff_port=sniff_ports[0], params=params, sniff_data=data, tg=env.tg[1])[0] assert env.tg[1].check_packet_field(packet=packet, layer="Ethernet", field="type", value=tp_id_2), "Type field value isn't equal to expected" assert env.tg[1].check_packet_field(packet=packet, layer="Dot1Q", field="vlan", value=vlan_id_customer1), "Vlan field value isn't equal to expected" assert env.tg[1].check_packet_field(packet=packet, layer="Dot1Q", field="prio", value=vlan_priority_customer), "Prio field value isn't equal to expected" assert env.tg[1].check_packet_field(packet=packet, layer="Dot1Q", field="type", value=2048), "Type field value isn't equal to expected" params = [{"layer": "Ethernet", "field": 'dst', "value": destination_mac1.lower()}] packet = helpers.get_packet_from_the_port(sniff_port=sniff_ports[0], params=params, sniff_data=data, tg=env.tg[1])[0] assert env.tg[1].check_packet_field(packet=packet, layer="Ethernet", field="type", value=tp_id_2), "Type field value isn't equal to expected" assert env.tg[1].check_packet_field(packet=packet, layer="Dot1Q", field="vlan", value=vlan_id_customer2), "Vlan field value isn't equal to expected" assert env.tg[1].check_packet_field(packet=packet, layer="Dot1Q", field="prio", value=vlan_priority_customer), "Prio field value isn't equal to expected" assert env.tg[1].check_packet_field(packet=packet, layer="Dot1Q", field="type", value=2048), "Type field value isn't equal to expected"