def test_read(self): node = factory.make_Node() cache_sets = [ factory.make_CacheSet(node=node) for _ in range(3) ] uri = get_bcache_cache_sets_uri(node) response = self.client.get(uri) self.assertEqual( http.client.OK, response.status_code, response.content) expected_ids = [ cache_set.id for cache_set in cache_sets ] expected_names = [ cache_set.name for cache_set in cache_sets ] result_ids = [ cache_set["id"] for cache_set in json_load_bytes(response.content) ] result_names = [ cache_set["name"] for cache_set in json_load_bytes(response.content) ] self.assertItemsEqual(expected_ids, result_ids) self.assertItemsEqual(expected_names, result_names)
def test_read_404_when_node_mismatch(self): node = factory.make_Node(owner=self.user) cache_set = factory.make_CacheSet(node=node) uri = get_bcache_cache_set_uri(cache_set, node=factory.make_Node()) response = self.client.get(uri) self.assertEqual(http.client.NOT_FOUND, response.status_code, response.content)
def test_bcache_creation_with_names(self): node = factory.make_Node() backing_size = 10 * 1000**4 cache_set = factory.make_CacheSet(node=node) backing_device = factory.make_PhysicalBlockDevice(node=node, size=backing_size) backing_partition_table = factory.make_PartitionTable( block_device=backing_device) backing_partition = backing_partition_table.add_partition() uuid = str(uuid4()) form = CreateBcacheForm( node=node, data={ "name": "bcache0", "uuid": uuid, "cache_set": cache_set.name, "backing_partition": backing_partition.name, "cache_mode": CACHE_MODE_TYPE.WRITEBACK, }, ) self.assertTrue(form.is_valid(), form.errors) bcache = form.save() self.assertEqual("bcache0", bcache.name) self.assertEqual(uuid, bcache.uuid) self.assertEqual(cache_set, bcache.cache_set) self.assertEqual( backing_partition.get_effective_filesystem(), bcache.filesystems.get(fstype=FILESYSTEM_TYPE.BCACHE_BACKING), ) self.assertEqual(FILESYSTEM_GROUP_TYPE.BCACHE, bcache.group_type)
def test_update_403_when_not_admin(self): node = factory.make_Node(status=NODE_STATUS.READY) cache_set = factory.make_CacheSet(node=node) uri = get_bcache_cache_set_uri(cache_set) response = self.client.put(uri, {}) self.assertEqual(http.client.FORBIDDEN, response.status_code, response.content)
def test_get_parents_handles_cache_set(self): # Regression test for lp1519397 node = factory.make_Node(with_boot_disk=False) volume_group = factory.make_VolumeGroup(node=node) name = factory.make_name() vguuid = "%s" % uuid4() size = random.randint(MIN_BLOCK_DEVICE_SIZE, volume_group.get_size()) logical_volume = volume_group.create_logical_volume(name=name, uuid=vguuid, size=size) logical_volume = reload_object(logical_volume) sdb = factory.make_PhysicalBlockDevice(node=node) factory.make_CacheSet(block_device=sdb, node=node) self.assertItemsEqual( [fs.block_device_id for fs in volume_group.filesystems.all()], [parent.id for parent in logical_volume.get_parents()])
def test_read(self): node = factory.make_Node() cache_block_device = factory.make_PhysicalBlockDevice(node=node) cache_set = factory.make_CacheSet(block_device=cache_block_device) uri = get_bcache_cache_set_uri(cache_set) response = self.client.get(uri) self.assertEqual( http.client.OK, response.status_code, response.content ) parsed_cache_set = json_load_bytes(response.content) self.assertThat( parsed_cache_set, ContainsDict( { "id": Equals(cache_set.id), "name": Equals(cache_set.name), "resource_uri": Equals( get_bcache_cache_set_uri(cache_set) ), "cache_device": ContainsDict( {"id": Equals(cache_block_device.id)} ), "system_id": Equals(cache_set.get_node().system_id), } ), )
def test_get_numa_nodes_indexes_many_devices(self): node = factory.make_Node() numa_nodes = [ node.default_numanode, factory.make_NUMANode(node=node), factory.make_NUMANode(node=node), ] block_devices = [ factory.make_PhysicalBlockDevice(numa_node=numa_node) for numa_node in numa_nodes ] filesystems = [ factory.make_Filesystem( fstype=FILESYSTEM_TYPE.LVM_PV, block_device=block_device ) for block_device in block_devices ] fsgroup = factory.make_FilesystemGroup( node=node, filesystems=filesystems, group_type=FILESYSTEM_GROUP_TYPE.LVM_VG, ) virtual_block_device = factory.make_VirtualBlockDevice( filesystem_group=fsgroup ) cache_set = factory.make_CacheSet(block_device=virtual_block_device) self.assertEqual(cache_set.get_numa_node_indexes(), [0, 1, 2])
def test_choices_are_being_populated_correctly(self): node = factory.make_Node(with_boot_disk=False) # Make 10 block devices. bds = [factory.make_PhysicalBlockDevice(node=node) for _ in range(10)] # Partition the last 5 devices with a single partition. partitions = [ factory.make_PartitionTable(block_device=bd).add_partition() for bd in bds[5:] ] partition_choices = [p.id for p in partitions ] + [p.name for p in partitions] # Get the chocies of the non-partitioned devices. block_device_choices = [ bd.id for bd in bds if bd.get_partitiontable() is None ] + [bd.name for bd in bds if bd.get_partitiontable() is None] cache_set = factory.make_CacheSet(block_device=bds[1]) form = UpdateCacheSetForm(cache_set=cache_set, data={}) # Should allow all devices and partitions, including the one currently # in use on the cache set. self.assertItemsEqual( block_device_choices, [k for (k, v) in form.fields["cache_device"].choices], ) self.assertItemsEqual( partition_choices, [k for (k, v) in form.fields["cache_partition"].choices], )
def test_bcache_update_with_boot_disk(self): node = factory.make_Node(with_boot_disk=False) boot_disk = factory.make_PhysicalBlockDevice(node=node) cache_set = factory.make_CacheSet(node=node) filesystems = [ factory.make_Filesystem( partition=factory.make_PartitionTable( block_device=factory.make_PhysicalBlockDevice( node=node)).add_partition(), fstype=FILESYSTEM_TYPE.BCACHE_BACKING, ) ] bcache = factory.make_FilesystemGroup( group_type=FILESYSTEM_GROUP_TYPE.BCACHE, cache_set=cache_set, filesystems=filesystems, ) form = UpdateBcacheForm(bcache=bcache, data={"backing_device": boot_disk.id}) self.assertTrue(form.is_valid(), form.errors) bcache = form.save() boot_partition = boot_disk.get_partitiontable().partitions.first() self.assertEqual( boot_partition.get_effective_filesystem(), bcache.filesystems.get(fstype=FILESYSTEM_TYPE.BCACHE_BACKING), )
def test_get_cache_set_by_id_or_name_by_id(self): node = factory.make_Node() cache_set = factory.make_CacheSet(node=node) self.assertEqual( cache_set, CacheSet.objects.get_cache_set_by_id_or_name(cache_set.id, node), )
def test_handler_path(self): node = factory.make_Node() cache_set = factory.make_CacheSet(node=node) self.assertEqual( '/MAAS/api/2.0/nodes/%s/bcache-cache-set/%s/' % (node.system_id, cache_set.id), get_bcache_cache_set_uri(cache_set, node=node))
def test_bcache_creation_on_save(self): node = factory.make_Node() backing_size = 10 * 1000**4 cache_set = factory.make_CacheSet(node=node) backing_device = factory.make_PhysicalBlockDevice(node=node, size=backing_size) uuid = str(uuid4()) form = CreateBcacheForm(node=node, data={ 'name': 'bcache0', 'uuid': uuid, 'cache_set': cache_set.id, 'backing_device': backing_device.id, 'cache_mode': CACHE_MODE_TYPE.WRITEBACK, }) self.assertTrue(form.is_valid(), form.errors) bcache = form.save() self.assertEqual('bcache0', bcache.name) self.assertEqual(uuid, bcache.uuid) self.assertEqual(cache_set, bcache.cache_set) self.assertEqual( backing_device.get_effective_filesystem(), bcache.filesystems.get(fstype=FILESYSTEM_TYPE.BCACHE_BACKING)) self.assertEqual(backing_size, bcache.get_size()) self.assertEqual(FILESYSTEM_GROUP_TYPE.BCACHE, bcache.group_type)
def test_get_cache_set_for_block_device(self): block_device = factory.make_PhysicalBlockDevice() cache_set = factory.make_CacheSet(block_device=block_device) self.assertEqual( cache_set, CacheSet.objects.get_cache_set_for_block_device(block_device), )
def test_choices_are_being_populated_correctly(self): node = factory.make_Node(with_boot_disk=False) # Make 10 block devices. bds = [ factory.make_PhysicalBlockDevice(node=node, size=10 * 1000**4) for _ in range(10) ] # Make 3 cache sets. cache_sets = [factory.make_CacheSet(node=node) for _ in range(3)] cache_set_choices = [cache_set.id for cache_set in cache_sets ] + [cache_set.name for cache_set in cache_sets] # Partition the last 5 devices with a single partition. partitions = [ factory.make_PartitionTable(block_device=bd).add_partition() for bd in bds[5:] ] partition_choices = [partition.id for partition in partitions ] + [partition.name for partition in partitions] # Get the IDs of the non-partitioned devices. block_devices = [ bd.id for bd in bds if bd.get_partitiontable() is None ] + [bd.name for bd in bds if bd.get_partitiontable() is None] form = CreateBcacheForm(node=node, data={}) self.assertItemsEqual( cache_set_choices, [k for (k, v) in form.fields["cache_set"].choices], ) self.assertItemsEqual( block_devices, [k for (k, v) in form.fields["backing_device"].choices], ) self.assertItemsEqual( partition_choices, [k for (k, v) in form.fields["backing_partition"].choices], )
def test_update_change_cache_device(self): mock_create_audit_event = self.patch( bcache_cacheset_module, "create_audit_event" ) self.become_admin() node = factory.make_Node(status=NODE_STATUS.READY) cache_set = factory.make_CacheSet(node=node) new_device = factory.make_PhysicalBlockDevice(node) uri = get_bcache_cache_set_uri(cache_set) response = self.client.put(uri, {"cache_device": new_device.id}) self.assertEqual( http.client.OK, response.status_code, response.content ) parsed_device = json_load_bytes(response.content) self.assertEqual(new_device.id, parsed_device["cache_device"]["id"]) self.assertThat( mock_create_audit_event, MockCalledOnceWith( EVENT_TYPES.NODE, ENDPOINT.API, ANY, node.system_id, "Updated bcache cache set.", ), )
def test_bcache_with_invalid_block_device_fails(self): """Tests allowable device list validation.""" node = factory.make_Node() cache_set = factory.make_CacheSet(node=node) filesystems = [ factory.make_Filesystem( partition=factory.make_PartitionTable( block_device=factory.make_PhysicalBlockDevice( node=node)).add_partition(), fstype=FILESYSTEM_TYPE.BCACHE_BACKING, ) ] backing_device = factory.make_PhysicalBlockDevice() bcache = factory.make_FilesystemGroup( group_type=FILESYSTEM_GROUP_TYPE.BCACHE, cache_set=cache_set, filesystems=filesystems, ) form = UpdateBcacheForm(bcache=bcache, data={"backing_device": backing_device.id}) self.assertFalse(form.is_valid(), form.errors) self.assertIn("Select a valid choice.", form.errors["backing_device"][0]) self.assertIn( "is not one of the available choices.", form.errors["backing_device"][0], )
def test__admin_raises_PermissionDenied_when_user_requests_admin(self): user = factory.make_User() node = factory.make_Node() cache_set = factory.make_CacheSet(node=node) self.assertRaises(PermissionDenied, CacheSet.objects.get_cache_set_or_404, node.system_id, cache_set.id, user, NodePermission.admin)
def test__edit_raises_PermissionDenied_when_user_not_owner(self): user = factory.make_User() node = factory.make_Node(owner=factory.make_User()) cache_set = factory.make_CacheSet(node=node) self.assertRaises(PermissionDenied, CacheSet.objects.get_cache_set_or_404, node.system_id, cache_set.id, user, NodePermission.edit)
def test_update_409_when_not_ready(self): self.become_admin() node = factory.make_Node(status=NODE_STATUS.ALLOCATED) cache_set = factory.make_CacheSet(node=node) uri = get_bcache_cache_set_uri(cache_set) response = self.client.put(uri, {}) self.assertEqual(http.client.CONFLICT, response.status_code, response.content)
def test_delete_deletes_cache_set(self): self.become_admin() node = factory.make_Node(status=NODE_STATUS.READY) cache_set = factory.make_CacheSet(node=node) uri = get_bcache_cache_set_uri(cache_set) response = self.client.delete(uri) self.assertEqual(http.client.NO_CONTENT, response.status_code, response.content) self.assertIsNone(reload_object(cache_set))
def test__admin_returns_device_when_admin(self): user = factory.make_admin() node = factory.make_Node() cache_set = factory.make_CacheSet(node=node) self.assertEqual( cache_set.id, CacheSet.objects.get_cache_set_or_404(node.system_id, cache_set.id, user, NodePermission.admin).id)
def test__view_returns_cache_set_when_owner(self): user = factory.make_User() node = factory.make_Node(owner=user) cache_set = factory.make_CacheSet(node=node) self.assertEqual( cache_set.id, CacheSet.objects.get_cache_set_or_404(node.system_id, cache_set.id, user, NODE_PERMISSION.VIEW).id)
def test__view_returns_cache_set_when_no_owner(self): user = factory.make_User() node = factory.make_Node() cache_set = factory.make_CacheSet(node=node) self.assertEqual( cache_set.id, CacheSet.objects.get_cache_set_or_404(node.system_id, cache_set.id, user, NodePermission.view).id)
def test__edit_returns_device_when_user_is_owner(self): user = factory.make_User() node = factory.make_Node(owner=user) cache_set = factory.make_CacheSet(node=node) self.assertEqual( cache_set.id, CacheSet.objects.get_cache_set_or_404(node.system_id, cache_set.id, user, NodePermission.edit).id)
def test_get_cache_set_by_id_or_name_by_id_invalid_for_mismatch_node(self): node = factory.make_Node() cache_set = factory.make_CacheSet(node=node) self.assertRaises( CacheSet.DoesNotExist, CacheSet.objects.get_cache_set_by_id_or_name, cache_set.id, factory.make_Node(), )
def test__return_cache_set_by_name(self): user = factory.make_User() node = factory.make_Node() cache_set = factory.make_CacheSet(node=node) self.assertEqual( cache_set.id, CacheSet.objects.get_cache_set_or_404(node.system_id, cache_set.name, user, NODE_PERMISSION.VIEW).id)
def test_update_400_when_invalid_id(self): self.become_admin() node = factory.make_Node(status=NODE_STATUS.READY) cache_set = factory.make_CacheSet(node=node) new_device = factory.make_PhysicalBlockDevice(node=node) factory.make_Filesystem(block_device=new_device) uri = get_bcache_cache_set_uri(cache_set) response = self.client.put(uri, {"cache_device": new_device}) self.assertEqual(http.client.BAD_REQUEST, response.status_code, response.content)
def test_return_cache_set_by_name(self): user = factory.make_User() node = factory.make_Node() cache_set = factory.make_CacheSet(node=node) self.assertEqual( cache_set.id, CacheSet.objects.get_cache_set_or_404( node.system_id, cache_set.name, user, NodePermission.view ).id, )
def test_save_updates_the_cache_set_with_partition(self): node = factory.make_Node() cache_device = factory.make_PhysicalBlockDevice(node=node) cache_set = factory.make_CacheSet(block_device=cache_device) new_partition = factory.make_Partition(node=node) form = UpdateCacheSetForm(cache_set=cache_set, data={"cache_partition": new_partition.id}) self.assertTrue(form.is_valid(), form.errors) cache_set = form.save() self.assertEqual(new_partition, cache_set.get_device()) self.assertIsNone(cache_device.get_effective_filesystem())
def test_raises_Http404_when_invalid_node(self): user = factory.make_admin() cache_set = factory.make_CacheSet() self.assertRaises( Http404, CacheSet.objects.get_cache_set_or_404, factory.make_name("system_id"), cache_set.id, user, NodePermission.view, )