def test_filter_by_tags_returns_no_devices(self): tags = [factory.make_name('tag') for _ in range(3)] for _ in range(3): factory.make_BlockDevice(tags=tags) self.assertItemsEqual([], BlockDevice.objects.filter_by_tags( [factory.make_name('tag')]))
def _make_interesting_RAID( node, level=FILESYSTEM_GROUP_TYPE.RAID_6, num_devices=10, num_partitions=10, num_spare_devices=2, num_spare_partitions=2): """Returns a RAID that is interesting for our tests.""" size = 1000 ** 4 # A Terabyte. block_devices = [factory.make_BlockDevice(node=node, size=size) for _ in range(num_devices)] partitions = [factory.make_Partition(node=node, block_device_size=size) for _ in range(num_partitions)] spare_devices = [factory.make_BlockDevice(node=node, size=size) for _ in range(num_spare_devices)] spare_partitions = [ factory.make_Partition(node=node, block_device_size=size) for _ in range(num_spare_partitions) ] return RAID.objects.create_raid( name='md%d' % random.randint(1, 1000), level=level, uuid=uuid4(), block_devices=block_devices, partitions=partitions, spare_devices=spare_devices, spare_partitions=spare_partitions )
def test_filter_by_tags_returns_devices_with_all_tags(self): tags = [factory.make_name('tag') for _ in range(3)] other_tags = [factory.make_name('tag') for _ in range(3)] devices_with_tags = [ factory.make_BlockDevice(tags=tags) for _ in range(3) ] for _ in range(3): factory.make_BlockDevice(tags=other_tags) self.assertItemsEqual(devices_with_tags, BlockDevice.objects.filter_by_tags(tags))
def test_get_free_block_devices_for_node(self): node = factory.make_Node(with_boot_disk=False) free_devices = [factory.make_BlockDevice(node=node) for _ in range(3)] # Block devices with partition tables. for _ in range(3): factory.make_PartitionTable(block_device=factory.make_BlockDevice( node=node)) # Block devices with filesystems. for _ in range(3): factory.make_Filesystem(block_device=factory.make_BlockDevice( node=node)) self.assertItemsEqual( free_devices, BlockDevice.objects.get_free_block_devices_for_node(node))
def test_user_cannot_view_BlockDevice_when_no_owner_rbac(self): self.enable_rbac() user = factory.make_User() node = factory.make_Node() device = factory.make_BlockDevice(node=node) backend = MAASAuthorizationBackend() self.assertFalse(backend.has_perm(user, NodePermission.view, device))
def test_fs_formatted(self): block_device = factory.make_BlockDevice() fs = factory.make_Filesystem(block_device=block_device) self.assertEqual( "Unmounted %s formatted filesystem" % fs.fstype, used_for(block_device), )
def test__raises_Http404_when_invalid_node(self): user = factory.make_admin() block_device = factory.make_BlockDevice() self.assertRaises( Http404, BlockDevice.objects.get_block_device_or_404, factory.make_name("system_id"), block_device.id, user, NodePermission.view)
def test__returns_device_when_admin(self): user = factory.make_admin() node = factory.make_Node() device = factory.make_BlockDevice(node=node) self.assertEqual( device.id, BlockDevice.objects.get_block_device_or_404( node.system_id, device.id, user, NodePermission.admin).id)
def test__edit_returns_device_when_user_is_owner(self): user = factory.make_User() node = factory.make_Node(owner=user) device = factory.make_BlockDevice(node=node) self.assertEqual( device.id, BlockDevice.objects.get_block_device_or_404( node.system_id, device.id, user, NodePermission.edit).id)
def test_admin_doesnt_have_admin_permission_on_BlockDevice_with_rbac(self): self.enable_rbac() backend = MAASAuthorizationBackend() user = factory.make_admin() node = factory.make_Node() device = factory.make_BlockDevice(node=node) self.assertFalse(backend.has_perm(user, NodePermission.admin, device))
def test_unique_on_block_device_and_acquired(self): # For any given block device, at most one unacquired and one acquired # filesystem record may exist. block_device = factory.make_BlockDevice() filesystem = factory.make_Filesystem(block_device=block_device) self.assertIsNone(filesystem.partition) # XXX: Why no Filesystem.acquire() method? filesystem_acquired = copy(filesystem) filesystem_acquired.id = None # Force INSERT. filesystem_acquired.acquired = True filesystem_acquired.save() # Create a duplicate. filesystem_dupe = copy(filesystem) filesystem_dupe.id = None # Force INSERT. error_messages_expected = Equals( ['Filesystem with this Block device and Acquired already exists.']) # Saving an unacquired duplicate fails. filesystem_dupe.acquired = False error = self.assertRaises(ValidationError, filesystem_dupe.save) self.assertThat(error.messages, error_messages_expected) # Saving an acquired duplicate fails. filesystem_dupe.acquired = True error = self.assertRaises(ValidationError, filesystem_dupe.save) self.assertThat(error.messages, error_messages_expected)
def test_validate_can_save_gpt_larger_than_2TiB(self): block_device = factory.make_BlockDevice(size=3 * (1024 ** 4)) # 3TiB partition_table = factory.make_PartitionTable( block_device=block_device, table_type=PARTITION_TABLE_TYPE.GPT ) # Test is that an error is not raised. partition_table.add_partition()
def test_filter_by_tags_returns_devices_with_iterable(self): tags = [factory.make_name('tag') for _ in range(3)] other_tags = [factory.make_name('tag') for _ in range(3)] devices_with_tags = [ factory.make_BlockDevice(tags=tags) for _ in range(3) ] for _ in range(3): factory.make_BlockDevice(tags=other_tags) def tag_generator(): for tag in tags: yield tag self.assertItemsEqual( devices_with_tags, BlockDevice.objects.filter_by_tags(tag_generator()))
def test_get_effective_filesystem(self): mock_get_effective_filesystem = self.patch_autospec( blockdevice_module, "get_effective_filesystem") mock_get_effective_filesystem.return_value = sentinel.filesystem block_device = factory.make_BlockDevice() self.assertEqual(sentinel.filesystem, block_device.get_effective_filesystem())
def test__view_raises_PermissionDenied_when_user_not_owner(self): user = factory.make_User() node = factory.make_Node(owner=factory.make_User()) device = factory.make_BlockDevice(node=node) self.assertRaises(PermissionDenied, BlockDevice.objects.get_block_device_or_404, node.system_id, device.id, user, NodePermission.view)
def test_get_effective_filesystem(self): mock_get_effective_filesystem = self.patch_autospec( blockdevice_module, "get_effective_filesystem") mock_get_effective_filesystem.return_value = sentinel.filesystem node = factory.make_Node(with_boot_disk=False) block_device = factory.make_BlockDevice(node=node) self.assertEqual(sentinel.filesystem, block_device.get_effective_filesystem())
def test__raises_PermissionDenied_when_user_requests_admin(self): user = factory.make_User() node = factory.make_Node() device = factory.make_BlockDevice(node=node) self.assertRaises(PermissionDenied, BlockDevice.objects.get_block_device_or_404, node.system_id, device.id, user, NodePermission.admin)
def test__admin_returns_device_when_admin(self): user = factory.make_admin() node = factory.make_Node() device = factory.make_BlockDevice(node=node) self.assertEqual( device.id, BlockDevice.objects.get_block_device_or_404( node.system_id, device.id, user, NODE_PERMISSION.ADMIN).id)
def test_remove_invalid_spare_blockdevice_fails(self): raid = _make_interesting_RAID(node=factory.make_Node()) ids = [factory.make_BlockDevice().id for _ in range(2)] form = UpdateRaidForm(raid, data={'remove_spare_devices': ids}) self.assertFalse(form.is_valid(), form.errors) self.assertIn('remove_spare_devices', form.errors) self.assertIn('is not one of the available choices.', form.errors['remove_spare_devices'][0])
def test_delete_not_allowed_if_part_of_filesystem_group(self): block_device = factory.make_BlockDevice() VolumeGroup.objects.create_volume_group(factory.make_name("vg"), [block_device], []) error = self.assertRaises(ValidationError, block_device.delete) self.assertEqual( "Cannot delete block device because its part of a volume group.", error.message)
def test_add_valid_spare_device(self): raid = factory.make_FilesystemGroup( group_type=FILESYSTEM_GROUP_TYPE.RAID_6) # Add 5 new blockdevices to the node. bd_ids = [factory.make_BlockDevice(node=raid.get_node()).id for _ in range(5)] form = UpdateRaidForm(raid, data={'add_spare_devices': bd_ids}) self.assertTrue(form.is_valid(), form.errors)
def test_user_has_no_admin_permission_on_BlockDevice(self): # NodePermission.admin permission on block devices is granted to super # user only. backend = MAASAuthorizationBackend() user = factory.make_User() self.assertFalse( backend.has_perm(user, NodePermission.admin, factory.make_BlockDevice()))
def test_user_cannot_edit_BlockDevice_rbac_if_locked(self): self.enable_rbac() user = factory.make_User() node = factory.make_Node(locked=True) device = factory.make_BlockDevice(node=node) self.rbac_store.add_pool(node.pool) self.rbac_store.allow(user.username, node.pool, 'admin-machine') backend = MAASAuthorizationBackend() self.assertFalse(backend.has_perm(user, NodePermission.edit, device))
def test_get_available_size(self): block_size = 4096 device = factory.make_BlockDevice(size=MIN_PARTITION_SIZE * 3 + PARTITION_TABLE_EXTRA_SPACE, block_size=block_size) partition_table = factory.make_PartitionTable(block_device=device) partition_table.add_partition(size=MIN_PARTITION_SIZE) self.assertEqual(MIN_PARTITION_SIZE * 2, partition_table.get_available_size())
def test_user_cannot_lock_BlockDevice_node_rbac_owner_other_user(self): self.enable_rbac() user = factory.make_User() node = factory.make_Node(owner=factory.make_User()) device = factory.make_BlockDevice(node=node) backend = MAASAuthorizationBackend() self.rbac_store.add_pool(node.pool) self.rbac_store.allow(user.username, node.pool, 'view') self.assertFalse(backend.has_perm(user, NodePermission.lock, device))
def test_user_has_admin_permission_on_BlockDevice_with_rbac(self): self.enable_rbac() backend = MAASAuthorizationBackend() user = factory.make_User() node = factory.make_Node() device = factory.make_BlockDevice(node=node) self.rbac_store.add_pool(node.pool) self.rbac_store.allow(user.username, node.pool, 'admin-machines') self.assertTrue(backend.has_perm(user, NodePermission.admin, device))
def test_user_can_view_BlockDevice_on_unowned_node_rbac(self): self.enable_rbac() user = factory.make_User() node = factory.make_Node() device = factory.make_BlockDevice(node=node) self.rbac_store.add_pool(node.pool) self.rbac_store.allow(user.username, node.pool, 'view') backend = MAASAuthorizationBackend() self.assertTrue(backend.has_perm(user, NodePermission.view, device))
def test_fs_formatted_and_mounted(self): block_device = factory.make_BlockDevice() fs = factory.make_Filesystem(block_device=block_device, mount_point="/mnt") self.assertEqual( ("%s formatted filesystem mounted at %s" % (fs.fstype, fs.mount_point)), used_for(block_device), )
def test_add_partition_no_size(self): """Tests whether a partition with no specified size stretches to the end of the device""" block_size = 4096 device = factory.make_BlockDevice(size=MIN_BLOCK_DEVICE_SIZE * 2 + PARTITION_TABLE_EXTRA_SPACE, block_size=block_size) partition_table = factory.make_PartitionTable(block_device=device) partition = partition_table.add_partition() self.assertEqual(partition.size, MIN_BLOCK_DEVICE_SIZE * 2)
def test_add_partition_to_full_device(self): """Tests whether we fail to add a partition to an already full device. """ block_size = 4096 device = factory.make_BlockDevice(size=MIN_BLOCK_DEVICE_SIZE * 3 + PARTITION_TABLE_EXTRA_SPACE, block_size=block_size) partition_table = factory.make_PartitionTable(block_device=device) partition_table.add_partition() self.assertRaises(ValidationError, partition_table.add_partition)