def test_get_volume(self, mock_boto3):
"""Test that a Volume is returned."""
region = random.choice(helper.SOME_AWS_REGIONS)
zone = helper.generate_dummy_availability_zone(region)
volume_id = helper.generate_dummy_volume_id()
mock_volume = helper.generate_mock_volume(volume_id=volume_id,
zone=zone)
resource = mock_boto3.resource.return_value
resource.Volume.return_value = mock_volume
actual_volume = ec2.get_volume(volume_id, region)
self.assertEqual(actual_volume, mock_volume)
def test_enqueue_ready_volume_success(self, mock_aws, mock_queue):
"""Assert that volumes are enqueued when ready."""
ami_id = util_helper.generate_dummy_image_id()
volume_id = util_helper.generate_dummy_volume_id()
mock_volume = util_helper.generate_mock_volume(volume_id=volume_id,
state="available")
region = mock_volume.zone[:-1]
mock_aws.get_volume.return_value = mock_volume
messages = [{"ami_id": ami_id, "volume_id": volume_id}]
enqueue_ready_volume(ami_id, volume_id, region)
mock_queue.assert_called_with(self.ready_volumes_queue_name, messages)
def test_enqueue_ready_volume_error(self, mock_aws):
"""Assert that an error is raised on bad volume state."""
ami_id = util_helper.generate_dummy_image_id()
volume_id = util_helper.generate_dummy_volume_id()
mock_volume = util_helper.generate_mock_volume(
volume_id=volume_id,
state=random.choice(('in-use', 'deleting', 'deleted', 'error')))
region = mock_volume.zone[:-1]
mock_aws.get_volume.return_value = mock_volume
mock_aws.check_volume_state.side_effect = AwsVolumeError()
with self.assertRaises(AwsVolumeError):
enqueue_ready_volume(ami_id, volume_id, region)
def test_enqueue_ready_volume_retry(self, mock_aws):
"""Assert that the task retries when volume is not available."""
ami_id = util_helper.generate_dummy_image_id()
volume_id = util_helper.generate_dummy_volume_id()
mock_volume = util_helper.generate_mock_volume(volume_id=volume_id,
state="creating")
region = mock_volume.zone[:-1]
mock_aws.get_volume.return_value = mock_volume
mock_aws.check_volume_state.side_effect = AwsVolumeNotReadyError()
with patch.object(enqueue_ready_volume, "retry") as mock_retry:
mock_retry.side_effect = Retry()
with self.assertRaises(Retry):
enqueue_ready_volume(ami_id, volume_id, region)
def test_create_volume_snapshot_ready(self, mock_boto3):
"""Test that volume creation starts when snapshot is ready."""
zone = helper.generate_dummy_availability_zone()
mock_snapshot = helper.generate_mock_snapshot()
mock_volume = helper.generate_mock_volume()
mock_ec2 = mock_boto3.resource.return_value
mock_ec2.Snapshot.return_value = mock_snapshot
mock_ec2.create_volume.return_value = mock_volume
volume_id = ec2.create_volume(mock_snapshot.snapshot_id, zone)
mock_ec2.create_volume.assert_called_with(
SnapshotId=mock_snapshot.snapshot_id, AvailabilityZone=zone)
mock_boto3.resource.assert_called_once_with('ec2')
self.assertEqual(volume_id, mock_volume.id)
def test_create_volume_success(self, mock_aws):
"""Assert that the volume create task succeeds."""
ami_id = util_helper.generate_dummy_image_id()
snapshot_id = util_helper.generate_dummy_snapshot_id()
zone = settings.HOUNDIGRADE_AWS_AVAILABILITY_ZONE
region = zone[:-1]
mock_volume = util_helper.generate_mock_volume()
mock_aws.create_volume.return_value = mock_volume.id
mock_aws.get_region_from_availability_zone.return_value = region
with patch.object(tasks, 'enqueue_ready_volume') as mock_enqueue:
create_volume(ami_id, snapshot_id)
mock_enqueue.delay.assert_called_with(ami_id, mock_volume.id,
region)
mock_aws.create_volume.assert_called_with(snapshot_id, zone)
def test_delete_snapshot_success(self, mock_aws, mock_boto3):
"""Assert that the delete snapshot succeeds."""
mock_snapshot_copy_id = util_helper.generate_dummy_snapshot_id()
mock_snapshot_copy = util_helper.generate_mock_snapshot(
mock_snapshot_copy_id)
resource = mock_boto3.resource.return_value
resource.Snapshot.return_value = mock_snapshot_copy
volume_id = util_helper.generate_dummy_volume_id()
mock_volume = util_helper.generate_mock_volume(volume_id=volume_id,
state="available")
volume_region = mock_volume.zone[:-1]
mock_aws.get_volume.return_value = mock_volume
mock_aws.check_volume_state.return_value = None
delete_snapshot(mock_snapshot_copy_id, volume_id, volume_region)
def test_check_volume_state_error(self):
"""Test the appropriate error for other volume states."""
mock_volume = helper.generate_mock_volume(state='error')
with self.assertRaises(AwsVolumeError):
ec2.check_volume_state(mock_volume)
def test_check_volume_state_creating(self):
"""Test the appropriate error for still creating volumes."""
mock_volume = helper.generate_mock_volume(state='creating')
with self.assertRaises(AwsVolumeNotReadyError):
ec2.check_volume_state(mock_volume)
def test_check_volume_state_available(self):
"""Test that a volue is available."""
mock_volume = helper.generate_mock_volume(state='available')
self.assertIsNone(ec2.check_volume_state(mock_volume))
