def test_node_set_mac_exception(self, session: Session, mac: str): # given node = session.add_node(CoreNode) switch = session.add_node(SwitchNode) iface_data = InterfaceData() iface = node.new_iface(switch, iface_data) # when with pytest.raises(CoreError): node.set_mac(iface.node_id, mac)
def test_node_sethwaddr_exception(self, session: Session): # given node = session.add_node(CoreNode) switch = session.add_node(SwitchNode) interface_data = InterfaceData() index = node.newnetif(switch, interface_data) node.netif(index) mac = "aa:aa:aa:ff:ff:fff" # when with pytest.raises(CoreError): node.sethwaddr(index, mac)
def test_xml_ptp( self, session: Session, tmpdir: TemporaryFile, ip_prefixes: IpPrefixes ): """ Test xml client methods for a ptp network. :param session: session for test :param tmpdir: tmpdir to create data in :param ip_prefixes: generates ip addresses for nodes """ # create ptp ptp_node = session.add_node(PtpNet) # create nodes node1 = session.add_node(CoreNode) node2 = session.add_node(CoreNode) # link nodes to ptp net for node in [node1, node2]: iface_data = ip_prefixes.create_iface(node) session.add_link(node.id, ptp_node.id, iface1_data=iface_data) # instantiate session session.instantiate() # get ids for nodes node1_id = node1.id node2_id = node2.id # save xml xml_file = tmpdir.join("session.xml") file_path = xml_file.strpath session.save_xml(file_path) # verify xml file was created and can be parsed assert xml_file.isfile() assert ElementTree.parse(file_path) # stop current session, clearing data session.shutdown() # verify nodes have been removed from session with pytest.raises(CoreError): assert not session.get_node(node1_id, CoreNode) with pytest.raises(CoreError): assert not session.get_node(node2_id, CoreNode) # load saved xml session.open_xml(file_path, start=True) # verify nodes have been recreated assert session.get_node(node1_id, CoreNode) assert session.get_node(node2_id, CoreNode)
def test_add_net_to_node(self, session: Session, ip_prefixes: IpPrefixes): # given node1 = session.add_node(SwitchNode) node2 = session.add_node(CoreNode) iface2_data = ip_prefixes.create_iface(node2) # when session.add_link(node1.id, node2.id, iface2_data=iface2_data) # then assert node1.links() assert node2.get_iface(iface2_data.id)
def test_delete_net_to_net_error(self, session: Session, ip_prefixes: IpPrefixes): # given node1 = session.add_node(SwitchNode) node2 = session.add_node(SwitchNode) node3 = session.add_node(SwitchNode) session.add_link(node1.id, node2.id) assert node1.get_linked_iface(node2) # when with pytest.raises(CoreError): session.delete_link(node1.id, node3.id)
def test_net_to_node(self, session: Session, ip_prefixes: IpPrefixes): # given node_one = session.add_node(SwitchNode) node_two = session.add_node(CoreNode) interface_two = ip_prefixes.create_interface(node_two) # when session.add_link(node_one.id, node_two.id, interface_two=interface_two) # then assert node_one.all_link_data() assert node_two.netif(interface_two.id)
def test_node_set_mac(self, session: Session, mac: str, expected: str): # given node = session.add_node(CoreNode) switch = session.add_node(SwitchNode) iface_data = InterfaceData() iface = node.new_iface(switch, iface_data) # when node.set_mac(iface.node_id, mac) # then assert str(iface.mac) == expected
def test_delete_node_to_net(self, session: Session, ip_prefixes: IpPrefixes): # given node1 = session.add_node(CoreNode) node2 = session.add_node(SwitchNode) iface1_data = ip_prefixes.create_iface(node1) session.add_link(node1.id, node2.id, iface1_data) assert node1.get_iface(iface1_data.id) # when session.delete_link(node1.id, node2.id, iface1_id=iface1_data.id) # then assert iface1_data.id not in node1.ifaces
def test_delete_node_to_net_error(self, session: Session, ip_prefixes: IpPrefixes): # given node1 = session.add_node(CoreNode) node2 = session.add_node(SwitchNode) node3 = session.add_node(SwitchNode) iface1_data = ip_prefixes.create_iface(node1) iface1, _ = session.add_link(node1.id, node2.id, iface1_data) assert iface1 # when with pytest.raises(CoreError): session.delete_link(node1.id, node3.id)
def test_node_sethwaddr(self, session: Session): # given node = session.add_node(CoreNode) switch = session.add_node(SwitchNode) interface_data = InterfaceData() index = node.newnetif(switch, interface_data) interface = node.netif(index) mac = "aa:aa:aa:ff:ff:ff" # when node.sethwaddr(index, mac) # then assert interface.hwaddr == mac
def test_node_addaddr(self, session: Session): # given node = session.add_node(CoreNode) switch = session.add_node(SwitchNode) interface_data = InterfaceData() index = node.newnetif(switch, interface_data) interface = node.netif(index) addr = "192.168.0.1/24" # when node.addaddr(index, addr) # then assert interface.addrlist[0] == addr
def test_mobility(self, session: Session, ip_prefixes: IpPrefixes): """ Test basic wlan network. :param core.emulator.coreemu.EmuSession session: session for test :param ip_prefixes: generates ip addresses for nodes """ # create wlan wlan_node = session.add_node(WlanNode) session.mobility.set_model(wlan_node, BasicRangeModel) # create nodes options = NodeOptions(model="mdr") options.set_position(0, 0) node_one = session.add_node(CoreNode, options=options) node_two = session.add_node(CoreNode, options=options) # link nodes for node in [node_one, node_two]: interface = ip_prefixes.create_interface(node) session.add_link(node.id, wlan_node.id, interface_one=interface) # configure mobility script for session config = { "file": _MOBILITY_FILE, "refresh_ms": "50", "loop": "1", "autostart": "0.0", "map": "", "script_start": "", "script_pause": "", "script_stop": "", } session.mobility.set_model(wlan_node, Ns2ScriptedMobility, config) # add handler for receiving node updates event = threading.Event() def node_update(_): event.set() session.node_handlers.append(node_update) # instantiate session session.instantiate() # validate we receive a node message for updating its location assert event.wait(5)
def test_model_set_error(self, session: Session): # given wlan_node = session.add_node(WlanNode) # when / then with pytest.raises(ValueError): session.mobility.set_model(wlan_node, EmaneIeee80211abgModel)
def test_node_add_ip(self, session: Session, ip: str, expected: str, is_ip6: bool): # given node = session.add_node(CoreNode) switch = session.add_node(SwitchNode) iface_data = InterfaceData() iface = node.new_iface(switch, iface_data) # when node.add_ip(iface.node_id, ip) # then if is_ip6: assert str(iface.get_ip6()) == expected else: assert str(iface.get_ip4()) == expected
def test_models(self, session: Session, model: Type[EmaneModel], ip_prefixes: IpPrefixes): """ Test emane models within a basic network. :param core.emulator.coreemu.EmuSession session: session for test :param model: emane model to test :param ip_prefixes: generates ip addresses for nodes """ # create emane node for networking the core nodes session.set_location(47.57917, -122.13232, 2.00000, 1.0) options = NodeOptions() options.set_position(80, 50) emane_network = session.add_node(EmaneNet, options=options) session.emane.set_model(emane_network, model) # configure tdma if model == EmaneTdmaModel: session.emane.set_model_config( emane_network.id, EmaneTdmaModel.name, { "schedule": os.path.join(_DIR, "../../examples/tdma/schedule.xml") }, ) # create nodes options = NodeOptions(model="mdr") options.set_position(150, 150) node1 = session.add_node(CoreNode, options=options) options.set_position(300, 150) node2 = session.add_node(CoreNode, options=options) for i, node in enumerate([node1, node2]): node.setposition(x=150 * (i + 1), y=150) iface_data = ip_prefixes.create_iface(node) session.add_link(node.id, emane_network.id, iface1_data=iface_data) # instantiate session session.instantiate() # ping node2 from node1 and assert success status = ping(node1, node2, ip_prefixes, count=5) assert not status
def test_update_node_to_net(self, session: Session, ip_prefixes: IpPrefixes): # given node1 = session.add_node(CoreNode) node2 = session.add_node(SwitchNode) iface1_data = ip_prefixes.create_iface(node1) iface1, _ = session.add_link(node1.id, node2.id, iface1_data) assert iface1.local_options != LINK_OPTIONS # when session.update_link(node1.id, node2.id, iface1_id=iface1_data.id, options=LINK_OPTIONS) # then assert iface1.local_options == LINK_OPTIONS assert iface1.has_local_netem
def test_add_net_to_node(self, session: Session, ip_prefixes: IpPrefixes): # given node1 = session.add_node(SwitchNode) node2 = session.add_node(CoreNode) iface2_data = ip_prefixes.create_iface(node2) # when _, iface = session.add_link(node1.id, node2.id, iface2_data=iface2_data, options=LINK_OPTIONS) # then assert node1.links() assert node2.get_iface(iface2_data.id) assert iface is not None assert iface.local_options == LINK_OPTIONS assert iface.has_local_netem
def test_netif(self, session: Session, ip_prefixes: IpPrefixes): """ Test netif methods. :param session: session for test :param ip_prefixes: generates ip addresses for nodes """ # create ptp ptp_node = session.add_node(PtpNet) # create nodes node_one = session.add_node(CoreNode) node_two = session.add_node(CoreNode) # link nodes to ptp net for node in [node_one, node_two]: interface = ip_prefixes.create_interface(node) session.add_link(node.id, ptp_node.id, interface_one=interface) # instantiate session session.instantiate() # check link data gets generated assert ptp_node.all_link_data(MessageFlags.ADD) # check common nets exist between linked nodes assert node_one.commonnets(node_two) assert node_two.commonnets(node_one) # check we can retrieve netif index assert node_one.ifname(0) assert node_two.ifname(0) # check interface parameters interface = node_one.netif(0) interface.setparam("test", 1) assert interface.getparam("test") == 1 assert interface.getparams() # delete netif and test that if no longer exists node_one.delnetif(0) assert not node_one.netif(0)
def test_node_delete(self, session: Session): # given node = session.add_node(CoreNode) # when session.delete_node(node.id) # then with pytest.raises(CoreError): session.get_node(node.id, CoreNode)
def test_iface(self, session: Session, ip_prefixes: IpPrefixes): """ Test interface methods. :param session: session for test :param ip_prefixes: generates ip addresses for nodes """ # create ptp ptp_node = session.add_node(PtpNet) # create nodes node1 = session.add_node(CoreNode) node2 = session.add_node(CoreNode) # link nodes to ptp net for node in [node1, node2]: iface = ip_prefixes.create_iface(node) session.add_link(node.id, ptp_node.id, iface1_data=iface) # instantiate session session.instantiate() # check link data gets generated assert ptp_node.links(MessageFlags.ADD) # check common nets exist between linked nodes assert node1.commonnets(node2) assert node2.commonnets(node1) # check we can retrieve interface id assert 0 in node1.ifaces assert 0 in node2.ifaces # check interface parameters iface = node1.get_iface(0) iface.setparam("test", 1) assert iface.getparam("test") == 1 assert iface.getparams() # delete interface and test that if no longer exists node1.delete_iface(0) assert 0 not in node1.ifaces
def test_model_set(self, session: Session): # given wlan_node = session.add_node(WlanNode) # when session.mobility.set_model(wlan_node, BasicRangeModel) # then assert session.mobility.get_model_config(wlan_node.id, BasicRangeModel.name)
def test_node_add(self, session: Session, model: str): # given options = NodeOptions(model=model) # when node = session.add_node(CoreNode, options=options) # then assert node assert node.alive() assert node.up
def test_node_set_pos(self, session: Session): # given node = session.add_node(CoreNode) x, y = 100.0, 50.0 # when session.set_node_pos(node, x, y) # then assert node.position.x == x assert node.position.y == y
def test_get_models(self, session: Session): # given wlan_node = session.add_node(WlanNode) session.mobility.set_model(wlan_node, BasicRangeModel) # when models = session.mobility.get_models(wlan_node) # then assert models assert len(models) == 1
def test_service_validate(self, session: Session): # given ServiceManager.add_services(_SERVICES_PATH) my_service = ServiceManager.get(SERVICE_ONE) node = session.add_node(CoreNode) session.services.create_service_files(node, my_service) # when status = session.services.validate_service(node, my_service) # then assert not status
def test_node_set_geo(self, session: Session): # given node = session.add_node(CoreNode) lon, lat, alt = 0.0, 0.0, 0.0 # when session.set_node_geo(node, lon, lat, alt) # then assert node.position.lon == lon assert node.position.lat == lat assert node.position.alt == alt
def test_service_add_services(self, session: Session): # given ServiceManager.add_services(_SERVICES_PATH) node = session.add_node(CoreNode) total_service = len(node.services) # when session.services.add_services(node, node.type, [SERVICE_ONE, SERVICE_TWO]) # then assert node.services assert len(node.services) == total_service + 2
def test_update_node_to_net(self, session: Session, ip_prefixes: IpPrefixes): # given delay = 50 bandwidth = 5000000 loss = 25 dup = 25 jitter = 10 buffer = 100 node1 = session.add_node(CoreNode) node2 = session.add_node(SwitchNode) iface1_data = ip_prefixes.create_iface(node1) session.add_link(node1.id, node2.id, iface1_data) iface1 = node1.get_iface(iface1_data.id) assert iface1.getparam("delay") != delay assert iface1.getparam("bw") != bandwidth assert iface1.getparam("loss") != loss assert iface1.getparam("duplicate") != dup assert iface1.getparam("jitter") != jitter assert iface1.getparam("buffer") != buffer # when options = LinkOptions( delay=delay, bandwidth=bandwidth, loss=loss, dup=dup, jitter=jitter, buffer=buffer, ) session.update_link( node1.id, node2.id, iface1_id=iface1_data.id, options=options ) # then assert iface1.getparam("delay") == delay assert iface1.getparam("bw") == bandwidth assert iface1.getparam("loss") == loss assert iface1.getparam("duplicate") == dup assert iface1.getparam("jitter") == jitter assert iface1.getparam("buffer") == buffer
def test_two_emane_interfaces(self, session: Session): """ Test nodes running multiple emane interfaces. :param core.emulator.coreemu.EmuSession session: session for test """ # create emane node for networking the core nodes session.set_location(47.57917, -122.13232, 2.00000, 1.0) options = NodeOptions() options.set_position(80, 50) options.emane = EmaneIeee80211abgModel.name emane_net1 = session.add_node(EmaneNet, options=options) options.emane = EmaneRfPipeModel.name emane_net2 = session.add_node(EmaneNet, options=options) # create nodes options = NodeOptions(model="mdr") options.set_position(150, 150) node1 = session.add_node(CoreNode, options=options) options.set_position(300, 150) node2 = session.add_node(CoreNode, options=options) # create interfaces ip_prefix1 = IpPrefixes("10.0.0.0/24") ip_prefix2 = IpPrefixes("10.0.1.0/24") for i, node in enumerate([node1, node2]): node.setposition(x=150 * (i + 1), y=150) iface_data = ip_prefix1.create_iface(node) session.add_link(node.id, emane_net1.id, iface1_data=iface_data) iface_data = ip_prefix2.create_iface(node) session.add_link(node.id, emane_net2.id, iface1_data=iface_data) # instantiate session session.instantiate() # ping node2 from node1 on both interfaces and check success status = ping(node1, node2, ip_prefix1, count=5) assert not status status = ping(node1, node2, ip_prefix2, count=5) assert not status
def test_ptp(self, session: Session, ip_prefixes: IpPrefixes): # given node_one = session.add_node(CoreNode) node_two = session.add_node(CoreNode) interface_one = ip_prefixes.create_interface(node_one) interface_two = ip_prefixes.create_interface(node_two) # when session.add_link(node_one.id, node_two.id, interface_one, interface_two) # then assert node_one.netif(interface_one.id) assert node_two.netif(interface_two.id)