knife-ionoscloud 5.0.0.beta.1

data/spec/chef/knife/ionoscloud_pcc_list_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+require 'ionoscloud_pcc_list'
+
+Chef::Knife::IonoscloudPccList.load_deps
+
+describe Chef::Knife::IonoscloudPccList do
+  before :each do
+    subject { Chef::Knife::IonoscloudPccList.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call PrivateCrossConnectApi.pccs_get' do
+      pccs = pccs_mock
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      pcc_list = [
+        subject.ui.color('ID', :bold),
+        subject.ui.color('Name', :bold),
+        subject.ui.color('Description', :bold),
+        pccs.items.first.id,
+        pccs.items.first.properties.name,
+        pccs.items.first.properties.description || '',
+      ]
+
+      expect(subject.ui).to receive(:list).with(pcc_list, :uneven_columns_across, 3)
+
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: '/pccs',
+            operation: :'PrivateCrossConnectApi.pccs_get',
+            return_type: 'PrivateCrossConnects',
+            result: pccs,
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should not make any call if any required option is missing' do
+      required_options = subject.instance_variable_get(:@required_options)
+
+      arrays_without_one_element(required_options).each do |test_case|
+
+        test_case[:array].each { |value| subject.config[value] = 'test' }
+
+        expect(subject).to receive(:puts).with("Missing required parameters #{test_case[:removed]}")
+        expect(subject.api_client).not_to receive(:call_api)
+
+        expect { subject.run }.to raise_error(SystemExit) do |error|
+          expect(error.status).to eq(1)
+        end
+
+        required_options.each { |value| subject.config[value] = nil }
+      end
+    end
+  end
+end

data/spec/chef/knife/ionoscloud_request_list_spec.rb

@@ -0,0 +1,165 @@
+require 'spec_helper'
+require 'ionoscloud_request_list'
+
+Chef::Knife::IonoscloudRequestList.load_deps
+
+describe Chef::Knife::IonoscloudRequestList do
+  before :each do
+    subject { Chef::Knife::IonoscloudRequestList.new }
+
+    @requests = requests_mock
+    @request_list = request_list = [
+      subject.ui.color('ID', :bold),
+      subject.ui.color('Status', :bold),
+      subject.ui.color('Method', :bold),
+      subject.ui.color('Targets', :bold),
+    ]
+
+    @requests.items.each do |request|
+      @request_list << request.id
+      @request_list << request.metadata.request_status.metadata.status
+      @request_list << request.properties.method
+      @request_list << request.metadata.request_status.metadata.targets.map { |target| [target.target.id, target.target.type] }.to_s
+
+    end
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call RequestApi.resources_get with default options when nothing is set' do
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      expect(subject.ui).to receive(:list).with(@request_list, :uneven_columns_across, 4)
+
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: '/requests',
+            operation: :'RequestApi.requests_get',
+            options: { depth: 2, limit: 20, offset: 0 },
+            return_type: 'Requests',
+            result: @requests,
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should call RequestApi.resources_get with set options if present' do
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        offset: 3,
+        limit: 6,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      expect(subject.ui).to receive(:list).with(@request_list, :uneven_columns_across, 4)
+
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: '/requests',
+            operation: :'RequestApi.requests_get',
+            options: { depth: 2, limit: subject_config[:limit], offset: subject_config[:offset] },
+            return_type: 'Requests',
+            result: @requests,
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should call RequestApi.resources_get with default limit if it is not an Integers' do
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        limit: 'invalid',
+        offset: 3,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      expect(subject.ui).to receive(:list).with(@request_list, :uneven_columns_across, 4)
+      expect(subject.ui).to receive(:warn).with('limit should be an Integer!')
+
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: '/requests',
+            operation: :'RequestApi.requests_get',
+            options: { depth: 2, limit: 20, offset: subject_config[:offset] },
+            return_type: 'Requests',
+            result: @requests,
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should call RequestApi.resources_get with default offset if it is not an Integers' do
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        offset: 'invalid',
+        limit: 12,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      expect(subject.ui).to receive(:list).with(@request_list, :uneven_columns_across, 4)
+      expect(subject.ui).to receive(:warn).with('offset should be an Integer!')
+
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: '/requests',
+            operation: :'RequestApi.requests_get',
+            options: { depth: 2, limit: subject_config[:limit], offset: 0 },
+            return_type: 'Requests',
+            result: @requests,
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should not make any call if any required option is missing' do
+      required_options = subject.instance_variable_get(:@required_options)
+
+      arrays_without_one_element(required_options).each do |test_case|
+
+        test_case[:array].each { |value| subject.config[value] = 'test' }
+
+        expect(subject).to receive(:puts).with("Missing required parameters #{test_case[:removed]}")
+        expect(subject.api_client).not_to receive(:call_api)
+
+        expect { subject.run }.to raise_error(SystemExit) do |error|
+          expect(error.status).to eq(1)
+        end
+
+        required_options.each { |value| subject.config[value] = nil }
+      end
+    end
+  end
+end

data/spec/chef/knife/ionoscloud_request_status_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+require 'ionoscloud_request_status'
+
+Chef::Knife::IonoscloudRequestStatus.load_deps
+
+describe Chef::Knife::IonoscloudRequestStatus do
+  subject { Chef::Knife::IonoscloudRequestStatus.new }
+
+  describe '#run' do
+    it 'should call RequestApi.requests_status_get and output the received status when the request ID is valid' do
+      request_status = request_status_mock
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        request_id: 'request_id',
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      allow(subject).to receive(:puts)
+
+      expect(subject.api_client).not_to receive(:wait_for)
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: "/requests/#{subject_config[:request_id]}/status",
+            operation: :'RequestApi.requests_status_get',
+            return_type: 'RequestStatus',
+            result: request_status,
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should output an error is the request is not found' do
+      request_id = 'invalid_id'
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        request_id: request_id,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      allow(subject).to receive(:puts)
+      allow(subject).to receive(:print)
+
+      expect(subject.ui).to receive(:error).with("Request ID #{request_id} not found.")
+
+      expect(subject.api_client).not_to receive(:wait_for)
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: "/requests/#{request_id}/status",
+            operation: :'RequestApi.requests_status_get',
+            return_type: 'RequestStatus',
+            exception: Ionoscloud::ApiError.new(code: 404),
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should not make any call if any required option is missing' do
+      required_options = subject.instance_variable_get(:@required_options)
+      allow(subject).to receive(:puts)
+      allow(subject).to receive(:print)
+
+      arrays_without_one_element(required_options).each {
+        |test_case|
+
+        test_case[:array].each { |value| subject.config[value] = 'test' }
+
+        expect(subject).to receive(:puts).with("Missing required parameters #{test_case[:removed]}")
+        expect(subject.api_client).not_to receive(:call_api)
+
+        expect { subject.run }.to raise_error(SystemExit) do |error|
+          expect(error.status).to eq(1)
+        end
+
+        required_options.each { |value| subject.config[value] = nil }
+      }
+    end
+  end
+end

data/spec/chef/knife/ionoscloud_request_wait_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+require 'ionoscloud_request_wait'
+
+Chef::Knife::IonoscloudRequestWait.load_deps
+
+describe Chef::Knife::IonoscloudRequestWait do
+  subject { Chef::Knife::IonoscloudRequestWait.new }
+
+  describe '#run' do
+    it 'should call api_client.wait_for' do
+      request_status = request_status_mock
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        request_id: 'request_id',
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      allow(subject).to receive(:puts)
+      allow(subject).to receive(:print)
+
+      expect(subject).to receive(:is_done?).once do |arg|
+        expect(arg).to eql(subject_config[:request_id])
+        true
+      end
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should output an error is the request is not found' do
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        request_id: 'request_id',
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      allow(subject).to receive(:puts)
+      allow(subject).to receive(:print)
+
+      expect(subject.ui).to receive(:error).with("Request ID #{subject_config[:request_id]} not found.")
+
+      expect(subject).to receive(:is_done?).once do |arg|
+        expect(arg).to eql(subject_config[:request_id])
+        raise Ionoscloud::ApiError.new(code: 404)
+      end
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should not make any call if any required option is missing' do
+      required_options = subject.instance_variable_get(:@required_options)
+      allow(subject).to receive(:puts)
+      allow(subject).to receive(:print)
+
+      arrays_without_one_element(required_options).each {
+        |test_case|
+
+        test_case[:array].each { |value| subject.config[value] = 'test' }
+
+        expect(subject).to receive(:puts).with("Missing required parameters #{test_case[:removed]}")
+        expect(subject.api_client).not_to receive(:call_api)
+
+        expect { subject.run }.to raise_error(SystemExit) do |error|
+          expect(error.status).to eq(1)
+        end
+
+        required_options.each { |value| subject.config[value] = nil }
+      }
+    end
+  end
+end

data/spec/chef/knife/ionoscloud_resource_list_spec.rb

@@ -0,0 +1,155 @@
+require 'spec_helper'
+require 'ionoscloud_resource_list'
+
+
+Chef::Knife::IonoscloudResourceList.load_deps
+
+describe Chef::Knife::IonoscloudResourceList do
+
+  before :each do
+    subject { Chef::Knife::IonoscloudResourceList.new }
+
+    @resources = resources_mock
+
+    @resource_list = [
+      subject.ui.color('ID', :bold),
+      subject.ui.color('Type', :bold),
+      subject.ui.color('Name', :bold),
+      @resources.items.first.id,
+      @resources.items.first.type,
+      @resources.items.first.properties.name,
+    ]
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call UserManagementApi.um_resources_find_by_type_and_id when resource_type and resource_id is set' do
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        resource_type: 'resource_type',
+        resource_id: 'resource_id',
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      expect(subject.ui).to receive(:list).with(@resource_list, :uneven_columns_across, 3)
+
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: "/um/resources/#{subject_config[:resource_type]}/#{subject_config[:resource_id]}",
+            operation: :'UserManagementApi.um_resources_find_by_type_and_id',
+            return_type: 'Resource',
+            result: @resources,
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should call UserManagementApi.um_resources_find_by_type when only resource_type is set' do
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        resource_type: 'resource_type',
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      expect(subject.ui).to receive(:list).with(@resource_list, :uneven_columns_across, 3)
+
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: "/um/resources/#{subject_config[:resource_type]}",
+            operation: :'UserManagementApi.um_resources_find_by_type',
+            return_type: 'Resources',
+            result: @resources,
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should call UserManagementApi.um_resources_get when neither resource_type not resource_id are set' do
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      expect(subject.ui).to receive(:list).with(@resource_list, :uneven_columns_across, 3)
+
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: '/um/resources',
+            operation: :'UserManagementApi.um_resources_get',
+            return_type: 'Resources',
+            result: @resources,
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should call UserManagementApi.um_resources_get when only resource_id is set and warn the user' do
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        resource_id: 'resource_id'
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      expect(subject.ui).to receive(:list).with(@resource_list, :uneven_columns_across, 3)
+      expect(subject.ui).to receive(:warn).with('Ignoring resource_id because no resource_type was specified.')
+
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: '/um/resources',
+            operation: :'UserManagementApi.um_resources_get',
+            return_type: 'Resources',
+            result: @resources,
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should not make any call if any required option is missing' do
+      required_options = subject.instance_variable_get(:@required_options)
+
+      arrays_without_one_element(required_options).each do |test_case|
+
+        test_case[:array].each { |value| subject.config[value] = 'test' }
+
+        expect(subject).to receive(:puts).with("Missing required parameters #{test_case[:removed]}")
+        expect(subject.api_client).not_to receive(:call_api)
+
+        expect { subject.run }.to raise_error(SystemExit) do |error|
+          expect(error.status).to eq(1)
+        end
+
+        required_options.each { |value| subject.config[value] = nil }
+      end
+    end
+  end
+end