refactored some future naming to be more consistent, added new data objects to pass into coreemu api to help make scripting easier, set sessions to master by default now

This commit is contained in:
Blake J. Harnden 2018-04-24 16:24:54 -07:00
parent 1404ca19c5
commit 3ea885e2eb
9 changed files with 550 additions and 449 deletions

View file

@ -3,9 +3,9 @@ import time
import pytest
from core.data import NodeData, LinkData
from core.enumerations import NodeTypes, EventTypes
from core.future.coreemu import CoreEmu, FutureIpv4Prefix
from core.future.coreemu import CoreEmu
from core.future.futuredata import IpPrefixes, NodeOptions, LinkOptions
from core.misc import utils
@ -13,7 +13,7 @@ from core.misc import utils
def future_session():
# use coreemu and create a session
coreemu = CoreEmu()
session = coreemu.create_session(master=True)
session = coreemu.create_session()
session.set_state(EventTypes.CONFIGURATION_STATE.value)
# return created session
@ -41,16 +41,15 @@ class TestFuture:
@pytest.mark.parametrize("model", MODELS)
def test_node_add(self, future_session, model):
# given
node_data = NodeData(node_type=NodeTypes.DEFAULT.value, model=model)
node_options = NodeOptions(_type=NodeTypes.DEFAULT, model=model)
# when
node_id = future_session.node_add(node_data)
node = future_session.add_node(node_options)
# give time for node services to boot
time.sleep(1)
# then
node = future_session.get_object(node_id)
assert node
assert os.path.exists(node.nodedir)
assert node.alive()
@ -60,187 +59,116 @@ class TestFuture:
def test_node_update(self, future_session):
# given
node_data = NodeData(node_type=NodeTypes.DEFAULT.value)
node_id = future_session.node_add(node_data)
node_options = NodeOptions(_type=NodeTypes.DEFAULT)
node = future_session.add_node(node_options)
position_value = 100
update_data = NodeData(
id=node_id,
x_position=position_value,
y_position=position_value
)
update_options = NodeOptions(_id=node.objid)
update_options.set_position(x=position_value, y=position_value)
# when
future_session.node_update(update_data)
future_session.update_node(update_options)
# then
node = future_session.get_object(node_id)
assert node.position.x == position_value
assert node.position.y == position_value
def test_node_delete(self, future_session):
# given
node_data = NodeData(node_type=NodeTypes.DEFAULT.value)
node_id = future_session.node_add(node_data)
node_options = NodeOptions(_type=NodeTypes.DEFAULT)
node = future_session.add_node(node_options)
# when
future_session.node_delete(node_id)
future_session.delete_node(node.objid)
# then
with pytest.raises(KeyError):
future_session.get_object(node_id)
future_session.get_object(node.objid)
@pytest.mark.parametrize("net_type", NET_TYPES)
def test_net(self, future_session, net_type):
# given
node_data = NodeData(node_type=net_type.value)
node_options = NodeOptions(_type=net_type)
# when
node_id = future_session.node_add(node_data)
node = future_session.add_node(node_options)
# then
node = future_session.get_object(node_id)
assert node
assert node.up
assert utils.check_cmd(["brctl", "show", node.brname])
def test_ptp(self, future_session):
# given
prefix = FutureIpv4Prefix("10.83.0.0/16")
node_data = NodeData(node_type=NodeTypes.DEFAULT.value)
node_one_id = future_session.node_add(node_data)
node_two_id = future_session.node_add(node_data)
node_one = future_session.get_object(node_one_id)
inteface_one_index = node_one.newifindex()
address_one = prefix.addr(node_one_id)
node_two = future_session.get_object(node_two_id)
inteface_two_index = node_two.newifindex()
address_two = prefix.addr(node_two_id)
link_data = LinkData(
node1_id=node_one_id,
node2_id=node_two_id,
interface1_id=inteface_one_index,
interface1_ip4=str(address_one),
interface1_ip4_mask=prefix.prefixlen,
interface2_id=inteface_two_index,
interface2_ip4=str(address_two),
interface2_ip4_mask=prefix.prefixlen,
)
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
node_options = NodeOptions(_type=NodeTypes.DEFAULT)
node_one = future_session.add_node(node_options)
node_two = future_session.add_node(node_options)
interface_one = prefixes.create_interface(node_one)
inteface_two = prefixes.create_interface(node_two)
# when
future_session.link_add(link_data)
future_session.add_link(node_one.objid, node_two.objid, interface_one, inteface_two)
# then
assert node_one.netif(inteface_one_index)
assert node_two.netif(inteface_two_index)
assert node_one.netif(interface_one.id)
assert node_two.netif(inteface_two.id)
def test_node_to_net(self, future_session):
# given
prefix = FutureIpv4Prefix("10.83.0.0/16")
node_data = NodeData(node_type=NodeTypes.DEFAULT.value)
node_one = future_session.node_add(node_data)
node_data = NodeData(node_type=NodeTypes.SWITCH.value)
node_two = future_session.node_add(node_data)
node = future_session.get_object(node_one)
inteface_index = node.newifindex()
address = prefix.addr(node_one)
link_data = LinkData(
node1_id=node_one,
node2_id=node_two,
interface1_id=inteface_index,
interface1_ip4=str(address),
interface1_ip4_mask=prefix.prefixlen,
)
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
node_options = NodeOptions(_type=NodeTypes.DEFAULT)
node_one = future_session.add_node(node_options)
node_options = NodeOptions(_type=NodeTypes.SWITCH)
node_two = future_session.add_node(node_options)
interface_one = prefixes.create_interface(node_one)
# when
future_session.link_add(link_data)
future_session.add_link(node_one.objid, node_two.objid, interface_one)
# then
node_two = future_session.get_object(node_two)
assert node_two.all_link_data(0)
assert node.netif(inteface_index)
assert node_one.netif(interface_one.id)
def test_net_to_node(self, future_session):
# given
prefix = FutureIpv4Prefix("10.83.0.0/16")
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
node_data = NodeData(node_type=NodeTypes.SWITCH.value)
node_one = future_session.node_add(node_data)
node_data = NodeData(node_type=NodeTypes.DEFAULT.value)
node_two = future_session.node_add(node_data)
node = future_session.get_object(node_two)
inteface_index = node.newifindex()
address = prefix.addr(node_two)
link_data = LinkData(
node1_id=node_one,
node2_id=node_two,
interface2_id=inteface_index,
interface2_ip4=str(address),
interface2_ip4_mask=prefix.prefixlen,
)
node_options = NodeOptions(_type=NodeTypes.SWITCH)
node_one = future_session.add_node(node_options)
node_options = NodeOptions(_type=NodeTypes.DEFAULT)
node_two = future_session.add_node(node_options)
interface_two = prefixes.create_interface(node_two)
# when
future_session.link_add(link_data)
future_session.add_link(node_one.objid, node_two.objid, interface_two=interface_two)
# then
node_one = future_session.get_object(node_one)
assert node_one.all_link_data(0)
assert node.netif(inteface_index)
assert node_two.netif(interface_two.id)
def test_net_to_net(self, future_session):
# given
node_data = NodeData(node_type=NodeTypes.SWITCH.value)
node_one = future_session.node_add(node_data)
node_data = NodeData(node_type=NodeTypes.SWITCH.value)
node_two = future_session.node_add(node_data)
link_data = LinkData(
node1_id=node_one,
node2_id=node_two,
)
node_options = NodeOptions(_type=NodeTypes.SWITCH)
node_one = future_session.add_node(node_options)
node_options = NodeOptions(_type=NodeTypes.SWITCH)
node_two = future_session.add_node(node_options)
# when
future_session.link_add(link_data)
future_session.add_link(node_one.objid, node_two.objid)
# then
node_one = future_session.get_object(node_one)
assert node_one.all_link_data(0)
def test_link_update(self, future_session):
# given
prefix = FutureIpv4Prefix("10.83.0.0/16")
node_data = NodeData(node_type=NodeTypes.DEFAULT.value)
node_one = future_session.node_add(node_data)
node_data = NodeData(node_type=NodeTypes.SWITCH.value)
node_two = future_session.node_add(node_data)
node = future_session.get_object(node_one)
inteface_index = node.newifindex()
address = prefix.addr(node_one)
link_data = LinkData(
node1_id=node_one,
node2_id=node_two,
interface1_id=inteface_index,
interface1_ip4=str(address),
interface1_ip4_mask=prefix.prefixlen,
)
future_session.link_add(link_data)
update_data = LinkData(
node1_id=node_one,
node2_id=node_two,
interface1_id=inteface_index,
delay=50,
bandwidth=5000000,
per=25,
dup=25
)
interface = node.netif(inteface_index)
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
node_options = NodeOptions(_type=NodeTypes.DEFAULT)
node_one = future_session.add_node(node_options)
node_options = NodeOptions(_type=NodeTypes.SWITCH)
node_two = future_session.add_node(node_options)
interface_one = prefixes.create_interface(node_one)
future_session.add_link(node_one.objid, node_two.objid, interface_one)
interface = node_one.netif(interface_one.id)
output = utils.check_cmd(["tc", "qdisc", "show", "dev", interface.localname])
assert "delay" not in output
assert "rate" not in output
@ -248,7 +176,13 @@ class TestFuture:
assert "duplicate" not in output
# when
future_session.link_update(update_data)
link_options = LinkOptions()
link_options.delay = 50
link_options.bandwidth = 5000000
link_options.per = 25
link_options.dup = 25
future_session.update_link(node_one.objid, node_two.objid,
interface_one_id=interface_one.id, link_options=link_options)
# then
output = utils.check_cmd(["tc", "qdisc", "show", "dev", interface.localname])
@ -259,35 +193,21 @@ class TestFuture:
def test_link_delete(self, future_session):
# given
prefix = FutureIpv4Prefix("10.83.0.0/16")
node_data = NodeData(node_type=NodeTypes.DEFAULT.value)
node_one_id = future_session.node_add(node_data)
node_two_id = future_session.node_add(node_data)
node_one = future_session.get_object(node_one_id)
inteface_one_index = node_one.newifindex()
address_one = prefix.addr(node_one_id)
node_two = future_session.get_object(node_two_id)
inteface_two_index = node_two.newifindex()
address_two = prefix.addr(node_two_id)
link_data = LinkData(
node1_id=node_one_id,
node2_id=node_two_id,
interface1_id=inteface_one_index,
interface1_ip4=str(address_one),
interface1_ip4_mask=prefix.prefixlen,
interface2_id=inteface_two_index,
interface2_ip4=str(address_two),
interface2_ip4_mask=prefix.prefixlen,
)
future_session.link_add(link_data)
assert node_one.netif(inteface_one_index)
assert node_two.netif(inteface_two_index)
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
node_options = NodeOptions(_type=NodeTypes.DEFAULT)
node_one = future_session.add_node(node_options)
node_two = future_session.add_node(node_options)
interface_one = prefixes.create_interface(node_one)
interface_two = prefixes.create_interface(node_two)
future_session.add_link(node_one.objid, node_two.objid, interface_one, interface_two)
assert node_one.netif(interface_one.id)
assert node_two.netif(interface_two.id)
assert future_session.get_node_count() == 3
# when
future_session.link_delete(link_data)
future_session.delete_link(node_one.objid, node_two.objid, interface_one.id, interface_two.id)
# then
assert not node_one.netif(inteface_one_index)
assert not node_two.netif(inteface_two_index)
assert not node_one.netif(interface_one.id)
assert not node_two.netif(interface_two.id)
assert future_session.get_node_count() == 2