def test__saves_power_parameters(self): self.prepare_rack_rpc() mac_addresses = [ factory.make_mac_address() for _ in range(3)] architecture = make_usable_architecture(self) power_parameters = { 'power_address': factory.make_ip_address(), # XXX: URLs break. 'power_pass': factory.make_name('power_pass'), 'power_id': factory.make_name('power_id'), } node = create_node( architecture, 'virsh', power_parameters, mac_addresses) # Reload the object from the DB so that we're sure its power # parameters are being persisted. node = reload_object(node) self.assertEqual(power_parameters, node.power_parameters)
def test__changes_boot_interface_vlan_not_relayed_through_rack(self): rack_controller = factory.make_RackController() rack_fabric = factory.make_Fabric() rack_vlan = rack_fabric.get_default_vlan() rack_interface = factory.make_Interface( INTERFACE_TYPE.PHYSICAL, node=rack_controller, vlan=rack_vlan) rack_subnet = factory.make_Subnet(vlan=rack_vlan) rack_ip = factory.make_StaticIPAddress( alloc_type=IPADDRESS_TYPE.STICKY, subnet=rack_subnet, interface=rack_interface) other_vlan = factory.make_VLAN() relay_vlan = factory.make_VLAN(relay_vlan=other_vlan) remote_ip = factory.make_ip_address() node = self.make_node(vlan=relay_vlan) mac = node.get_boot_interface().mac_address get_config( rack_controller.system_id, rack_ip.ip, remote_ip, mac=mac, query_count=28) self.assertEqual( rack_vlan, reload_object(node).get_boot_interface().vlan)
def test_create_interface_creates_external(self): user = factory.make_admin() node = factory.make_Node(interface=False, node_type=NODE_TYPE.DEVICE) handler = DeviceHandler(user, {}) name = factory.make_name("eth") mac_address = factory.make_mac_address() ip_address = factory.make_ip_address() handler.create_interface({ "system_id": node.system_id, "name": name, "mac_address": mac_address, "ip_assignment": DEVICE_IP_ASSIGNMENT_TYPE.EXTERNAL, "ip_address": ip_address, }) new_interface = node.interface_set.first() self.assertIsNotNone(new_interface) auto_ip = new_interface.ip_addresses.filter( alloc_type=IPADDRESS_TYPE.USER_RESERVED) self.assertIsNotNone(auto_ip) self.assertEqual(1, len(auto_ip))
def test_can_create_forward_dns_server(self): name = factory.make_name("domain") forward_dns_servers = [factory.make_ip_address() for _ in range(0, 2)] form = DomainForm({ "name": name, "authoritative": False, "forward_dns_servers": " ".join(forward_dns_servers), }) self.assertTrue(form.is_valid(), form.errors) domain = form.save() self.assertEqual( forward_dns_servers, [ fwd_dns_srvr.ip_address for fwd_dns_srvr in domain.forward_dns_servers ], )
def test_POST_create_returns_machine_with_matching_power_parameters(self): mock_create_machine = self.patch(machines_module, "create_machine") hostname = factory.make_name("hostname") architecture = make_usable_architecture(self) power_type = "ipmi" power_parameters = { "power_address": factory.make_ip_address(), "power_user": factory.make_name("power-user"), "power_pass": factory.make_name("power-pass"), } machine = factory.make_Machine( hostname=hostname, status=NODE_STATUS.NEW, architecture="", power_type=power_type, power_parameters=power_parameters, ) # Simulate creating the MAAS IPMI user power_parameters["power_user"] = "******" power_parameters["power_pass"] = factory.make_name("power-pass") response = self.client.post( reverse("machines_handler"), { "hostname": "maas-enlistment", "architecture": architecture, "power_type": power_type, "mac_addresses": factory.make_mac_address(), "power_parameters": json.dumps(power_parameters), }, ) self.assertEqual(http.client.OK, response.status_code) machine = reload_object(machine) self.assertEqual(hostname, machine.hostname) self.assertEqual(architecture, machine.architecture) # The power form add default values, matching is based on the IP # address. self.assertDictContainsSubset(power_parameters, machine.bmc.power_parameters) self.assertThat(mock_create_machine, MockNotCalled()) self.assertEqual(machine.system_id, json_load_bytes(response.content)["system_id"])
def test_preseed_url_for_known_node_internal_domain(self): rack_url = 'http://%s' % factory.make_name('host') rack_controller = factory.make_RackController(url=rack_url) vlan = factory.make_VLAN(dhcp_on=True, primary_rack=rack_controller) subnet = factory.make_Subnet(vlan=vlan) subnet.dns_servers = [] subnet.save() local_ip = factory.pick_ip_in_Subnet(subnet) remote_ip = factory.make_ip_address() self.patch( server_address, 'resolve_hostname').return_value = {local_ip} node = self.make_node(primary_rack=rack_controller) mac = node.get_boot_interface().mac_address observed_config = get_config( rack_controller.system_id, local_ip, remote_ip, mac=mac) self.assertThat( observed_config["preseed_url"], StartsWith( 'http://%s.%s:5248' % ( get_resource_name_for_subnet(subnet), Config.objects.get_config('maas_internal_domain'))))
def test_POST_create_returns_machine_with_matching_power_parameters(self): mock_create_machine = self.patch(machines_module, "create_machine") hostname = factory.make_name("hostname") architecture = make_usable_architecture(self) power_type = 'ipmi' power_parameters = { "power_address": factory.make_ip_address(), "power_user": factory.make_name("power-user"), "power_pass": factory.make_name("power-pass"), "power_driver": 'LAN_2_0', "mac_address": '', "power_boot_type": 'auto', } machine = factory.make_Machine( hostname=hostname, status=NODE_STATUS.NEW, architecture='', power_type=power_type, power_parameters=power_parameters) # Simulate creating the MAAS IPMI user power_parameters["power_user"] = "******" power_parameters["power_pass"] = factory.make_name("power-pass") response = self.client.post( reverse('machines_handler'), { 'hostname': 'maas-enlistment', 'architecture': architecture, 'power_type': power_type, 'mac_addresses': factory.make_mac_address(), 'power_parameters': json.dumps(power_parameters), }) self.assertEqual(http.client.OK, response.status_code) machine = reload_object(machine) self.assertEqual(hostname, machine.hostname) self.assertEqual(architecture, machine.architecture) self.assertDictContainsSubset( machine.bmc.power_parameters, power_parameters) node_metadata = NodeMetadata.objects.get(node=machine, key='enlisting') self.assertEqual(node_metadata.value, 'True') self.assertThat(mock_create_machine, MockNotCalled()) self.assertEqual( machine.system_id, json_load_bytes(response.content)['system_id'])
def test__creates_staticipaddresses(self): name = factory.make_name("dnsresource") domain = factory.make_Domain() ips = [factory.make_ip_address() for _ in range(3)] request = Mock() request.user = factory.make_User() form = DNSResourceForm( { "name": name, "domain": domain.id, "ip_addresses": " ".join(ips), }, request=request) self.assertTrue(form.is_valid(), form.errors) dnsresource = form.save() self.assertEqual(name, dnsresource.name) self.assertEqual(domain.id, dnsresource.domain.id) actual_ips = dnsresource.ip_addresses.all() actual = {str(ip.ip) for ip in actual_ips} self.assertItemsEqual(set(ips), actual) actual_users = {ip.user_id for ip in actual_ips} self.assertItemsEqual({request.user.id}, actual_users)
def test_compose_preseed_for_commissioning_includes_metadata_status_url( self): rack_controller = factory.make_RackController(url='') node = factory.make_Node(interface=True, status=NODE_STATUS.COMMISSIONING) nic = node.get_boot_interface() nic.vlan.dhcp_on = True nic.vlan.primary_rack = rack_controller nic.vlan.save() region_ip = factory.make_ip_address() preseed = yaml.safe_load( compose_preseed(PRESEED_TYPE.COMMISSIONING, node, default_region_ip=region_ip)) self.assertEqual( absolute_reverse('metadata', default_region_ip=region_ip), preseed['datasource']['MAAS']['metadata_url']) self.assertEqual( absolute_reverse('metadata-status', default_region_ip=region_ip, args=[node.system_id]), preseed['reporting']['maas']['endpoint'])
def make_kwargs( self, action=None, mac=None, ip=None, timestamp=None, lease_time=None, hostname=None, subnet=None, ): if action is None: action = random.choice(["commit", "expiry", "release"]) if mac is None: mac = factory.make_mac_address() if ip is None: if subnet is not None: ip = factory.pick_ip_in_network(subnet.get_ipnetwork()) else: ip = factory.make_ip_address() if timestamp is None: timestamp = int(time.time()) if action == "commit": if lease_time is None: lease_time = random.randint(30, 1000) if hostname is None: hostname = factory.make_name("host") ip_family = "ipv4" if IPAddress(ip).version == IPADDRESS_FAMILY.IPv6: ip_family = "ipv6" return { "action": action, "mac": mac, "ip": ip, "ip_family": ip_family, "timestamp": timestamp, "lease_time": lease_time, "hostname": hostname, }
def test_get_bmc_ip_enables_dynamic(self): ip = factory.make_ip_address() mock_bmc_set = self.patch(self.ipmi, "_bmc_set") self.patch(self.ipmi, "_get_bmc_ip").side_effect = ( None, None, None, None, None, None, None, None, ip, ) self.assertEqual(ip, self.ipmi.get_bmc_ip()) self.assertThat( mock_bmc_set, MockCallsMatch( call("Lan_Conf:IP_Address_Source", "Static"), call("Lan_Conf:IP_Address_Source", "Use_DHCP"), ), )
def test_get_credentials_lan_old(self): self.ipmi.username = factory.make_name("username") self.ipmi.password = factory.make_name("password") self.patch( self.ipmi, "_get_ipmi_locate_output").return_value = "IPMI Version: 1.0" self.patch(bmc_config.platform, "machine").return_value = "x86_64" self.patch(bmc_config.os.path, "isdir").return_value = False ip = factory.make_ip_address() self.patch(self.ipmi, "get_bmc_ip").return_value = ip self.assertEqual( { "power_address": ip, "power_pass": self.ipmi.password, "power_user": self.ipmi.username, "power_driver": "LAN", "power_boot_type": "auto", "k_g": "", "cipher_suite_id": "", "privilege_level": "", }, self.ipmi.get_credentials(), )
def test_POST_simple_user_can_set_power_type_and_parameters(self): new_power_address = factory.make_ip_address() # XXX: URLs don't work. new_power_id = factory.make_name('power_id') response = self.client.post( reverse('machines_handler'), { 'architecture': make_usable_architecture(self), 'power_type': 'virsh', 'power_parameters': json.dumps( { "power_address": new_power_address, "power_id": new_power_id, }), 'mac_addresses': ['AA:BB:CC:DD:EE:FF'], }) machine = Machine.objects.get( system_id=json_load_bytes(response.content)['system_id']) self.assertEqual(http.client.OK, response.status_code) self.assertEqual('virsh', machine.power_type) self.assertEqual( { 'power_pass': '', 'power_id': new_power_id, 'power_address': new_power_address, }, machine.power_parameters)
def test_set_current_entry_asserts_for_empty_list(self): region = factory.make_RegionController() with ExpectedException(AssertionError): RDNS.objects.set_current_entry(factory.make_ip_address(), [], region)
def test_returns_list_if_space_separated_ips(self): addresses = [factory.make_ip_address() for _ in range(3)] Config.objects.set_config("upstream_dns", " ".join(addresses)) self.assertEqual(addresses, get_upstream_dns())
def test_returns_list_of_one_address_if_set(self): address = factory.make_ip_address() Config.objects.set_config("upstream_dns", address) self.assertEqual([address], get_upstream_dns())
def test__errors_when_no_event_type(self): name = factory.make_name('name') description = factory.make_name('description') self.assertRaises(NoSuchEventType, events.send_event_ip_address, factory.make_ip_address(), name, description, datetime.datetime.utcnow())
def test_accepts_comma_separated_ips(self): ips = [factory.make_ip_address() for _ in range(5)] input = ",".join(ips) self.assertEqual(" ".join(ips), SubnetListFormField().clean(input))
def test_accepts_single_ip(self): ip = factory.make_ip_address() self.assertEqual(ip, SubnetListFormField().clean(ip))
def test_accepts_space_separated_ips(self): ips = [factory.make_ip_address() for _ in range(5)] input = " ".join(ips) self.assertEqual(input, HostListFormField().clean(input))
def test_rejects_invalid_input(self): invalid = factory.make_name("invalid") input = " ".join([factory.make_ip_address(), invalid]) error = self.assertRaises(ValidationError, IPListFormField().clean, input) self.assertIn("Invalid IP address: %s" % invalid, error.message)
def test_delete_current_entry_ignores_missing_entries(self): region = factory.make_RegionController() ip = factory.make_ip_address() with TwistedLoggerFixture() as logger: RDNS.objects.delete_current_entry(ip, region) self.assertThat(logger.output, Equals(""))
def test_detected_ip(self): self.patch(self.wedge, "_detect_known_switch").return_value = "accton" self.patch(self.wedge, "get_bmc_ip").return_value = factory.make_ip_address() self.assertTrue(self.wedge.detected())
def test_upstream_dns_accepts_ip_list(self): field = get_config_field('upstream_dns') ips1 = [factory.make_ip_address() for _ in range(3)] ips2 = [factory.make_ip_address() for _ in range(3)] input = ' '.join(ips1) + ' ' + ','.join(ips2) self.assertEqual(' '.join(ips1 + ips2), field.clean(input))
def test__delete_current_entry_ignores_missing_entries(self): region = factory.make_RegionController() ip = factory.make_ip_address() RDNS.objects.delete_current_entry(ip, region) self.assertThat(self.maaslog.output, Equals(""))
def test_returns_None_when_unknown_subnet(self): self.assertIsNone( find_rack_controller(make_request(factory.make_ip_address())))
def test_get_credentials(self): self.hp_moonshot.username = "******" self.hp_moonshot.password = "******" mock_get_local_address = self.patch(self.hp_moonshot, "_get_local_address") local_address = factory.make_name("local_address") mock_get_local_address.return_value = local_address output = factory.make_string() self.mock_check_output.return_value = output.encode() mock_get_cartridge_address = self.patch(self.hp_moonshot, "_get_cartridge_address") node_address = factory.make_name("node_address") mock_get_cartridge_address.return_value = node_address mock_get_channel_number = self.patch(self.hp_moonshot, "_get_channel_number") local_chan = factory.make_name("local_chan") cartridge_chan = factory.make_name("cartridge_chan") mock_get_channel_number.side_effect = (local_chan, cartridge_chan) mock_get_bmc_ip = self.patch(self.hp_moonshot, "get_bmc_ip") ip = factory.make_ip_address() mock_get_bmc_ip.return_value = ip self.assertEqual( { "power_address": ip, "power_pass": "******", "power_user": "******", "power_hwaddress": "-B %s -T %s -b %s -t %s -m 0x20" % ( cartridge_chan, node_address, local_chan, local_address, ), }, self.hp_moonshot.get_credentials(), ) self.assertThat(mock_get_local_address, MockCalledOnce()) self.assertThat(mock_get_cartridge_address, MockCalledOnceWith(local_address)) self.assertThat( self.mock_check_output, MockCalledOnceWith( [ "ipmitool", "-b", "0", "-t", "0x20", "-m", local_address, "sdr", "list", "mcloc", "-v", ], timeout=60, ), ) self.assertThat( mock_get_channel_number, MockCallsMatch(call(local_address, output), call(node_address, output)), )