fix: remove WIP test logic

src/net/parser/fluereflows.rs

@@ -293,150 +293,3 @@ fn ipv6_packet(time: u64, packet: Ipv6Packet) -> Result<(usize, [u8; 9], FluereR
         ),
     ))
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use pcap::Packet;
-    use pnet::packet::ethernet::{EtherTypes, MutableEthernetPacket};
-    use pnet::packet::ipv4::{Ipv4Packet, MutableIpv4Packet, Ipv4Flags};
-    use pnet::packet::ipv6::MutableIpv6Packet;
-    use pnet::packet::arp::ArpOperation;
-    use pnet::packet::{MutablePacket, Packet as PnetPacket};
-    use std::net::{Ipv4Addr, Ipv6Addr};
-    use chrono::format::Numeric::Timestamp;
-
-    // Helper function to create a basic IPv4 packet
-    fn create_ipv4_packet(src: Ipv4Addr, dst: Ipv4Addr, payload: &[u8]) -> Vec<u8> {
-        let mut buf = vec![0u8; 20 + payload.len()];
-        let mut pkt = MutableIpv4Packet::new(&mut buf).unwrap();
-        pkt.set_version(4);
-        pkt.set_header_length(5);
-        pkt.set_total_length(20 + payload.len() as u16);
-        pkt.set_source(src);
-        pkt.set_destination(dst);
-        pkt.set_payload(payload);
-        buf
-    }
-
-    // Helper function to create a basic IPv6 packet
-    fn create_ipv6_packet(src: Ipv6Addr, dst: Ipv6Addr, payload: &[u8]) -> Vec<u8> {
-        let mut buf = vec![0u8; 40 + payload.len()];
-        let mut pkt = MutableIpv6Packet::new(&mut buf).unwrap();
-        pkt.set_version(6);
-        pkt.set_payload_length(payload.len() as u16);
-        pkt.set_next_header(pnet::packet::ip::IpNextHeaderProtocol(59)); // No Next Header
-        pkt.set_hop_limit(64);
-        pkt.set_source(src);
-        pkt.set_destination(dst);
-        pkt.set_payload(payload);
-        buf
-    }
-
-    #[test]
-    fn test_empty_packet() {
-        let packet = Packet {
-            data: &[],
-            header: &pcap::PacketHeader {
-                ts: Timestamp { tv_sec: 0, tv_usec: 0 },
-                caplen: 0,
-                len: 0,
-            },
-        };
-        assert!(matches!(parse_fluereflow(packet), Err(NetError::EmptyPacket)));
-    }
-
-    #[test]
-    fn test_unsupported_ethertype() {
-        let payload = [0u8; 10]; // Dummy payload
-        let eth_buf = create_ethernet_packet(EtherTypes::Loopback, &payload);
-        let packet = Packet {
-            data: &eth_buf,
-            header: &pcap::PacketHeader {
-                ts: Timestamp { tv_sec: 0, tv_usec: 0 },
-                caplen: eth_buf.len() as u32,
-                len: eth_buf.len() as u32,
-            },
-        };
-        assert!(matches!(parse_fluereflow(packet), Err(NetError::UnknownEtherType(_))));
-    }
-
-    #[test]
-    fn test_ipv4_fluere_record() {
-        let src_ip = Ipv4Addr::new(192, 168, 1, 1);
-        let dst_ip = Ipv4Addr::new(192, 168, 1, 2);
-        let payload = [1, 2, 3, 4]; // Example payload
-        let ipv4_packet = create_ipv4_packet(src_ip, dst_ip, &payload);
-        let eth_packet = create_ethernet_packet(EtherTypes::Ipv4, &ipv4_packet);
-
-        let packet = Packet {
-            data: &eth_packet,
-            header: &pcap::PacketHeader {
-                ts: Timestamp { tv_sec: 1_561_011_200, tv_usec: 0 },
-                caplen: eth_packet.len() as u32,
-                len: eth_packet.len() as u32,
-            },
-        };
-
-        if let Ok((_, _, fluere_record)) = parse_fluereflow(packet) {
-            assert_eq!(fluere_record.source, std::net::IpAddr::V4(src_ip));
-            assert_eq!(fluere_record.destination, std::net::IpAddr::V4(dst_ip));
-            // Add more assertions here based on the expected FluereRecord fields
-        } else {
-            panic!("Failed to parse IPv4 packet");
-        }
-    }
-
-    #[test]
-    fn test_ipv6_fluere_record() {
-        let src_ip = Ipv6Addr::new(0x2001, 0x0db8, 0x85a3, 0, 0, 0, 0, 0x1);
-        let dst_ip = Ipv6Addr::new(0x2001, 0x0db8, 0x85a3, 0, 0, 0, 0, 0x2);
-        let payload = [1, 2, 3, 4]; // Example payload
-        let ipv6_packet = create_ipv6_packet(src_ip, dst_ip, &payload);
-        let eth_packet = create_ethernet_packet(EtherTypes::Ipv6, &ipv6_packet);
-
-        let packet = Packet {
-            data: &eth_packet,
-            header: &pcap::PacketHeader {
-                ts: Timestamp { tv_sec: 1_561_011_200, tv_usec: 0 },
-                caplen: eth_packet.len() as u32,
-                len: eth_packet.len() as u32,
-            },
-        };
-
-        if let Ok((_, _, fluere_record)) = parse_fluereflow(packet) {
-            assert_eq!(fluere_record.source, std::net::IpAddr::V6(src_ip));
-            assert_eq!(fluere_record.destination, std::net::IpAddr::V6(dst_ip));
-            // Add more assertions here based on the expected FluereRecord fields
-        } else {
-            panic!("Failed to parse IPv6 packet");
-        }
-    }
-
-    #[test]
-    fn test_arp_fluere_record() {
-        let src_ip = Ipv4Addr::new(192, 168, 1, 1);
-        let dst_ip = Ipv4Addr::new(192, 168, 1, 2);
-        let arp_packet = vec![0u8; 28]; // Example ARP packet
-        let eth_packet = create_ethernet_packet(EtherTypes::Arp, &arp_packet);
-
-        let packet = Packet {
-            data: &eth_packet,
-            header: &pcap::PacketHeader {
-                ts: Timestamp { tv_sec: 1_561_011_200, tv_usec: 0 },
-                caplen: eth_packet.len() as u32,
-                len: eth_packet.len() as u32,
-            },
-        };
-
-        if let Ok((_, _, fluere_record)) = parse_fluereflow(packet) {
-            assert_eq!(fluere_record.source, std::net::IpAddr::V4(src_ip));
-            assert_eq!(fluere_record.destination, std::net::IpAddr::V4(dst_ip));
-            // Add more assertions here based on the expected FluereRecord fields
-        } else {
-            panic!("Failed to parse ARP packet");
-        }
-    }
-
-    // Implement similar tests for VXLAN decapsulation.
-}