knife-vrealize 2.1.1 → 5.0.2

data/spec/unit/vra_catalog_list_spec.rb

@@ -1,44 +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/vra_catalog_list'
-require 'support/shared_examples_for_command'
-
-describe Chef::Knife::Cloud::VraCatalogList do
-  it_behaves_like Chef::Knife::Cloud::Command, Chef::Knife::Cloud::VraCatalogList.new
-
-  subject { described_class.new }
-
-  describe '#format_status_value' do
-    context 'when the status is "published"' do
-      it 'displays with green' do
-        expect(subject.ui).to receive(:color).with('published', :green)
-        subject.format_status_value('published')
-      end
-    end
-
-    context 'when the status it not "published"' do
-      it 'displays with red' do
-        expect(subject.ui).to receive(:color).with('unpublished', :red)
-        subject.format_status_value('unpublished')
-      end
-    end
-  end
-end

data/spec/unit/vra_server_create_spec.rb

@@ -1,171 +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/vra_server_create'
-require 'support/shared_examples_for_command'
-require 'support/shared_examples_for_servercreatecommand'
-
-describe Chef::Knife::Cloud::VraServerCreate do
-  before(:each) do
-    Chef::Config.reset
-  end
-
-  argv = []
-  argv += %w(--cpus 1)
-  argv += %w(--memory 512)
-  argv += %w(--requested-for myuser@corp.local)
-  argv += %w(--bootstrap-protocol ssh)
-  argv += %w(--ssh-password password)
-  argv += %w(--extra-param key1=string:value1)
-  argv += %w(--extra-param key2=integer:2)
-  argv += %w(d5ba201a-449f-47a4-9d02-39196224bf01)
-
-  subject { Chef::Knife::Cloud::VraServerCreate.new(argv) }
-
-  it_behaves_like Chef::Knife::Cloud::Command, Chef::Knife::Cloud::VraServerCreate.new(argv)
-  it_behaves_like Chef::Knife::Cloud::ServerCreateCommand, Chef::Knife::Cloud::VraServerCreate.new(argv)
-
-  describe '#validate_params!' do
-    context 'when no catalog ID is supplied' do
-      it 'raises an error' do
-        argv = []
-        argv += %w(--cpus 1)
-        argv += %w(--memory 512)
-        argv += %w(--requested-for myuser@corp.local)
-        argv += %w(--bootstrap-protocol ssh)
-        argv += %w(--ssh-password password)
-
-        command = Chef::Knife::Cloud::VraServerCreate.new(argv)
-        expect(command.ui).to receive(:error)
-        expect { command.validate_params! }.to raise_error(SystemExit)
-      end
-    end
-
-    it 'validates extra parameters' do
-      expect(subject).to receive(:validate_extra_params!)
-      subject.validate_params!
-    end
-  end
-
-  describe '#extra_params' do
-    context 'when there are no extra params' do
-      before do
-        Chef::Config[:knife][:vra_extra_params] = {}
-      end
-
-      it 'returns nil' do
-        expect(subject.extra_params).to eq(nil)
-      end
-    end
-
-    context 'when extra params are provided' do
-      before do
-        Chef::Config[:knife][:vra_extra_params] = {
-          'key1' => 'string:value1',
-          'key2' => 'integer:2'
-        }
-      end
-
-      it 'parses extra parameters properly' do
-        params = subject.extra_params
-        expect(params[0][:key]).to eq 'key1'
-        expect(params[0][:type]).to eq 'string'
-        expect(params[0][:value]).to eq 'value1'
-        expect(params[1][:key]).to eq 'key2'
-        expect(params[1][:type]).to eq 'integer'
-        expect(params[1][:value]).to eq '2'
-      end
-    end
-  end
-
-  describe '#validate_extra_params!' do
-    context 'when no extra parameters are supplied' do
-      it 'does not raise an exception' do
-        argv = []
-        argv += %w(--cpus 1)
-        argv += %w(--memory 512)
-        argv += %w(--requested-for myuser@corp.local)
-        argv += %w(--bootstrap-protocol ssh)
-        argv += %w(--ssh-password password)
-        command = Chef::Knife::Cloud::VraServerCreate.new(argv)
-
-        expect { command.validate_extra_params! }.not_to raise_error
-      end
-    end
-
-    context 'when correct parameters are supplied' do
-      it 'does not raise an exception' do
-        expect { subject.validate_extra_params! }.not_to raise_error
-      end
-    end
-
-    context 'when a type or value is missing' do
-      it 'raises an exception' do
-        argv = []
-        argv += %w(--cpus 1)
-        argv += %w(--memory 512)
-        argv += %w(--requested-for myuser@corp.local)
-        argv += %w(--bootstrap-protocol ssh)
-        argv += %w(--ssh-password password)
-        argv += %w(d5ba201a-449f-47a4-9d02-39196224bf01)
-        argv += %w(--extra-param key1=value1)
-        command = Chef::Knife::Cloud::VraServerCreate.new(argv)
-
-        expect { command.validate_extra_params! }.to raise_error(ArgumentError)
-      end
-    end
-
-    context 'when an invalid parameter type is provided' do
-      it 'raises an exception' do
-        argv = []
-        argv += %w(--cpus 1)
-        argv += %w(--memory 512)
-        argv += %w(--requested-for myuser@corp.local)
-        argv += %w(--bootstrap-protocol ssh)
-        argv += %w(--ssh-password password)
-        argv += %w(d5ba201a-449f-47a4-9d02-39196224bf01)
-        argv += %w(--extra-param key1=faketype:value1)
-        command = Chef::Knife::Cloud::VraServerCreate.new(argv)
-
-        expect { command.validate_extra_params! }.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  describe '#hostname_for_server' do
-    let(:server)       { double('server') }
-    let(:ip_addresses) { [ '1.2.3.4' ] }
-
-    it 'returns the IP address if it exists' do
-      allow(subject).to receive(:server).and_return(server)
-      allow(server).to receive(:ip_addresses).and_return(ip_addresses)
-
-      expect(subject.hostname_for_server).to eq('1.2.3.4')
-    end
-
-    it 'returns the hostname if the IP address is missing' do
-      allow(subject).to receive(:server).and_return(server)
-      allow(server).to receive(:ip_addresses).and_return([])
-      allow(server).to receive(:name).and_return('test_name')
-
-      expect(subject.hostname_for_server).to eq('test_name')
-    end
-  end
-end

data/spec/unit/vra_server_delete_spec.rb

@@ -1,64 +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/vra_server_delete'
-require 'support/shared_examples_for_command'
-require 'support/shared_examples_for_serverdeletecommand'
-
-describe Chef::Knife::Cloud::VraServerDelete do
-  subject { Chef::Knife::Cloud::VraServerDelete.new(%w(12345 54321)) }
-
-  it_behaves_like Chef::Knife::Cloud::Command, Chef::Knife::Cloud::VraServerDelete.new(%w(12345 54321))
-
-  describe '#validate_params!' do
-    context 'when no resource IDs are supplied' do
-      let(:command) { Chef::Knife::Cloud::VraServerDelete.new }
-      it 'prints an error and exits' do
-        expect(command.ui).to receive(:error)
-        expect { command.validate_params! }.to raise_error(SystemExit)
-      end
-    end
-  end
-
-  describe '#execute_command' do
-    before(:each) do
-      server1 = double('server1', name: 'server1')
-      server2 = double('server2', name: 'server2')
-      allow(subject).to receive_message_chain(:service, :get_server).with('12345').and_return(server1)
-      allow(subject).to receive_message_chain(:service, :get_server).with('54321').and_return(server2)
-    end
-
-    it 'calls delete_server for each server' do
-      allow(subject).to receive(:delete_from_chef).with('server1')
-      allow(subject).to receive(:delete_from_chef).with('server2')
-      expect(subject).to receive_message_chain(:service, :delete_server).with('12345')
-      expect(subject).to receive_message_chain(:service, :delete_server).with('54321')
-      subject.execute_command
-    end
-
-    it 'calls delete_from_chef using the server names for each server' do
-      allow(subject).to receive_message_chain(:service, :delete_server).with('12345')
-      allow(subject).to receive_message_chain(:service, :delete_server).with('54321')
-      expect(subject).to receive(:delete_from_chef).with('server1')
-      expect(subject).to receive(:delete_from_chef).with('server2')
-      subject.execute_command
-    end
-  end
-end

data/spec/unit/vra_server_list_spec.rb

@@ -1,51 +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/vra_server_list'
-require 'support/shared_examples_for_command'
-
-describe Chef::Knife::Cloud::VraServerList do
-  it_behaves_like Chef::Knife::Cloud::Command, Chef::Knife::Cloud::VraServerList.new
-
-  subject { described_class.new }
-
-  describe '#format_status_value' do
-    context 'when the status is "active"' do
-      it 'displays with green' do
-        expect(subject.ui).to receive(:color).with('active', :green)
-        subject.format_status_value('active')
-      end
-    end
-
-    context 'when the status is "deleted"' do
-      it 'displays with red' do
-        expect(subject.ui).to receive(:color).with('deleted', :red)
-        subject.format_status_value('deleted')
-      end
-    end
-
-    context 'when the status is anything else' do
-      it 'displays with yellow' do
-        expect(subject.ui).to receive(:color).with('unknown', :yellow)
-        subject.format_status_value('unknown')
-      end
-    end
-  end
-end

data/spec/unit/vra_server_show_spec.rb

@@ -1,44 +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/vra_server_show'
-require 'support/shared_examples_for_command'
-
-describe Chef::Knife::Cloud::VraServerShow do
-  it_behaves_like Chef::Knife::Cloud::Command, Chef::Knife::Cloud::VraServerShow.new
-
-  describe '#validate_params!' do
-    context 'when no resources are supplied' do
-      let(:command) { Chef::Knife::Cloud::VraServerShow.new }
-      it 'prints an error and exits' do
-        expect(command.ui).to receive(:error)
-        expect { command.validate_params! }.to raise_error(SystemExit)
-      end
-    end
-
-    context 'when more than one resource is supplied' do
-      let(:command) { Chef::Knife::Cloud::VraServerShow.new(%w(12345 54321)) }
-      it 'prints an error and exits' do
-        expect(command.ui).to receive(:error)
-        expect { command.validate_params! }.to raise_error(SystemExit)
-      end
-    end
-  end
-end

data/spec/unit/vro_workflow_execute_spec.rb

@@ -1,366 +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/vro_workflow_execute'
-
-describe Chef::Knife::VroWorkflowExecute do
-  let(:workflow_name)          { 'test workflow' }
-  let(:workflow_id)            { '1d335f85-5328-42fc-a842-a956d1ccdf08' }
-  let(:vro_username)           { 'myuser' }
-  let(:vro_password)           { 'mypassword' }
-  let(:vro_base_url)           { 'https://vro.corp.local' }
-  let(:vro_disable_ssl_verify) { true }
-  let(:key1)                   { 'value1' }
-  let(:key2)                   { '2' }
-
-  let(:argv) do
-    [ workflow_name,
-      "key1=#{key1}",
-      "key2=#{key2}",
-      '--vro-workflow-id', workflow_id]
-  end
-
-  subject { described_class.new(argv) }
-
-  before(:each) do
-    Chef::Config[:knife][:vro_username]           = vro_username
-    Chef::Config[:knife][:vro_password]           = vro_password
-    Chef::Config[:knife][:vro_base_url]           = vro_base_url
-    Chef::Config[:knife][:vro_disable_ssl_verify] = vro_disable_ssl_verify
-  end
-
-  describe '#verify_ssl?' do
-    context 'when vro_disable_ssl_verify is set to true' do
-      let(:vro_disable_ssl_verify) { true }
-      it 'returns false' do
-        expect(subject.verify_ssl?).to eq(false)
-      end
-    end
-
-    context 'when vro_disable_ssl_verify is set to false' do
-      let(:vro_disable_ssl_verify) { false }
-      it 'returns true' do
-        expect(subject.verify_ssl?).to eq(true)
-      end
-    end
-  end
-
-  describe '#vro_config' do
-    it 'creates a config object' do
-      expect(VcoWorkflows::Config).to receive(:new).with(url: vro_base_url,
-                                                         username: vro_username,
-                                                         password: vro_password,
-                                                         verify_ssl: false)
-      subject.vro_config
-    end
-  end
-
-  describe '#vro_client' do
-    it 'creates a client object' do
-      config = double('config')
-      allow(subject).to receive(:vro_config).and_return(config)
-      expect(VcoWorkflows::Workflow).to receive(:new).with(workflow_name,
-                                                           id: workflow_id,
-                                                           config: config)
-
-      subject.set_parameters
-      subject.vro_client
-    end
-  end
-
-  describe '#parse_and_validate_params' do
-    context 'when proper parameters are supplied' do
-      let(:args) { %w(key1=value1 key2=value2) }
-      it 'returns a hash of parameters' do
-        expect(subject.parse_and_validate_params!(args)).to eq('key1' => 'value1',
-                                                               'key2' => 'value2')
-      end
-    end
-
-    context 'when a parameter is malformed' do
-      let(:args) { %w(key1=value1 key2) }
-      it 'raises an exception' do
-        expect { subject.parse_and_validate_params!(args) }.to raise_error(RuntimeError)
-      end
-    end
-  end
-
-  describe 'execute_workflow' do
-    before do
-      config = double('config')
-      client = double('client')
-      allow(subject).to receive(:vro_config).and_return(config)
-      allow(subject).to receive(:vro_client).and_return(client)
-      allow(client).to receive(:parameter)
-      allow(client).to receive(:execute)
-      subject.set_parameters
-    end
-
-    it 'sets the workflow parameters' do
-      expect(subject.vro_client).to receive(:parameter).with('key1', key1)
-      expect(subject.vro_client).to receive(:parameter).with('key2', key2)
-
-      subject.execute_workflow
-    end
-
-    it 'executes the workflow' do
-      expect(subject.vro_client).to receive(:execute)
-      subject.execute_workflow
-    end
-
-    context 'when execute fails with a RestClient::BadRequest' do
-      it 'prints an error with the HTTP response' do
-        HTTPResponse = Struct.new(:code, :to_s)
-        response = HTTPResponse.new(400, 'an HTTP error occurred')
-        exception = RestClient::BadRequest.new
-        exception.response = response
-        allow(subject.vro_client).to receive(:execute).and_raise(exception)
-        expect(subject.ui).to receive(:error).with('The workflow execution request failed: an HTTP error occurred')
-        expect { subject.execute_workflow }.to raise_error(RestClient::BadRequest)
-      end
-    end
-
-    context 'when execute fails with any other exception' do
-      it 'prints an error with the exception message' do
-        allow(subject.vro_client).to receive(:execute).and_raise(RuntimeError, 'a non-HTTP error occurred')
-        expect(subject.ui).to receive(:error).with('The workflow execution request failed: a non-HTTP error occurred')
-        expect { subject.execute_workflow }.to raise_error(RuntimeError)
-      end
-    end
-  end
-
-  describe '#wait_for_workflow' do
-    before(:each) do
-      # don't actually sleep
-      allow(subject).to receive(:sleep)
-    end
-
-    context 'when the requests completes normally, 3 loops' do
-      it 'only fetches the token 3 times' do
-        client = double('client')
-        token  = double('token')
-        allow(subject).to receive(:vro_client).and_return(client)
-        allow(client).to receive(:token).and_return(token)
-        allow(token).to receive(:alive?).exactly(3).times.and_return(true, true, false)
-
-        expect(subject.vro_client).to receive(:token).exactly(3).times
-        subject.wait_for_workflow
-      end
-    end
-
-    context 'when the request is completed on the first loop' do
-      it 'only refreshes the request 1 time' do
-        client = double('client')
-        token  = double('token')
-        allow(subject).to receive(:vro_client).and_return(client)
-        allow(client).to receive(:token).and_return(token)
-        expect(token).to receive(:alive?).once.and_return(false)
-
-        subject.wait_for_workflow
-      end
-    end
-
-    context 'when the timeout is exceeded' do
-      before do
-        Chef::Config[:knife][:request_timeout] = 600
-      end
-      it 'raises a Timeout exception' do
-        allow(Timeout).to receive(:timeout).and_raise(Timeout::Error)
-        expect { subject.wait_for_workflow }.to raise_error(
-          Timeout::Error, 'Workflow did not complete in 600 seconds. ' \
-                          'Please check the vRO UI for more information.' \
-        )
-      end
-    end
-
-    context 'when a non-timeout exception is raised' do
-      it 'raises the original exception' do
-        client = double('client')
-        allow(subject).to receive(:vro_client).and_return(client)
-        allow(client).to receive(:token).and_raise(RuntimeError, 'an error occurred')
-        expect { subject.wait_for_workflow }.to raise_error(RuntimeError, 'an error occurred')
-      end
-    end
-  end
-
-  describe '#missing_config_parameters' do
-    context 'when all parameters are supplied' do
-      it 'returns an empty array' do
-        expect(subject.missing_config_parameters).to eq([])
-      end
-    end
-
-    context 'when a parameter is missing' do
-      before do
-        Chef::Config[:knife][:vro_username] = nil
-      end
-      it 'returns an array with that parameter' do
-        expect(subject.missing_config_parameters).to eq([ :vro_username ])
-      end
-    end
-  end
-
-  describe '#validate!' do
-    context 'when a config parameter is missing' do
-      it 'calls #print_error_and_exit' do
-        allow(subject).to receive(:missing_config_parameters).and_return([ :parameter ])
-        expect(subject).to receive(:print_error_and_exit)
-
-        subject.validate!
-      end
-    end
-
-    context 'when no workflow name is provided' do
-      let(:knife) { Chef::Knife::VroWorkflowExecute.new }
-      it 'calls #print_error_and_exit' do
-        expect(knife).to receive(:print_error_and_exit)
-
-        knife.validate!
-      end
-    end
-  end
-
-  describe '#print_error_and_exit' do
-    it 'prints an error and exits' do
-      expect(subject.ui).to receive(:error).with('an error occurred')
-      expect { subject.print_error_and_exit('an error occurred') }.to raise_error(SystemExit)
-    end
-  end
-
-  describe '#print_results' do
-    it 'prints a blank line and calls the other print methods' do
-      expect(subject.ui).to receive(:msg).with('')
-      expect(subject).to receive(:print_output_parameters)
-      expect(subject).to receive(:print_execution_log)
-
-      subject.print_results
-    end
-  end
-
-  describe '#print_output_parameters' do
-    context 'when there are no output parameters' do
-      before do
-        client = double('client')
-        token  = double('token')
-        allow(subject).to receive(:vro_client).and_return(client)
-        allow(client).to receive(:token).and_return(token)
-        allow(token).to receive(:output_parameters).and_return({})
-      end
-
-      it 'does not print any output' do
-        expect(subject.ui).not_to receive(:msg)
-
-        subject.print_output_parameters
-      end
-    end
-
-    context 'when output parameters exist' do
-      before do
-        client = double('client')
-        token  = double('token')
-        param1 = double('param1', value: 'value1', type: 'string')
-        param2 = double('param2', value: 2.0, type: 'number')
-        allow(subject).to receive(:vro_client).and_return(client)
-        allow(client).to receive(:token).and_return(token)
-        allow(token).to receive(:output_parameters).and_return(
-          'key1' => param1,
-          'key2' => param2
-        )
-
-        # squelch output during testing
-        allow(subject.ui).to receive(:msg)
-        allow(subject).to receive(:msg_pair)
-      end
-
-      it 'prints a header and a blank line' do
-        header = subject.ui.color('Output Parameters:', :bold)
-        expect(subject.ui).to receive(:msg).with(header)
-        expect(subject.ui).to receive(:msg).with('')
-
-        subject.print_output_parameters
-      end
-
-      it 'prints out the output parameters' do
-        expect(subject).to receive(:msg_pair).with('key1', 'value1 (string)')
-        expect(subject).to receive(:msg_pair).with('key2', '2.0 (number)')
-
-        subject.print_output_parameters
-      end
-    end
-  end
-
-  describe '#print_execution_log' do
-    context 'when the log is empty' do
-      before do
-        client = double('client', log: nil)
-        allow(subject).to receive(:vro_client).and_return(client)
-      end
-
-      it 'does not print any information' do
-        expect(subject.ui).not_to receive(:msg)
-
-        subject.print_execution_log
-      end
-    end
-
-    context 'when the log exists' do
-      before do
-        client = double('client', log: 'log entries go here')
-        allow(subject).to receive(:vro_client).and_return(client)
-      end
-
-      it 'prints a header and the log entry' do
-        header = subject.ui.color('Workflow Execution Log:', :bold)
-        expect(subject.ui).to receive(:msg).with(header)
-        expect(subject.ui).to receive(:msg).with('log entries go here')
-
-        subject.print_execution_log
-      end
-    end
-  end
-
-  describe '#set_parameters' do
-    it 'sets the instance variables correctly' do
-      subject.set_parameters
-
-      expect(subject.workflow_name).to eq(workflow_name)
-      expect(subject.workflow_id).to eq(workflow_id)
-      expect(subject.parameters).to eq(
-        'key1' => 'value1',
-        'key2' => '2'
-      )
-    end
-  end
-
-  describe '#run' do
-    it 'calls the correct methods' do
-      expect(subject).to receive(:validate!)
-      expect(subject).to receive(:set_parameters)
-      expect(subject.ui).to receive(:msg).with('Starting workflow execution...')
-      expect(subject).to receive(:execute_workflow).and_return('12345')
-      expect(subject.ui).to receive(:msg).with('Workflow execution 12345 started. Waiting for it to complete...')
-      expect(subject).to receive(:wait_for_workflow)
-      expect(subject.ui).to receive(:msg).with('Workflow execution complete.')
-      expect(subject).to receive(:print_results)
-
-      subject.run
-    end
-  end
-end