def test_add_batfish_interface_intf_ether_sub():
"""
Verify `add_batfish_interface()` is working properly for a sub interface of a physical interface
"""
config.load_config()
data = {
"Interface": "GigabitEthernet0/0/0.201",
"Active": True,
"Speed": 1000000000,
"MTU": 1500,
"Switchport_Mode": "NONE",
"Switchport": False,
"Native_VLAN": None,
"Encapsulation_VLAN": 201,
"Description": "my description",
"Channel_Group_Members": [],
"Channel_Group": None,
}
intf = NetworkImporterInterface(name=data["Interface"], device_name="dev")
intf.add_batfish_interface(pd.Series(data))
assert isinstance(intf.local, Interface)
assert intf.local.is_virtual
assert intf.local.allowed_vlans == [201]
assert not intf.local.is_lag
assert not intf.local.is_lag_member
def test_add_batfish_interface_loopback():
"""
Verify `add_batfish_interface()` is working properly for a Loopback interface
"""
config.load_config()
data = {
"Interface": "Loopback1",
"Active": True,
"Speed": None,
"MTU": 1500,
"Switchport_Mode": "NONE",
"Switchport": False,
"Native_VLAN": None,
"Encapsulation_VLAN": None,
"Description": "intf1 description",
"Channel_Group_Members": [],
"Channel_Group": None,
}
intf = NetworkImporterInterface(name=data["Interface"], device_name="dev")
intf.add_batfish_interface(pd.Series(data))
assert isinstance(intf.local, Interface)
assert intf.local.is_virtual
assert not intf.local.is_lag
assert not intf.local.is_lag_member
def test_add_batfish_interface_intf_lag_member():
"""
Verify `add_batfish_interface()` is working properly for lag member
"""
config.load_config()
data = {
"Interface": "TenGigabitEthernet2/1/3",
"Active": True,
"Speed": 10000000000,
"MTU": 1500,
"Allowed_VLANs": "10-12,40",
"Switchport_Mode": "TRUNK",
"Switchport": True,
"Native_VLAN": 1,
"Encapsulation_VLAN": None,
"Description": "my description",
"Channel_Group_Members": [],
"Channel_Group": "Port-Channel111",
}
intf = NetworkImporterInterface(name=data["Interface"], device_name="dev")
intf.add_batfish_interface(pd.Series(data))
assert isinstance(intf.local, Interface)
assert not intf.local.is_virtual
assert not intf.local.is_lag
assert intf.local.is_lag_member
assert intf.local.allowed_vlans == [10, 11, 12, 40]
def test_netbox26_properties_long_description():
config.load_config()
data = yaml.safe_load(open(f"{HERE}/{FIXTURES}/interface_loopback.json"))
rem = pynetbox.models.dcim.Interfaces(data, "http://mock", 1)
intf = Netbox26Interface()
intf.add(rem)
intf_prop = Netbox26Interface.get_properties(intf)
assert len(intf_prop["description"]) == 100
def test_netbox26_properties_interface_lag_trunk():
config.load_config()
data = yaml.safe_load(open(f"{HERE}/{FIXTURES}/interface_lag_trunk.json"))
rem = pynetbox.models.dcim.Interfaces(data, "http://mock", 1)
intf = Netbox27Interface()
intf.add(rem)
intf_prop = Netbox27Interface.get_properties(intf)
assert intf_prop["mode"] == "tagged"
def test_netbox26_properties_interface_loopback():
config.load_config()
data = yaml.safe_load(open(f"{HERE}/{FIXTURES}/interface_loopback.json"))
rem = pynetbox.models.dcim.Interfaces(data, "http://mock", 1)
intf = Netbox26Interface()
intf.add(rem)
intf_prop = Netbox26Interface.get_properties(intf)
assert intf_prop["type"] == 0
assert intf_prop["mode"] == None
assert intf_prop["enabled"] == True
def test_netbox27_add_interface_no_type():
config.load_config()
data = yaml.safe_load(open(f"{HERE}/{FIXTURES}/interface_no_type.json"))
rem = pynetbox.models.dcim.Interfaces(data, "http://mock", 1)
intf = Netbox27Interface()
intf.add(rem)
assert intf.is_lag == False
assert intf.is_virtual == False
assert intf.is_lag_member == None
assert intf.switchport_mode == "ACCESS"
assert intf.access_vlan == 300
def test_netbox26_add_interface_loopback():
config.load_config()
data = yaml.safe_load(open(f"{HERE}/{FIXTURES}/interface_loopback.json"))
rem = pynetbox.models.dcim.Interfaces(data, "http://mock", 1)
intf = Netbox26Interface()
intf.add(rem)
assert intf.is_lag == False
assert intf.is_virtual == True
assert intf.is_lag_member == None
assert intf.switchport_mode == "NONE"
assert intf.access_vlan == None
assert intf.allowed_vlans == None
def test_config_nev_verify_ssl():
os.environ["NETBOX_ADDRESS"] = "http://fromenv"
os.environ["NETBOX_TOKEN"] = "fromenv" # nosec
os.environ["NETWORK_DEVICE_LOGIN"] = "******"
os.environ["NETWORK_DEVICE_PWD"] = "fromenv" # nosec
os.environ["NETBOX_VERIFY_SSL"] = "false"
os.environ["NETBOX_CACERT"] = "fromenv"
config.load_config(f"{HERE}/fixtures/config_env_var.toml")
assert config.netbox["address"] == "http://fromenv"
assert config.netbox["token"] == "fromenv"
assert config.netbox["cacert"] == "fromenv"
assert config.netbox["verify_ssl"] == False
assert config.network["login"] == "fromenv"
assert config.network["password"] == "fromenv" # nosec
def test_config_env_var_no_file():
os.environ["NETBOX_ADDRESS"] = "http://envvar"
os.environ["NETBOX_TOKEN"] = "mytoken" # nosec
os.environ["NETWORK_DEVICE_LOGIN"] = "******"
os.environ["NETWORK_DEVICE_PWD"] = "pypwd" # nosec
os.environ["NETBOX_VERIFY_SSL"] = "1"
os.environ["NETBOX_CACERT"] = "mycert"
config.load_config()
assert config.netbox["address"] == "http://envvar"
assert config.netbox["token"] == "mytoken"
assert config.netbox["cacert"] == "mycert"
assert config.netbox["verify_ssl"] == True
assert config.network["login"] == "mylogin"
assert config.network["password"] == "pypwd"
def main(config_file, limit, diff, apply, check, debug, update_configs):
config.load_config(config_file)
perf.init()
# ------------------------------------------------------------
# Setup Logging
# ------------------------------------------------------------
logging.getLogger("pybatfish").setLevel(logging.ERROR)
logging.getLogger("netaddr").setLevel(logging.ERROR)
if config.logs["level"] != "debug":
logging.getLogger("paramiko.transport").setLevel(logging.CRITICAL)
logging.getLogger("nornir.core.task").setLevel(logging.CRITICAL)
logging.basicConfig(
stream=sys.stdout, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
)
if config.logs["level"] == "debug":
logger.setLevel(logging.DEBUG)
elif config.logs["level"] == "warning":
logger.setLevel(logging.WARNING)
else:
logger.setLevel(logging.INFO)
# TODO add code to set config.main["hostvars_directory"] based on options.output
# TODO add code to set config.main["configs_directory"] based on options.configs
ni = NetworkImporter()
if update_configs:
ni.build_inventory(limit=limit)
ni.update_configurations()
ni.init(limit=limit)
ni.import_devices_from_configs()
ni.import_devices_from_cmds()
ni.import_cabling()
ni.check_data_consistency()
# ------------------------------------------------------------------------------------
# Update Remote if apply is enabled
# ------------------------------------------------------------------------------------
if apply:
ni.update_remote()
elif check:
ni.diff_local_remote()
if config.logs["performance_log"]:
perf.TIME_TRACKER.set_nbr_devices(len(ni.devs.inventory.hosts.keys()))
perf.TIME_TRACKER.print_all()
if config.netbox["status_update"] and apply:
ni.update_devices_status()
if diff:
ni.print_diffs()
logger.info(
f"Execution finished, processed {perf.TIME_TRACKER.nbr_devices} device(s) "
)
if debug:
pdb.set_trace()
def test_config_no_config():
config.load_config()
assert config.netbox["address"] == "http://localhost"
