def test_config_wifi():
"""
Test paradrop.lib.config.wifi
"""
from paradrop.core.config import wifi
update = MockUpdate()
update.old = None
update.new = MockChute()
# Chute has no net information, we should pass silently.
assert wifi.getOSWirelessConfig(update) is None
interfaces = fake_interface_list()
update.new.setCache('networkInterfaces', interfaces)
wifi.getOSWirelessConfig(update)
# Verify the new cache entry
result = update.new.getCache('osWirelessConfig')
assert len(result) == 1
# Need to make a writable location for our config files.
settings.UCI_CONFIG_DIR = tempfile.mkdtemp()
settings.UCI_BACKUP_DIR = tempfile.mkdtemp()
wifi.setOSWirelessConfig(update)
# Clean up our config dir
pdos.remove(settings.UCI_CONFIG_DIR)
pdos.remove(settings.UCI_BACKUP_DIR)
def test_configservice():
"""
Test paradrop.core.config.configservice
"""
from paradrop.core.config import configservice
# This one should raise an exception
update = MockUpdate(name="BadChute")
assert_raises(Exception, configservice.reloadAll, update)
def test_configservice():
"""
Test paradrop.core.config.configservice
"""
from paradrop.core.config import configservice
# This one should succeed
update = MockUpdate(name="GoodChute")
assert configservice.reloadAll(update) is None
def test_revert_config():
"""
Test the revertConfig function
"""
from paradrop.core.config import osconfig
# Need to make a writable location for our config files.
settings.UCI_CONFIG_DIR = tempfile.mkdtemp()
settings.UCI_BACKUP_DIR = tempfile.mkdtemp()
update = MockUpdate()
update.old = None
update.new = MockChute()
osconfig.revertConfig(update, "network")
# Clean up our config dir
pdos.remove(settings.UCI_CONFIG_DIR)
pdos.remove(settings.UCI_BACKUP_DIR)
def test_config_dhcp():
"""
Test paradrop.lib.config.dhcp
"""
from paradrop.core.config import dhcp
update = MockUpdate()
update.old = None
update.new = MockChute()
# Should do nothing before we set "networkInterfaces".
dhcp.getVirtDHCPSettings(update)
interfaces = fake_interface_list()
update.new.setCache("externalSystemDir", "/tmp")
update.new.setCache("networkInterfaces", interfaces)
settings.UCI_CONFIG_DIR = tempfile.mkdtemp()
settings.UCI_BACKUP_DIR = tempfile.mkdtemp()
# Test code path with caching enabled
dhcp.DNSMASQ_CACHE_ENABLED = True
dhcp.getVirtDHCPSettings(update)
dhcp.setVirtDHCPSettings(update)
# Test code path with caching disabled
dhcp.DNSMASQ_CACHE_ENABLED = False
dhcp.getVirtDHCPSettings(update)
dhcp.setVirtDHCPSettings(update)
pdos.remove(settings.UCI_CONFIG_DIR)
pdos.remove(settings.UCI_BACKUP_DIR)
# Test with missing "lease" field.
interfaces.append({'name': 'broken', 'dhcp': {'start': 100, 'limit': 100}})
assert_raises(Exception, dhcp.getVirtDHCPSettings, update)
def test_state():
"""
Test plan generation for state module
"""
from paradrop.core.plan import state
from paradrop.core.chute.chute import Chute
from paradrop.base import settings
# Set this to exercise debug mode code
settings.DEBUG_MODE = True
update = MockUpdate()
# generatePlans returns:
# True on failure
# None on success
# Stop with no old chute should fail
update.old = None
update.new = Chute(name="test")
update.updateType = "stop"
assert state.generatePlans(update) is True
# Install with no old chute should succeed
update.updateType = "install"
update.new.state = Chute.STATE_RUNNING
assert state.generatePlans(update) is None
# Entering invalid state should fail
update.new.state = Chute.STATE_INVALID
assert state.generatePlans(update) is True
# Start with old chute already running should fail
update.old = Chute(name="test")
update.old.state = Chute.STATE_RUNNING
update.updateType = "start"
assert state.generatePlans(update) is True
# But if the old chute was stopped, then start should succeed
update.new.state = "running"
update.old.state = Chute.STATE_STOPPED
assert state.generatePlans(update) is None
# Should be fine
update.updateType = "restart"
assert state.generatePlans(update) is None
# Create should fail when old chute exists
update.updateType = "create"
assert state.generatePlans(update) is True
# Delete and set to stopped is fine
update.new.state = Chute.STATE_STOPPED
update.updateType = "delete"
assert state.generatePlans(update) is None
# Stopping an already stopped chute should fail
update.updateType = "stop"
update.old.state = Chute.STATE_STOPPED
assert state.generatePlans(update) is True
# Stopping a running chute is fine
update.old.state = Chute.STATE_RUNNING
assert state.generatePlans(update) is None
def test_get_network_config():
"""
Test generating network configuration for a chute update.
"""
from paradrop.core.config import network
from paradrop.core.config.reservations import DeviceReservations
# Test normal case where key is defined and encryption is implied.
iface = dict()
cfg = {'key': 'password'}
network.getWifiKeySettings(cfg, iface)
assert iface['key'] == "password"
# Test normal case where encryption is set to "none".
iface = dict()
cfg = {'encryption': 'none'}
network.getWifiKeySettings(cfg, iface)
assert iface['encryption'] == "none"
# Test error case where encryption is defined but no key is present.
iface = dict()
cfg = {'encryption': 'psk2'}
assert_raises(Exception, network.getWifiKeySettings, cfg, iface)
update = MockUpdate()
update.old = None
update.new = MockChute()
# Should do nothing on a chute with no "networkInterfaces" cache key.
network.reclaimNetworkResources(update.new)
# Chute has no net information, we should pass silently.
assert network.getNetworkConfig(update) is None
update.new.net = {
'mywifi': {
'type': 'wifi',
'intfName': 'wlan0',
'encryption': 'psk2',
'key': 'password'
}
}
devices = {
'wifi': [{
'name': 'wlan0',
'mac': '00:11:22:33:44:55',
'phy': 'phy0'
}]
}
update.new.setCache("networkDevices", devices)
update.new.setCache("deviceReservations", {"wlan0": DeviceReservations()})
update.new.setCache("subnetReservations", set())
update.new.setCache("interfaceReservations", set())
# Missing 'ssid' field should raise exception.
assert_raises(Exception, network.getNetworkConfig, update)
update.new.net['mywifi']['ssid'] = "Paradrop"
# Need to make a writable location for our config files.
settings.UCI_CONFIG_DIR = tempfile.mkdtemp()
settings.UCI_BACKUP_DIR = tempfile.mkdtemp()
# Try the normal sequence of steps for installing a new chute.
network.getNetworkConfig(update)
network.getOSNetworkConfig(update)
network.setOSNetworkConfig(update)
network.abortNetworkConfig(update)
# Set up state so that old chute matches new chute.
update.old = MockChute()
update.old.net = update.new.net.copy()
ifaces = list(update.new.getCache("networkInterfaces"))
update.old.setCache("networkInterfaces", ifaces)
# Now try sequence of steps that would occur for a restart.
network.reclaimNetworkResources(update.old)
network.getNetworkConfig(update)
network.getOSNetworkConfig(update)
network.setOSNetworkConfig(update)
# Try asking for a new chute without any interfaces.
update.new.net = dict()
# This would be a restart where we remove an interface that was in old but
# not in new.
network.getNetworkConfig(update)
network.getOSNetworkConfig(update)
network.setOSNetworkConfig(update)
network.abortNetworkConfig(update)
# Try a network interface with missing 'type' field.
update.new.net = {
'mywifi': {
'intfName': 'wlan0',
}
}
assert_raises(Exception, network.getNetworkConfig, update)
# Try asking for something funny.
update.new.net = {
'mywifi': {
'type': 'fail',
'intfName': 'wlan0',
}
}
assert_raises(Exception, network.getNetworkConfig, update)
# Clean up our config dir
pdos.remove(settings.UCI_CONFIG_DIR)
pdos.remove(settings.UCI_BACKUP_DIR)
def test_config_firewall():
"""
Test paradrop.lib.config.firewall
"""
from paradrop.core.config import firewall
# Test findMatchingInterface function
interfaces = fake_interface_list()
assert firewall.findMatchingInterface("*wifi", interfaces) is not None
assert firewall.findMatchingInterface("??lan", interfaces) is not None
assert firewall.findMatchingInterface("missing", interfaces) is None
update = MockUpdate()
update.old = None
update.new = MockChute()
# No interfaces in the cache---should return without a problem
firewall.getOSFirewallRules(update)
firewall.getDeveloperFirewallRules(update)
update.new.setCache("networkInterfaces", interfaces)
firewall.getOSFirewallRules(update)
result = update.new.getCache("osFirewallRules")
assert len(result) >= 4
update.new.firewall = fake_rules_list()
firewall.getDeveloperFirewallRules(update)
result = update.new.getCache('developerFirewallRules')
assert len(result) == 1
# Need to make a writable location for our config files.
settings.UCI_CONFIG_DIR = tempfile.mkdtemp()
settings.UCI_BACKUP_DIR = tempfile.mkdtemp()
firewall.setOSFirewallRules(update)
pdos.remove(settings.UCI_CONFIG_DIR)
pdos.remove(settings.UCI_BACKUP_DIR)
# Try a bad rule that has both from/to outside the chute.
update.new.firewall = fake_rules_list()
update.new.firewall.append({
'name': 'bad',
'type': 'redirect',
'from': '@host.lan',
'to': '@host.lan'
})
assert_raises(Exception, firewall.getDeveloperFirewallRules, update)
# Try a bad rule that does not match an interface.
update.new.firewall = fake_rules_list()
update.new.firewall.append({
'name': 'bad',
'type': 'redirect',
'from': '@host.lan',
'to': 'missing'
})
assert_raises(Exception, firewall.getDeveloperFirewallRules, update)
# Try an SNAT rule, which is not currently supported.
update.new.firewall = fake_rules_list()
update.new.firewall.append({
'name': 'bad',
'type': 'redirect',
'from': 'missing',
'to': '@host.lan'
})
assert_raises(Exception, firewall.getDeveloperFirewallRules, update)
# Try something else that we do not recognize.
update.new.firewall = fake_rules_list()
update.new.firewall.append({
'name': 'bad',
'type': 'redirect',
'from': 'missing',
'to': 'missing'
})
assert_raises(Exception, firewall.getDeveloperFirewallRules, update)
def test_config_devices():
"""
Test paradrop.core.config.devices
"""
from paradrop.core.config import devices
# Test the isVirtual function
assert devices.isVirtual("eth0") is False
assert devices.isVirtual("v0000.eth0")
assert devices.isVirtual("vethabcdef")
assert devices.isWAN("eth0")
assert devices.isWAN("wlan0") is False
update = MockUpdate()
update.old = None
update.new = MockChute()
hostConfig = {
'wan': {
'interface': 'eth0'
},
'lan': {
'interfaces': ['eth1'],
'ipaddr': '192.168.1.1',
'netmask': '255.255.255.0',
'dhcp': {
'start': 100,
'limit': 100,
'leasetime': '12h'
}
},
'wifi': [{
'macaddr': '00:11:22:33:44:55',
'channel': 1
}]
}
update.new.setCache('hostConfig', hostConfig)
settings.UCI_CONFIG_DIR = tempfile.mkdtemp()
settings.UCI_BACKUP_DIR = tempfile.mkdtemp()
# Calling before getSystemDevices should do nothing.
devices.setSystemDevices(update)
# Test normal flow---our mock functions will simulate the existence of
# various network interfaces.
devices.getSystemDevices(update)
devices.setSystemDevices(update)
cachedDevices = update.new.getCache("networkDevices")
assert len(cachedDevices) == 3
# Make sure it continues to work with missing devices.
cachedDevices['lan'] = []
devices.setSystemDevices(update)
cachedDevices['wifi'] = []
devices.setSystemDevices(update)
cachedDevices['wan'] = []
devices.setSystemDevices(update)
pdos.remove(settings.UCI_CONFIG_DIR)
pdos.remove(settings.UCI_BACKUP_DIR)