vm_shepherd 0.0.1 → 0.1.0

data/spec/vm_shepherd/shepherd_spec.rb

@@ -1,23 +1,19 @@
-require 'vm_shepherd/shepherd'
+require 'vm_shepherd'
 require 'recursive_open_struct'
 
 module VmShepherd
   RSpec.describe Shepherd do
     subject(:manager) { Shepherd.new(settings: settings) }
 
-    specify { expect(Shepherd::VCLOUD_IAAS_TYPE).to eq('vcloud') }
-    specify { expect(Shepherd::VSPHERE_IAAS_TYPE).to eq('vsphere') }
-    specify { expect(Shepherd::VSPHERE_TEMPLATE_PREFIX).to eq('tpl') }
-
     describe '#deploy' do
       context 'with vcloud settings' do
         let(:settings) do
           RecursiveOpenStruct.new(YAML.load_file(File.join(SPEC_ROOT, 'fixtures', 'shepherd', 'vcloud.yml')))
         end
-        let(:deployer) { instance_double(VappManager::Deployer) }
+        let(:vcloud_manager) { instance_double(VcloudManager) }
 
-        it 'uses VappManager::Deployer to launch a vm' do
-          expect(VappManager::Deployer).to receive(:new).
+        it 'uses VcloudManager::Deployer to launch a vm' do
+          expect(VcloudManager).to receive(:new).
               with(
                 {
                   url: settings.vapp_deployer.creds.url,
@@ -31,9 +27,9 @@ module VmShepherd
                   network: settings.vapp_deployer.vdc.network,
                 },
                 instance_of(Logger)
-              ).and_return(deployer)
+              ).and_return(vcloud_manager)
 
-          expect(deployer).to receive(:deploy).with(
+          expect(vcloud_manager).to receive(:deploy).with(
               'FAKE_PATH',
               {
                 name: settings.vapp_deployer.vapp.name,
@@ -53,28 +49,17 @@ module VmShepherd
         let(:settings) do
           RecursiveOpenStruct.new(YAML.load_file(File.join(SPEC_ROOT, 'fixtures', 'shepherd', 'vsphere.yml')))
         end
-        let(:deployer) { instance_double(OvaManager::Deployer) }
+        let(:ova_manager) { instance_double(VsphereManager) }
 
-        it 'uses OvaManager::Deployer to launch a vm' do
-          expect(OvaManager::Deployer).to receive(:new).
-              with(
-                {
-                  host: settings.vm_deployer.vcenter_creds.ip,
-                  user: settings.vm_deployer.vcenter_creds.username,
-                  password: settings.vm_deployer.vcenter_creds.password,
-                },
-                {
-                  datacenter: settings.vm_deployer.vsphere.datacenter,
-                  cluster: settings.vm_deployer.vsphere.cluster,
-                  resource_pool: settings.vm_deployer.vsphere.resource_pool,
-                  datastore: settings.vm_deployer.vsphere.datastore,
-                  network: settings.vm_deployer.vsphere.network,
-                  folder: settings.vm_deployer.vsphere.folder,
-                },
-              ).and_return(deployer)
+        it 'uses VsphereManager::Deployer to launch a vm' do
+          expect(VsphereManager).to receive(:new).with(
+              settings.vm_deployer.vcenter_creds.ip,
+                settings.vm_deployer.vcenter_creds.username,
+                settings.vm_deployer.vcenter_creds.password,
+                settings.vm_deployer.vsphere.datacenter,
+              ).and_return(ova_manager)
 
-          expect(deployer).to receive(:deploy).with(
-              Shepherd::VSPHERE_TEMPLATE_PREFIX,
+          expect(ova_manager).to receive(:deploy).with(
               'FAKE_PATH',
               {
                 ip: settings.vm_deployer.vm.ip,
@@ -82,7 +67,14 @@ module VmShepherd
                 netmask: settings.vm_deployer.vm.netmask,
                 dns: settings.vm_deployer.vm.dns,
                 ntp_servers: settings.vm_deployer.vm.ntp_servers,
-              }
+              },
+              {
+                cluster: settings.vm_deployer.vsphere.cluster,
+                resource_pool: settings.vm_deployer.vsphere.resource_pool,
+                datastore: settings.vm_deployer.vsphere.datastore,
+                network: settings.vm_deployer.vsphere.network,
+                folder: settings.vm_deployer.vsphere.folder,
+              },
             )
 
           manager.deploy(path: 'FAKE_PATH')
@@ -93,7 +85,7 @@ module VmShepherd
         let(:settings) do
           RecursiveOpenStruct.new(YAML.load_file(File.join(SPEC_ROOT, 'fixtures', 'shepherd', 'aws.yml')))
         end
-        let(:ams_manager) { instance_double(AmiManager) }
+        let(:ams_manager) { instance_double(AwsManager) }
         let(:ami_file_path) { 'PATH_TO_AMI_FILE' }
         let(:aws_options) do
           {
@@ -109,12 +101,49 @@ module VmShepherd
         end
 
         it 'uses AwsManager::Deployer to launch a VM' do
-          expect(AmiManager).to receive(:new).with(aws_options).and_return(ams_manager)
+          expect(AwsManager).to receive(:new).with(aws_options).and_return(ams_manager)
           expect(ams_manager).to receive(:deploy).with(ami_file_path)
           manager.deploy(path: ami_file_path)
         end
       end
 
+      context 'with OpenStack settings' do
+        let(:settings) do
+          RecursiveOpenStruct.new(YAML.load_file(File.join(SPEC_ROOT, 'fixtures', 'shepherd', 'openstack.yml')))
+        end
+        let(:qcow2_manager) { instance_double(OpenstackManager) }
+        let(:qcow2_file_path) { 'PATH_TO_QCOW2_FILE' }
+        let(:openstack_options) do
+          {
+            auth_url: 'http://example.com/version/tokens',
+            username: 'username',
+            api_key: 'api-key',
+            tenant: 'tenant',
+          }
+        end
+        let(:openstack_vm_options) do
+          {
+            name: 'some-vm-name',
+            min_disk_size: 150,
+            network_name: 'some-network',
+            key_name: 'some-key',
+            security_group_names: [
+              'security-group-A',
+              'security-group-B',
+              'security-group-C',
+            ],
+            public_ip: '198.11.195.5',
+            private_ip: '192.168.100.100',
+          }
+        end
+
+        it 'uses QCow2Manager to launch a VM' do
+          expect(OpenstackManager).to receive(:new).with(openstack_options).and_return(qcow2_manager)
+          expect(qcow2_manager).to receive(:deploy).with(qcow2_file_path, openstack_vm_options)
+          manager.deploy(path: qcow2_file_path)
+        end
+      end
+
       context 'when IAAS is unknown' do
         let(:settings) do
           RecursiveOpenStruct.new(YAML.load_file(File.join(SPEC_ROOT, 'fixtures', 'shepherd', 'unknown.yml')))
@@ -131,10 +160,10 @@ module VmShepherd
         let(:settings) do
           RecursiveOpenStruct.new(YAML.load_file(File.join(SPEC_ROOT, 'fixtures', 'shepherd', 'vcloud.yml')))
         end
-        let(:destroyer) { instance_double(VappManager::Destroyer) }
+        let(:vcloud_manager) { instance_double(VcloudManager) }
 
-        it 'uses VappManager::Destroyer to destroy a vm' do
-          expect(VappManager::Destroyer).to receive(:new).with(
+        it 'uses VcloudManager::Destroyer to destroy a vm' do
+          expect(VcloudManager).to receive(:new).with(
               {
                 url: settings.vapp_deployer.creds.url,
                 organization: settings.vapp_deployer.creds.organization,
@@ -144,10 +173,11 @@ module VmShepherd
               {
                 vdc: settings.vapp_deployer.vdc.name,
                 catalog: settings.vapp_deployer.vdc.catalog,
+                network: settings.vapp_deployer.vdc.network,
               },
               instance_of(Logger)
-            ).and_return(destroyer)
-          expect(destroyer).to receive(:destroy).with(settings.vapp_deployer.vapp.name)
+            ).and_return(vcloud_manager)
+          expect(vcloud_manager).to receive(:destroy).with(settings.vapp_deployer.vapp.name)
 
           manager.destroy
         end
@@ -157,18 +187,16 @@ module VmShepherd
         let(:settings) do
           RecursiveOpenStruct.new(YAML.load_file(File.join(SPEC_ROOT, 'fixtures', 'shepherd', 'vsphere.yml')))
         end
-        let(:destroyer) { instance_double(OvaManager::Destroyer) }
+        let(:ova_manager) { instance_double(VsphereManager) }
 
-        it 'uses OvaManager::Destroyer to destroy a vm' do
-          expect(OvaManager::Destroyer).to receive(:new).with(
+        it 'uses VsphereManager::Destroyer to destroy a vm' do
+          expect(VsphereManager).to receive(:new).with(
+              settings.vm_deployer.vcenter_creds.ip,
+              settings.vm_deployer.vcenter_creds.username,
+              settings.vm_deployer.vcenter_creds.password,
               settings.vm_deployer.vsphere.datacenter,
-              {
-                host: settings.vm_deployer.vcenter_creds.ip,
-                user: settings.vm_deployer.vcenter_creds.username,
-                password: settings.vm_deployer.vcenter_creds.password,
-              }
-            ).and_return(destroyer)
-          expect(destroyer).to receive(:clean_folder).with(settings.vm_deployer.vsphere.folder)
+            ).and_return(ova_manager)
+          expect(ova_manager).to receive(:destroy).with(settings.vm_deployer.vsphere.folder)
 
           manager.destroy
         end
@@ -178,7 +206,7 @@ module VmShepherd
         let(:settings) do
           RecursiveOpenStruct.new(YAML.load_file(File.join(SPEC_ROOT, 'fixtures', 'shepherd', 'aws.yml')))
         end
-        let(:ams_manager) { instance_double(AmiManager) }
+        let(:ams_manager) { instance_double(AwsManager) }
         let(:ami_destroy_options) do
           {
             aws_access_key: 'aws-access-key',
@@ -193,12 +221,49 @@ module VmShepherd
         end
 
         it 'uses AwsManager::Deployer to launch a VM' do
-          expect(AmiManager).to receive(:new).with(ami_destroy_options).and_return(ams_manager)
+          expect(AwsManager).to receive(:new).with(ami_destroy_options).and_return(ams_manager)
           expect(ams_manager).to receive(:destroy)
           manager.destroy
         end
       end
 
+      context 'when IAAS is Openstack' do
+        let(:settings) do
+          RecursiveOpenStruct.new(YAML.load_file(File.join(SPEC_ROOT, 'fixtures', 'shepherd', 'openstack.yml')))
+        end
+        let(:qcow2_manager) { instance_double(OpenstackManager) }
+        let(:qcow2_file_path) { 'PATH_TO_QCOW2_FILE' }
+        let(:openstack_options) do
+          {
+            auth_url: 'http://example.com/version/tokens',
+            username: 'username',
+            api_key: 'api-key',
+            tenant: 'tenant',
+          }
+        end
+        let(:openstack_vm_options) do
+          {
+            name: 'some-vm-name',
+            min_disk_size: 150,
+            network_name: 'some-network',
+            key_name: 'some-key',
+            security_group_names: [
+              'security-group-A',
+              'security-group-B',
+              'security-group-C',
+            ],
+            public_ip: '198.11.195.5',
+            private_ip: '192.168.100.100',
+          }
+        end
+
+        it 'uses QCow2Manager to destroy a VM' do
+          expect(OpenstackManager).to receive(:new).with(openstack_options).and_return(qcow2_manager)
+          expect(qcow2_manager).to receive(:destroy).with(openstack_vm_options)
+          manager.destroy
+        end
+      end
+
       context 'when IAAS is unknown' do
         let(:settings) do
           RecursiveOpenStruct.new(YAML.load_file(File.join(SPEC_ROOT, 'fixtures', 'shepherd', 'unknown.yml')))

data/spec/vm_shepherd/vcloud_manager_spec.rb

@@ -0,0 +1,364 @@
+require 'vm_shepherd/vcloud_manager'
+
+module VmShepherd
+  RSpec.describe VcloudManager do
+    let(:login_info) do
+      {
+        url: 'FAKE_URL',
+        organization: 'FAKE_ORGANIZATION',
+        user: 'FAKE_USER',
+        password: 'FAKE_PASSWORD',
+      }
+    end
+    let(:location) do
+      {
+        catalog: 'FAKE_CATALOG',
+        network: 'FAKE_NETWORK',
+        vdc: 'FAKE_VDC',
+      }
+    end
+    let(:logger) { instance_double(Logger).as_null_object }
+
+    let(:vcloud_manager) { VcloudManager.new(login_info, location, logger) }
+
+    describe '#deploy' do
+      let(:vapp_config) do
+        {
+          ip: 'FAKE_IP',
+          name: 'FAKE_NAME',
+          gateway: 'FAKE_GATEWAY',
+          dns: 'FAKE_DNS',
+          ntp: 'FAKE_NTP',
+          ip: 'FAKE_IP',
+          netmask: 'FAKE_NETMASK',
+        }
+      end
+      let(:vapp_template_path) { 'FAKE_VAPP_TEMPLATE_PATH' }
+      let(:tmpdir) { 'FAKE_TMP_DIR' }
+
+      before { allow(Dir).to receive(:mktmpdir).and_return(tmpdir) }
+
+      context 'when NO host exists at the specified IP' do
+        let(:expanded_vapp_template_path) { 'FAKE_EXPANDED_VAPP_TEMPLATE_PATH' }
+
+        before do
+          allow(vcloud_manager).to receive(:system).with("ping -c 5 #{vapp_config.fetch(:ip)}").and_return(false)
+
+          allow(File).to receive(:expand_path).with(vapp_template_path).and_return(expanded_vapp_template_path)
+
+          allow(FileUtils).to receive(:remove_entry_secure)
+        end
+
+        it 'expands the vapp_template into a TMP dir' do
+          expect(vcloud_manager).to receive(:system).with("cd #{tmpdir} && tar xfv '#{expanded_vapp_template_path}'")
+
+          expect { vcloud_manager.deploy(vapp_template_path, vapp_config) }.to raise_error
+        end
+
+        context 'when the template can be expanded' do
+          let(:client) { instance_double(VCloudSdk::Client) }
+          let(:catalog) { instance_double(VCloudSdk::Catalog) }
+          let(:network_config) { instance_double(VCloudSdk::NetworkConfig) }
+          let(:vapp) { instance_double(VCloudSdk::VApp) }
+          let(:vm) { instance_double(VCloudSdk::VM) }
+
+          before do
+            allow(vcloud_manager).to receive(:system).with("cd #{tmpdir} && tar xfv '#{expanded_vapp_template_path}'").
+                and_return(true)
+          end
+
+          context 'when the vApp can be deployed' do
+            let(:expected_properties) do
+              [
+                {
+                  'type' => 'string',
+                  'key' => 'gateway',
+                  'value' => vapp_config.fetch(:gateway),
+                  'password' => 'false',
+                  'userConfigurable' => 'true',
+                  'Label' => 'Default Gateway',
+                  'Description' => 'The default gateway address for the VM network. Leave blank if DHCP is desired.'
+                },
+                {
+                  'type' => 'string',
+                  'key' => 'DNS',
+                  'value' => vapp_config.fetch(:dns),
+                  'password' => 'false',
+                  'userConfigurable' => 'true',
+                  'Label' => 'DNS',
+                  'Description' => 'The domain name servers for the VM (comma separated). Leave blank if DHCP is desired.',
+                },
+                {
+                  'type' => 'string',
+                  'key' => 'ntp_servers',
+                  'value' => vapp_config.fetch(:ntp),
+                  'password' => 'false',
+                  'userConfigurable' => 'true',
+                  'Label' => 'NTP Servers',
+                  'Description' => 'Comma-delimited list of NTP servers'
+                },
+                {
+                  'type' => 'string',
+                  'key' => 'admin_password',
+                  'value' => 'tempest',
+                  'password' => 'true',
+                  'userConfigurable' => 'true',
+                  'Label' => 'Admin Password',
+                  'Description' => 'This password is used to SSH into the VM. The username is "tempest".',
+                },
+                {
+                  'type' => 'string',
+                  'key' => 'ip0',
+                  'value' => vapp_config.fetch(:ip),
+                  'password' => 'false',
+                  'userConfigurable' => 'true',
+                  'Label' => 'IP Address',
+                  'Description' => 'The IP address for the VM. Leave blank if DHCP is desired.',
+                },
+                {
+                  'type' => 'string',
+                  'key' => 'netmask0',
+                  'value' => vapp_config.fetch(:netmask),
+                  'password' => 'false',
+                  'userConfigurable' => 'true',
+                  'Label' => 'Netmask',
+                  'Description' => 'The netmask for the VM network. Leave blank if DHCP is desired.'
+                }
+              ]
+            end
+
+            before do
+              allow(VCloudSdk::Client).to receive(:new).and_return(client)
+              allow(client).to receive(:catalog_exists?)
+              allow(client).to receive(:delete_catalog_by_name)
+
+              allow(client).to receive(:create_catalog).and_return(catalog)
+              allow(catalog).to receive(:upload_vapp_template)
+              allow(catalog).to receive(:instantiate_vapp_template).and_return(vapp)
+
+              allow(VCloudSdk::NetworkConfig).to receive(:new).and_return(network_config)
+
+              allow(vapp).to receive(:find_vm_by_name).and_return(vm)
+              allow(vm).to receive(:product_section_properties=)
+              allow(vapp).to receive(:power_on)
+            end
+
+            it 'uses VCloudSdk::Client' do
+              expect(VCloudSdk::Client).to receive(:new).with(
+                  login_info.fetch(:url),
+                  [login_info.fetch(:user), login_info.fetch(:organization)].join('@'),
+                  login_info.fetch(:password),
+                  {},
+                  logger,
+                ).and_return(client)
+
+              vcloud_manager.deploy(vapp_template_path, vapp_config)
+            end
+
+            describe 'catalog deletion' do
+              before do
+                allow(client).to receive(:catalog_exists?).and_return(catalog_exists)
+              end
+
+              context 'when the catalog exists' do
+                let(:catalog_exists) { true }
+
+                it 'deletes the catalog' do
+                  expect(client).to receive(:delete_catalog_by_name).with(location.fetch(:catalog))
+
+                  vcloud_manager.deploy(vapp_template_path, vapp_config)
+                end
+              end
+
+              context 'when the catalog does not exist' do
+                let(:catalog_exists) { false }
+
+                it 'does not delete the catalog' do
+                  expect(client).not_to receive(:delete_catalog_by_name).with(location.fetch(:catalog))
+
+                  vcloud_manager.deploy(vapp_template_path, vapp_config)
+                end
+              end
+            end
+
+            it 'creates the catalog' do
+              expect(client).to receive(:create_catalog).with(location.fetch(:catalog)).and_return(catalog)
+
+              vcloud_manager.deploy(vapp_template_path, vapp_config)
+            end
+
+            it 'uploads the vApp template' do
+              expect(catalog).to receive(:upload_vapp_template).with(
+                  location.fetch(:vdc),
+                  vapp_config.fetch(:name),
+                  tmpdir,
+                ).and_return(catalog)
+
+              vcloud_manager.deploy(vapp_template_path, vapp_config)
+            end
+
+            it 'creates a VCloudSdk::NetworkConfig' do
+              expect(VCloudSdk::NetworkConfig).to receive(:new).with(
+                  location.fetch(:network),
+                  'Network 1',
+                ).and_return(network_config)
+
+              vcloud_manager.deploy(vapp_template_path, vapp_config)
+            end
+
+            it 'instantiates the vApp template' do
+              expect(catalog).to receive(:instantiate_vapp_template).with(
+                  vapp_config.fetch(:name),
+                  location.fetch(:vdc),
+                  vapp_config.fetch(:name),
+                  nil,
+                  nil,
+                  network_config
+                ).and_return(vapp)
+
+              vcloud_manager.deploy(vapp_template_path, vapp_config)
+            end
+
+            it 'sets the product section properties' do
+              expect(vm).to receive(:product_section_properties=).with(expected_properties)
+
+              vcloud_manager.deploy(vapp_template_path, vapp_config)
+            end
+
+            it 'powers on the vApp' do
+              expect(vapp).to receive(:power_on)
+
+              vcloud_manager.deploy(vapp_template_path, vapp_config)
+            end
+
+            it 'removes the expanded vApp template' do
+              expect(FileUtils).to receive(:remove_entry_secure).with(tmpdir, force: true)
+
+              vcloud_manager.deploy(vapp_template_path, vapp_config)
+            end
+          end
+
+          context 'when the vApp can NOT be deployed' do
+            it 'removes the expanded vApp template' do
+              expect(FileUtils).to receive(:remove_entry_secure).with(tmpdir, force: true)
+
+              expect { vcloud_manager.deploy(vapp_template_path, vapp_config) }.to raise_error
+            end
+          end
+        end
+
+        context 'when the template can NOT be expanded' do
+          let(:tar_expand_cmd) { "cd #{tmpdir} && tar xfv '#{expanded_vapp_template_path}'" }
+          before do
+            allow(vcloud_manager).to receive(:system).with(tar_expand_cmd).and_return(false)
+          end
+
+          it 'raises an error' do
+            expect { vcloud_manager.deploy(vapp_template_path, vapp_config) }.to raise_error("Error executing: #{tar_expand_cmd.inspect}")
+          end
+
+          it 'removes the expanded vApp template' do
+            expect(FileUtils).to receive(:remove_entry_secure).with(tmpdir, force: true)
+
+            expect { vcloud_manager.deploy(vapp_template_path, vapp_config) }.to raise_error
+          end
+        end
+      end
+
+      context 'when a host exists at the specified IP' do
+        before do
+          allow(vcloud_manager).to receive(:system).with("ping -c 5 #{vapp_config.fetch(:ip)}").and_return(true)
+        end
+
+        it 'raises an error' do
+          expect { vcloud_manager.deploy(vapp_template_path, vapp_config) }.to raise_error("VM exists at #{vapp_config.fetch(:ip)}")
+        end
+
+        it 'removes the expanded vApp template' do
+          expect(FileUtils).to receive(:remove_entry_secure).with(tmpdir, force: true)
+
+          expect { vcloud_manager.deploy(vapp_template_path, vapp_config) }.to raise_error
+        end
+      end
+    end
+    
+    describe '#destroy' do
+      let(:client) { instance_double(VCloudSdk::Client) }
+      let(:vdc) { instance_double(VCloudSdk::VDC) }
+      let(:vapp) { instance_double(VCloudSdk::VApp) }
+      let(:vapp_name) { 'FAKE_VAPP_NAME' }
+
+      context 'when the catalog exists' do
+        before do
+          allow(client).to receive(:catalog_exists?).with(location.fetch(:catalog)).and_return(true)
+        end
+
+        it 'uses VCloudSdk::Client to delete the vApp' do
+          expect(client).to receive(:find_vdc_by_name).with(location.fetch(:vdc)).and_return(vdc)
+          expect(vdc).to receive(:find_vapp_by_name).with(vapp_name).and_return(vapp)
+          expect(vapp).to receive(:power_off)
+          expect(vapp).to receive(:delete)
+          expect(client).to receive(:delete_catalog_by_name).with(location.fetch(:catalog))
+
+          expect(VCloudSdk::Client).to receive(:new).with(
+              login_info.fetch(:url),
+              [login_info.fetch(:user), login_info.fetch(:organization)].join('@'),
+              login_info.fetch(:password),
+              {},
+              logger,
+            ).and_return(client)
+
+          vcloud_manager.destroy(vapp_name)
+        end
+
+        context 'when an VCloudSdk::ObjectNotFoundError is thrown' do
+          before do
+            allow(VCloudSdk::Client).to receive(:new).and_return(client)
+            allow(client).to receive(:find_vdc_by_name).and_return(vdc)
+            allow(vdc).to receive(:find_vapp_by_name).and_return(vapp)
+            allow(vapp).to receive(:power_off)
+            allow(vapp).to receive(:delete)
+
+            allow(client).to receive(:delete_catalog_by_name)
+          end
+
+          it 'catches the error' do
+            allow(client).to receive(:find_vdc_by_name).and_raise(VCloudSdk::ObjectNotFoundError)
+
+            expect { vcloud_manager.destroy(vapp_name) }.not_to raise_error
+          end
+
+          it 'deletes to catalog' do
+            expect(client).to receive(:delete_catalog_by_name).with(location.fetch(:catalog))
+
+            vcloud_manager.destroy(vapp_name)
+          end
+        end
+      end
+
+      context 'when the catalog does not exist' do
+        before do
+          allow(client).to receive(:catalog_exists?).with(location.fetch(:catalog)).and_return(false)
+        end
+
+        it 'uses VCloudSdk::Client to delete the vApp' do
+          expect(client).to receive(:find_vdc_by_name).with(location.fetch(:vdc)).and_return(vdc)
+          expect(vdc).to receive(:find_vapp_by_name).with(vapp_name).and_return(vapp)
+          expect(vapp).to receive(:power_off)
+          expect(vapp).to receive(:delete)
+          expect(client).not_to receive(:delete_catalog_by_name).with(location.fetch(:catalog))
+
+          expect(VCloudSdk::Client).to receive(:new).with(
+              login_info.fetch(:url),
+              [login_info.fetch(:user), login_info.fetch(:organization)].join('@'),
+              login_info.fetch(:password),
+              {},
+              logger,
+            ).and_return(client)
+
+          vcloud_manager.destroy(vapp_name)
+        end
+      end
+    end
+  end
+end