knife-vrealize 3.0.0 → 4.0.3

data/Rakefile

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require 'bundler/gem_tasks'
-require 'rspec/core/rake_task'
-require 'rubocop/rake_task'
-
-RSpec::Core::RakeTask.new(:spec)
-RuboCop::RakeTask.new(:style)
-
-begin
-  require 'github_changelog_generator/task'
-
-  GitHubChangelogGenerator::RakeTask.new :changelog do |config|
-    config.future_release = KnifeVrealize::VERSION
-    config.issues = true
-  end
-rescue LoadError
-  puts 'github_changelog_generator is not available. gem install github_changelog_generator to generate changelogs'
-end
-
-task default: %i[spec style]

data/knife-vrealize.gemspec

@@ -1,34 +0,0 @@
-# coding: utf-8
-# frozen_string_literal: true
-
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-
-require 'knife-vrealize/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = 'knife-vrealize'
-  spec.version       = KnifeVrealize::VERSION
-  spec.authors       = ['Chef Partner Engineering']
-  spec.email         = ['partnereng@chef.io']
-  spec.summary       = 'Knife plugin to interact with VMware vRealize.'
-  spec.description   = spec.summary
-  spec.homepage      = 'https://github.com/chef-partners/knife-vrealize'
-  spec.license       = 'Apache 2.0'
-
-  spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ['lib']
-
-  spec.add_dependency 'cookstyle'
-  spec.add_dependency 'knife-cloud',  '~> 1.2.0'
-  spec.add_dependency 'vmware-vra',   '~> 2'
-  spec.add_dependency 'vcoworkflows', '~> 0.2'
-  spec.add_dependency 'rb-readline', '~> 0.5'
-
-  spec.add_development_dependency 'bundler', '~> 1.7'
-  spec.add_development_dependency 'github_changelog_generator'
-  spec.add_development_dependency 'rake',    '~> 10.0'
-  spec.add_development_dependency 'rubocop', '~> 0.35'
-end

data/spec/spec_helper.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-#
-# Author:: Chef Partner Engineering (<partnereng@chef.io>)
-# Copyright:: Copyright (c) 2015 Chef Software, Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#

data/spec/unit/cloud/vra_service_helpers_spec.rb

@@ -1,153 +0,0 @@
-# frozen_string_literal: true
-#
-# Author:: Chef Partner Engineering (<partnereng@chef.io>)
-# Copyright:: Copyright (c) 2015 Chef Software, Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require 'spec_helper'
-require 'chef/knife'
-require 'chef/knife/cloud/vra_service'
-require 'chef/knife/cloud/vra_service_helpers'
-
-class HelpersTester
-  include Chef::Knife::Cloud::VraServiceHelpers
-  attr_accessor :ui
-end
-
-describe 'Chef::Knife::Cloud::VraServiceHelpers' do
-  subject { HelpersTester.new }
-
-  before(:each) do
-    subject.ui = Chef::Knife::UI.new(STDOUT, STDERR, STDIN, {})
-  end
-
-  describe '#create_service_instance' do
-    it 'creates a service instance' do
-      allow(subject).to receive(:locate_config_value).with(:vra_username).and_return('myuser')
-      allow(subject).to receive(:locate_config_value).with(:vra_password).and_return('mypassword')
-      allow(subject).to receive(:locate_config_value).with(:vra_base_url).and_return('https://vra.corp.local')
-      allow(subject).to receive(:locate_config_value).with(:vra_tenant).and_return('mytenant')
-      allow(subject).to receive(:locate_config_value).with(:vra_page_size).and_return(50)
-      allow(subject).to receive(:locate_config_value).with(:vra_disable_ssl_verify).and_return(false)
-
-      expect(Chef::Knife::Cloud::VraService).to receive(:new)
-        .with(username:   'myuser',
-              password:   'mypassword',
-              base_url:   'https://vra.corp.local',
-              tenant:     'mytenant',
-              page_size:  50,
-              verify_ssl: true)
-
-      subject.create_service_instance
-    end
-  end
-
-  describe '#verify_ssl?' do
-    context 'when vra_disable_ssl_verify is true' do
-      it 'returns false' do
-        allow(subject).to receive(:locate_config_value).with(:vra_disable_ssl_verify).and_return(true)
-        expect(subject.verify_ssl?).to be false
-      end
-    end
-
-    context 'when vra_disable_ssl_verify is false' do
-      it 'returns true' do
-        allow(subject).to receive(:locate_config_value).with(:vra_disable_ssl_verify).and_return(false)
-        expect(subject.verify_ssl?).to be true
-      end
-    end
-  end
-
-  describe '#wait_for_request' do
-    before(:each) do
-      # muffle any stdout output from this method
-      allow(subject).to receive(:print)
-
-      # don't actually sleep
-      allow(subject).to receive(:sleep)
-    end
-
-    context 'when the requests completes normally, 3 loops' do
-      it 'only refreshes the request 3 times' do
-        request = double('request')
-        allow(request).to receive(:status)
-        allow(request).to receive(:completed?).exactly(3).times.and_return(false, false, true)
-        expect(request).to receive(:refresh).exactly(3).times
-
-        subject.wait_for_request(request)
-      end
-    end
-
-    context 'when the request is completed on the first loop' do
-      it 'only refreshes the request 1 time' do
-        request = double('request')
-        allow(request).to receive(:status)
-        allow(request).to receive(:completed?).once.and_return(true)
-        expect(request).to receive(:refresh).once
-
-        subject.wait_for_request(request)
-      end
-    end
-
-    context 'when the timeout is exceeded' do
-      it 'prints a warning and exits' do
-        request = double('request')
-        allow(Timeout).to receive(:timeout).and_raise(Timeout::Error)
-        expect(subject.ui).to receive(:msg).with('')
-        expect(subject.ui).to receive(:error)
-          .with('Request did not complete in 600 seconds. Check the Requests tab in the vRA UI for more information.')
-        expect { subject.wait_for_request(request) }.to raise_error(SystemExit)
-      end
-    end
-
-    context 'when a non-timeout exception is raised' do
-      it 'raises the original exception' do
-        request = double('request')
-        allow(request).to receive(:refresh).and_raise(RuntimeError)
-        expect { subject.wait_for_request(request) }.to raise_error(RuntimeError)
-      end
-    end
-  end
-
-  describe '#validate!' do
-    it 'calls checks for empty VRA connection configuration values' do
-      expect(subject).to receive(:check_for_missing_config_values!)
-        .with(:vra_username, :vra_password, :vra_base_url, :vra_tenant)
-
-      subject.validate!
-    end
-  end
-
-  describe '#check_for_missing_config_values!' do
-    context 'when all values exist' do
-      it 'does not raise an error' do
-        allow(subject).to receive(:locate_config_value).with(:key1).and_return('value')
-        allow(subject).to receive(:locate_config_value).with(:key2).and_return('value')
-        expect(subject.ui).not_to receive(:error)
-        expect { subject.check_for_missing_config_values!(:key1, :key2) }.not_to raise_error
-      end
-    end
-
-    context 'when a value does not exist' do
-      it 'prints an error and exits' do
-        allow(subject).to receive(:locate_config_value).with(:key1).and_return('value')
-        allow(subject).to receive(:locate_config_value).with(:key2).and_return(nil)
-        expect(subject.ui).to receive(:error)
-        expect { subject.check_for_missing_config_values!(:key1, :key2) }.to raise_error(SystemExit)
-      end
-    end
-  end
-end

data/spec/unit/cloud/vra_service_spec.rb

@@ -1,251 +0,0 @@
-# frozen_string_literal: true
-#
-# Author:: Chef Partner Engineering (<partnereng@chef.io>)
-# Copyright:: Copyright (c) 2015 Chef Software, Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require 'spec_helper'
-require 'chef/knife/cloud/exceptions'
-require 'chef/knife/cloud/vra_service'
-require 'support/shared_examples_for_service'
-
-describe Chef::Knife::Cloud::VraService do
-  subject do
-    Chef::Knife::Cloud::VraService.new(username:   'myuser',
-                                       password:   'mypassword',
-                                       base_url:   'https://vra.corp.local',
-                                       tenant:     'mytenant',
-                                       verify_ssl: true)
-  end
-
-  before(:each) do
-    subject.ui = Chef::Knife::UI.new(STDOUT, STDERR, STDIN, {})
-    allow(subject.ui).to receive(:msg).with('')
-  end
-
-  describe '#connection' do
-    it 'creates a Vra::Client object' do
-      expect(subject.connection).to be_an_instance_of(Vra::Client)
-    end
-  end
-
-  describe '#create_server' do
-    before(:each) do
-      allow(subject.ui).to receive(:msg).with('Catalog request 1 submitted.')
-      allow(subject.ui).to receive(:msg).with("Catalog request complete.\n")
-    end
-
-    context 'when the request is successful' do
-      it 'calls all the appropriate methods' do
-        submitted_request = double('submitted_request', id: 1, failed?: false)
-        resource = double('resource', vm?: true)
-        allow(submitted_request).to receive(:resources).and_return([resource])
-        expect(subject).to receive_message_chain(:catalog_request, :submit).and_return(submitted_request)
-        expect(subject).to receive(:wait_for_request)
-        expect(subject).to receive(:request_summary)
-
-        server = subject.create_server
-        expect(server).to eq resource
-      end
-    end
-
-    context 'when the request failed' do
-      it 'raises an exception' do
-        submitted_request = double('submitted_request', id: 1, failed?: true, completion_details: 'it failed')
-        expect(subject).to receive_message_chain(:catalog_request, :submit).and_return(submitted_request)
-        expect(subject).to receive(:wait_for_request)
-        expect(subject).to receive(:request_summary)
-
-        expect { subject.create_server }.to raise_error(Chef::Knife::Cloud::CloudExceptions::ServerCreateError)
-      end
-    end
-
-    context 'when the request returns no resources' do
-      it 'raises an exception' do
-        submitted_request = double('submitted_request', id: 1, failed?: false)
-        allow(submitted_request).to receive(:resources).and_return([])
-        expect(subject).to receive_message_chain(:catalog_request, :submit).and_return(submitted_request)
-        expect(subject).to receive(:wait_for_request)
-        expect(subject).to receive(:request_summary)
-
-        expect { subject.create_server }.to raise_error(Chef::Knife::Cloud::CloudExceptions::ServerCreateError)
-      end
-    end
-
-    context 'when the request returns more than one VM resource' do
-      it 'raises an exception' do
-        submitted_request = double('submitted_request', id: 1, failed?: false)
-        resource1 = double('resource1', vm?: true)
-        resource2 = double('resource2', vm?: true)
-        allow(submitted_request).to receive(:resources).and_return([resource1, resource2])
-        expect(subject).to receive_message_chain(:catalog_request, :submit).and_return(submitted_request)
-        expect(subject).to receive(:wait_for_request)
-        expect(subject).to receive(:request_summary)
-
-        expect { subject.create_server }.to raise_error(Chef::Knife::Cloud::CloudExceptions::ServerCreateError)
-      end
-    end
-
-    context 'when the request returns multiple resources, but only 1 VM' do
-      it 'happily returns the server resource' do
-        submitted_request = double('submitted_request', id: 1, failed?: false)
-        resource1 = double('resource1', vm?: true)
-        resource2 = double('resource2', vm?: false)
-        allow(submitted_request).to receive(:resources).and_return([resource1, resource2])
-        expect(subject).to receive_message_chain(:catalog_request, :submit).and_return(submitted_request)
-        expect(subject).to receive(:wait_for_request)
-        expect(subject).to receive(:request_summary)
-
-        server = subject.create_server
-        expect(server).to eq resource1
-      end
-    end
-  end
-
-  describe '#delete_server' do
-    context 'when the server exists' do
-      it 'calls the appropriate methods' do
-        server = double('server', status: 'ACTIVE')
-        destroy_request = double('destroy_request', id: 1)
-        expect(subject).to receive(:get_server).with('12345').and_return(server)
-        expect(subject).to receive(:server_summary).with(server)
-        expect(subject.ui).to receive(:confirm)
-        expect(server).to receive(:destroy).and_return(destroy_request)
-        expect(subject.ui).to receive(:msg).with('Destroy request 1 submitted.')
-        expect(subject).to receive(:wait_for_request)
-        expect(subject.ui).to receive(:msg).with('Destroy request complete.')
-        expect(subject).to receive(:request_summary)
-
-        subject.delete_server('12345')
-      end
-    end
-
-    context 'when the server is already deleted' do
-      it 'does not call #destroy on the server object' do
-        server = double('server', status: 'DELETED')
-        expect(subject).to receive(:get_server).with('12345').and_return(server)
-        expect(subject).to receive(:server_summary).with(server)
-        expect(subject.ui).to receive(:warn).with("Server is already deleted.\n")
-        expect(server).not_to receive(:destroy)
-
-        subject.delete_server('12345')
-      end
-    end
-  end
-
-  describe '#list_servers' do
-    it 'calls all_resources' do
-      expect(subject).to receive_message_chain(:connection, :resources, :all_resources)
-        .and_return([])
-
-      subject.list_servers
-    end
-  end
-
-  describe '#list_catalog_items' do
-    context 'when requesting entitled items only' do
-      it 'calls entitled_items' do
-        expect(subject).to receive_message_chain(:connection, :catalog, :entitled_items)
-
-        subject.list_catalog_items(true)
-      end
-    end
-
-    context 'when requesting all items' do
-      it 'calls all_items' do
-        expect(subject).to receive_message_chain(:connection, :catalog, :all_items)
-
-        subject.list_catalog_items(false)
-      end
-    end
-  end
-
-  describe '#get_server' do
-    it 'calls resources.by_id' do
-      expect(subject).to receive_message_chain(:connection, :resources, :by_id).with('12345')
-
-      subject.get_server('12345')
-    end
-  end
-
-  describe '#catalog_request' do
-    context 'when handling a proper request' do
-      it 'calls the appropriate methods' do
-        catalog_request = double('catalog_request')
-        expect(catalog_request).to receive(:cpus=).with(1)
-        expect(catalog_request).to receive(:memory=).with(512)
-        expect(catalog_request).to receive(:requested_for=).with('myuser@corp.local')
-        expect(catalog_request).to receive(:lease_days=).with(5)
-        expect(catalog_request).to receive(:notes=).with('my notes')
-        expect(catalog_request).to receive(:subtenant_id=).with('tenant1')
-        expect(subject).to receive_message_chain(:connection, :catalog, :request)
-          .with('12345')
-          .and_return(catalog_request)
-
-        subject.catalog_request(catalog_id: '12345',
-                                cpus: 1,
-                                memory: 512,
-                                requested_for: 'myuser@corp.local',
-                                lease_days: 5,
-                                notes: 'my notes',
-                                subtenant_id: 'tenant1')
-      end
-    end
-
-    context 'when optional arguments are missing' do
-      it 'does not call the attr setters for the missing attributes' do
-        catalog_request = double('catalog_request')
-        expect(catalog_request).to receive(:cpus=).with(1)
-        expect(catalog_request).to receive(:memory=).with(512)
-        expect(catalog_request).to receive(:requested_for=).with('myuser@corp.local')
-        expect(catalog_request).to_not receive(:lease_days=)
-        expect(catalog_request).to_not receive(:notes=)
-        expect(catalog_request).to_not receive(:subtenant_id=)
-        expect(subject).to receive_message_chain(:connection, :catalog, :request)
-          .with('12345')
-          .and_return(catalog_request)
-
-        subject.catalog_request(catalog_id: '12345',
-                                cpus: 1,
-                                memory: 512,
-                                requested_for: 'myuser@corp.local')
-      end
-    end
-
-    context 'when extra parameters are supplied' do
-      it 'calls set_parameter on the catalog_request' do
-        catalog_request = double('catalog_request')
-        expect(catalog_request).to receive(:cpus=).with(1)
-        expect(catalog_request).to receive(:memory=).with(512)
-        expect(catalog_request).to receive(:requested_for=).with('myuser@corp.local')
-        expect(catalog_request).to receive(:set_parameter).with('key1', 'string', 'value1')
-        expect(catalog_request).to receive(:set_parameter).with('key2', 'integer', '2')
-        expect(subject).to receive_message_chain(:connection, :catalog, :request)
-          .with('12345')
-          .and_return(catalog_request)
-
-        subject.catalog_request(catalog_id: '12345',
-                                cpus: 1,
-                                memory: 512,
-                                requested_for: 'myuser@corp.local',
-                                extra_params: [
-                                  { key: 'key1', type: 'string', value: 'value1' },
-                                  { key: 'key2', type: 'integer', value: '2' }
-                                ])
-      end
-    end
-  end
-end