Exemple #1
0
    def test_create_nested_snapshots_and_attach_volume(self):
        fake_volume = mock.MagicMock()
        fake_snapshot = mock.MagicMock()

        scenario = volumes.CinderVolumes(context=self._get_context())

        scenario._attach_volume = mock.MagicMock()
        scenario._detach_volume = mock.MagicMock()
        scenario._delete_server = mock.MagicMock()
        scenario._create_volume = mock.MagicMock(return_value=fake_volume)
        scenario._delete_volume = mock.MagicMock()
        scenario._create_snapshot = mock.MagicMock(return_value=fake_snapshot)
        scenario._delete_snapshot = mock.MagicMock()

        scenario.create_nested_snapshots_and_attach_volume()

        volume_count = scenario._create_volume.call_count
        snapshots_count = scenario._create_snapshot.call_count
        attached_count = scenario._attach_volume.call_count

        self.assertEqual(scenario._delete_volume.call_count, volume_count)
        self.assertEqual(scenario._delete_snapshot.call_count, snapshots_count)
        self.assertEqual(scenario._detach_volume.call_count, attached_count)
Exemple #2
0
    def test_create_nested_snapshots_and_attach_volume_kwargs(self):
        fake_volume = mock.MagicMock()
        fake_snapshot = mock.MagicMock()

        scenario = volumes.CinderVolumes(context=self._get_context())

        scenario._attach_volume = mock.MagicMock()
        scenario._detach_volume = mock.MagicMock()
        scenario._delete_server = mock.MagicMock()
        scenario._create_volume = mock.MagicMock(return_value=fake_volume)
        scenario._delete_volume = mock.MagicMock()
        scenario._create_snapshot = mock.MagicMock(return_value=fake_snapshot)
        scenario._delete_snapshot = mock.MagicMock()

        volume_kwargs = {"volume_type": "type1"}
        scenario.create_nested_snapshots_and_attach_volume(
            size={
                "min": 1,
                "max": 1
            }, create_volume_kwargs=volume_kwargs)

        scenario._create_volume.assert_called_once_with(1, **volume_kwargs)
        self.assertEqual(fake_volume, scenario._create_volume.return_value)
Exemple #3
0
    def test_create_snapshot_and_attach_volume_use_volume_type(self):
        fake_volume = mock.MagicMock()
        fake_snapshot = mock.MagicMock()
        fake_server = mock.MagicMock()

        scenario = volumes.CinderVolumes(self._get_context())

        scenario._attach_volume = mock.MagicMock()
        scenario._detach_volume = mock.MagicMock()
        scenario._boot_server = mock.MagicMock(return_value=fake_server)
        scenario._delete_server = mock.MagicMock()
        scenario._create_volume = mock.MagicMock(return_value=fake_volume)
        scenario._delete_volume = mock.MagicMock()
        scenario._create_snapshot = mock.MagicMock(return_value=fake_snapshot)
        scenario._delete_snapshot = mock.MagicMock()
        fake = fake_type()

        self.clients("cinder").volume_types.list = mock.MagicMock(
            return_value=[fake])
        self.clients("nova").servers.get = mock.MagicMock(
            return_value=fake_server)

        scenario.create_snapshot_and_attach_volume(volume_type=True)

        # Make sure create volume's second arg was the correct volume type.
        # fake or none (randomly selected)
        self.assertTrue(scenario._create_volume.called)
        vol_type = scenario._create_volume.call_args_list[0][1]["volume_type"]
        self.assertTrue(vol_type is fake.name or vol_type is None)
        scenario._create_snapshot.assert_called_once_with(
            fake_volume.id, False)
        scenario._delete_snapshot.assert_called_once_with(fake_snapshot)
        scenario._attach_volume.assert_called_once_with(
            fake_server, fake_volume)
        scenario._detach_volume.assert_called_once_with(
            fake_server, fake_volume)
        scenario._delete_volume.assert_called_once_with(fake_volume)
Exemple #4
0
    def test_create_nested_snapshots_and_attach_volume(self):
        fake_volume = mock.MagicMock()
        fake_snapshot = mock.MagicMock()
        fake_server = mock.MagicMock()
        scenario = volumes.CinderVolumes(
            context={
                "user": {
                    "tenant_id": "fake"
                },
                "users": [{
                    "tenant_id": "fake",
                    "users_per_tenant": 1
                }],
                "tenant": {
                    "id": "fake",
                    "name": "fake",
                    "servers": [fake_server.uuid]
                }
            })

        scenario._attach_volume = mock.MagicMock()
        scenario._detach_volume = mock.MagicMock()
        scenario._delete_server = mock.MagicMock()
        scenario._create_volume = mock.MagicMock(return_value=fake_volume)
        scenario._delete_volume = mock.MagicMock()
        scenario._create_snapshot = mock.MagicMock(return_value=fake_snapshot)
        scenario._delete_snapshot = mock.MagicMock()

        scenario.create_nested_snapshots_and_attach_volume()

        volume_count = scenario._create_volume.call_count
        snapshots_count = scenario._create_snapshot.call_count
        attached_count = scenario._attach_volume.call_count

        self.assertEqual(scenario._delete_volume.call_count, volume_count)
        self.assertEqual(scenario._delete_snapshot.call_count, snapshots_count)
        self.assertEqual(scenario._detach_volume.call_count, attached_count)
Exemple #5
0
    def test_create_volume_and_clone(self, nested_level=1, image=None):
        create_volumes_count = nested_level + 1
        fake_volumes = [mock.Mock(size=1) for i in range(create_volumes_count)]
        scenario = volumes.CinderVolumes(self.context)
        scenario._create_volume = mock.MagicMock(side_effect=fake_volumes)

        scenario.create_volume_and_clone(1,
                                         image=image,
                                         nested_level=nested_level,
                                         fakearg="fake")

        expected = [
            mock.call(1, imageRef=image, fakearg="fake")
            if image else mock.call(1, fakearg="fake")
        ]
        for i in range(nested_level):
            expected.append(
                mock.call(fake_volumes[i].size,
                          source_volid=fake_volumes[i].id,
                          atomic_action=False,
                          fakearg="fake"))
            self._test_atomic_action_timer(scenario.atomic_actions(),
                                           "cinder.clone_volume")
        scenario._create_volume.assert_has_calls(expected)
Exemple #6
0
    def test_create_and_upload_volume_to_image(self):
        fake_volume = mock.Mock()
        fake_image = mock.Mock()
        scenario = volumes.CinderVolumes(self.context)

        scenario._create_volume = mock.MagicMock(return_value=fake_volume)
        scenario._upload_volume_to_image = mock.MagicMock(
            return_value=fake_image)
        scenario._delete_volume = mock.MagicMock()
        scenario._delete_image = mock.MagicMock()

        scenario.create_and_upload_volume_to_image(2,
                                                   image="img",
                                                   container_format="fake",
                                                   disk_format="disk",
                                                   do_delete=False,
                                                   fakeargs="fakeargs")

        scenario._create_volume.assert_called_once_with(2,
                                                        imageRef="img",
                                                        fakeargs="fakeargs")
        scenario._upload_volume_to_image.assert_called_once_with(
            fake_volume, False, "fake", "disk")
        scenario._create_volume.reset_mock()
        scenario._upload_volume_to_image.reset_mock()

        scenario.create_and_upload_volume_to_image(1,
                                                   image=None,
                                                   do_delete=True,
                                                   fakeargs="fakeargs")

        scenario._create_volume.assert_called_once_with(1, fakeargs="fakeargs")
        scenario._upload_volume_to_image.assert_called_once_with(
            fake_volume, False, "bare", "raw")
        scenario._delete_volume.assert_called_once_with(fake_volume)
        scenario._delete_image.assert_called_once_with(fake_image)
Exemple #7
0
    def test_create_volume_and_modify_metadata(self):
        scenario = volumes.CinderVolumes(
            context={
                "user": {
                    "tenant_id": "fake"
                },
                "tenant": {
                    "id": "fake",
                    "name": "fake",
                    "volumes": [{
                        "id": "uuid"
                    }]
                }
            })
        scenario._set_metadata = mock.Mock()
        scenario._delete_metadata = mock.Mock()

        scenario.modify_volume_metadata(sets=5,
                                        set_size=4,
                                        deletes=3,
                                        delete_size=2)
        scenario._set_metadata.assert_called_once_with("uuid", 5, 4)
        scenario._delete_metadata.assert_called_once_with(
            "uuid", scenario._set_metadata.return_value, 3, 2)
Exemple #8
0
 def test_list_volumes(self):
     scenario = volumes.CinderVolumes(self.context)
     scenario._list_volumes = mock.MagicMock()
     scenario.list_volumes(True)
     scenario._list_volumes.assert_called_once_with(True)