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)