knife-ionoscloud 5.1.2 → 6.0.0.alpha.1

data/spec/chef/knife/ionoscloud_pcc_get_spec.rb

@@ -1,71 +0,0 @@
-require 'spec_helper'
-require 'ionoscloud_pcc_get'
-
-Chef::Knife::IonoscloudPccGet.load_deps
-
-describe Chef::Knife::IonoscloudPccGet do
-  before :each do
-    subject { Chef::Knife::IonoscloudPccGet.new }
-
-    allow(subject).to receive(:puts)
-    allow(subject).to receive(:print)
-  end
-
-  describe '#run' do
-    it 'should call PrivateCrossConnectApi.pccs_find_by_id' do
-      pcc = pcc_mock
-      subject_config = {
-        ionoscloud_username: 'email',
-        ionoscloud_password: 'password',
-        pcc_id: pcc.id,
-        yes: true,
-      }
-
-      subject_config.each { |key, value| subject.config[key] = value }
-
-
-      peers = pcc.properties.peers.map { |peer| peer.id }
-      datacenters = pcc.properties.connectable_datacenters.map { |pcc| pcc.id }
-
-      expect(subject).to receive(:puts).with("ID: #{pcc.id}")
-      expect(subject).to receive(:puts).with("Name: #{pcc.properties.name}")
-      expect(subject).to receive(:puts).with("Description: #{pcc.properties.description}")
-      expect(subject).to receive(:puts).with("Peers: #{peers.to_s}")
-      expect(subject).to receive(:puts).with("Connectable Datacenters: #{datacenters.to_s}")
-
-      expect(subject.api_client).not_to receive(:wait_for)
-      mock_call_api(
-        subject,
-        [
-          {
-            method: 'GET',
-            path: "/pccs/#{pcc.id}",
-            operation: :'PrivateCrossConnectApi.pccs_find_by_id',
-            return_type: 'PrivateCrossConnect',
-            result: pcc,
-          },
-        ],
-      )
-
-      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_pcc_update_spec.rb

@@ -1,83 +0,0 @@
-require 'spec_helper'
-require 'ionoscloud_pcc_update'
-
-Chef::Knife::IonoscloudPccUpdate.load_deps
-
-describe Chef::Knife::IonoscloudPccUpdate do
-  before :each do
-    subject { Chef::Knife::IonoscloudPccUpdate.new }
-
-    allow(subject).to receive(:puts)
-    allow(subject).to receive(:print)
-  end
-
-  describe '#run' do
-    it 'should call PrivateCrossConnectApi.pccs_patch' do
-      pcc = pcc_mock
-      subject_config = {
-        ionoscloud_username: 'email',
-        ionoscloud_password: 'password',
-        pcc_id: pcc.id,
-        name: pcc.properties.name + '_edited',
-        description: pcc.properties.description + '_edited',
-        yes: true,
-      }
-
-      subject_config.each { |key, value| subject.config[key] = value }
-
-      peers = pcc.properties.peers.map { |peer| peer.id }
-      datacenters = pcc.properties.connectable_datacenters.map { |pcc| pcc.id }
-
-      expect(subject).to receive(:puts).with("ID: #{pcc.id}")
-      expect(subject).to receive(:puts).with("Name: #{subject_config[:name]}")
-      expect(subject).to receive(:puts).with("Description: #{subject_config[:description]}")
-      expect(subject).to receive(:puts).with("Peers: #{peers.to_s}")
-      expect(subject).to receive(:puts).with("Connectable Datacenters: #{datacenters.to_s}")
-
-      pcc.properties.name = subject_config[:name]
-      pcc.properties.description = subject_config[:description]
-
-      mock_wait_for(subject)
-      mock_call_api(
-        subject,
-        [
-          {
-            method: 'PATCH',
-            path: "/pccs/#{pcc.id}",
-            operation: :'PrivateCrossConnectApi.pccs_patch',
-            return_type: 'PrivateCrossConnect',
-            body: { name: subject_config[:name], description: subject_config[:description] },
-            result: pcc,
-          },
-          {
-            method: 'GET',
-            path: "/pccs/#{pcc.id}",
-            operation: :'PrivateCrossConnectApi.pccs_find_by_id',
-            return_type: 'PrivateCrossConnect',
-            result: pcc,
-          },
-        ],
-      )
-
-      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_get_spec.rb

@@ -1,69 +0,0 @@
-require 'spec_helper'
-require 'ionoscloud_request_get'
-
-Chef::Knife::IonoscloudRequestGet.load_deps
-
-describe Chef::Knife::IonoscloudRequestGet do
-  before :each do
-    subject { Chef::Knife::IonoscloudRequestGet.new }
-
-    allow(subject).to receive(:puts)
-    allow(subject).to receive(:print)
-  end
-
-  describe '#run' do
-    it 'should call RequestApi.requests_find_by_id' do
-      request = request_mock
-      subject_config = {
-        ionoscloud_username: 'email',
-        ionoscloud_password: 'password',
-        request_id: request.id,
-        yes: true,
-      }
-
-      subject_config.each { |key, value| subject.config[key] = value }
-
-      expect(subject).to receive(:puts).with("ID: #{request.id}")
-      expect(subject).to receive(:puts).with("Status: #{request.metadata.request_status.metadata.status}")
-      expect(subject).to receive(:puts).with("Method: #{request.properties.method}")
-      expect(subject).to receive(:puts).with("URL: #{request.properties.url}")
-      expect(subject).to receive(:puts).with("Targets: #{request.metadata.request_status.metadata.targets.map { |target| [target.target.id, target.target.type] }.to_s}")
-      expect(subject).to receive(:puts).with("Body: #{request.properties.body}")
-      expect(subject).to receive(:puts).with("Headers: #{request.properties.headers}")
-
-      expect(subject.api_client).not_to receive(:wait_for)
-      mock_call_api(
-        subject,
-        [
-          {
-            method: 'GET',
-            path: "/requests/#{request.id}",
-            operation: :'RequestApi.requests_find_by_id',
-            return_type: 'Request',
-            result: request,
-          },
-        ],
-      )
-
-      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_s3key_get_spec.rb

@@ -1,66 +0,0 @@
-require 'spec_helper'
-require 'ionoscloud_s3key_get'
-
-Chef::Knife::IonoscloudS3keyGet.load_deps
-
-describe Chef::Knife::IonoscloudS3keyGet do
-  before :each do
-    subject { Chef::Knife::IonoscloudS3keyGet.new }
-
-    allow(subject).to receive(:puts)
-    allow(subject).to receive(:print)
-  end
-
-  describe '#run' do
-    it 'should call UserManagementApi.um_users_s3keys_find_by_key_id' do
-      s3_key = s3_key_mock
-      subject_config = {
-        ionoscloud_username: 'email',
-        ionoscloud_password: 'password',
-        user_id: 'user_id',
-        s3_key_id: s3_key.id,
-        yes: true,
-      }
-
-      subject_config.each { |key, value| subject.config[key] = value }
-
-      expect(subject).to receive(:puts).with("ID: #{s3_key.id}")
-      expect(subject).to receive(:puts).with("Secret Key: #{s3_key.properties.secret_key}")
-      expect(subject).to receive(:puts).with("Active: #{s3_key.properties.active}")
-
-      expect(subject.api_client).not_to receive(:wait_for)
-      mock_call_api(
-        subject,
-        [
-          {
-            method: 'GET',
-            path: "/um/users/#{subject_config[:user_id]}/s3keys/#{s3_key.id}",
-            operation: :'UserManagementApi.um_users_s3keys_find_by_key_id',
-            return_type: 'S3Key',
-            result: s3_key,
-          },
-        ],
-      )
-
-      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_server_get_spec.rb

@@ -1,71 +0,0 @@
-require 'spec_helper'
-require 'ionoscloud_server_get'
-
-Chef::Knife::IonoscloudServerGet.load_deps
-
-describe Chef::Knife::IonoscloudServerGet do
-  before :each do
-    subject { Chef::Knife::IonoscloudServerGet.new }
-
-    allow(subject).to receive(:puts)
-    allow(subject).to receive(:print)
-  end
-
-  describe '#run' do
-    it 'should call ServerApi.datacenters_servers_find_by_id' do
-      server = server_mock
-      subject_config = {
-        ionoscloud_username: 'email',
-        ionoscloud_password: 'password',
-        datacenter_id: 'datacenter_id',
-        server_id: server.id,
-        yes: true,
-      }
-
-      subject_config.each { |key, value| subject.config[key] = value }
-
-      expect(subject).to receive(:puts).with("ID: #{server.id}")
-      expect(subject).to receive(:puts).with("Name: #{server.properties.name}")
-      expect(subject).to receive(:puts).with("Cores: #{server.properties.cores}")
-      expect(subject).to receive(:puts).with("CPU Family: #{server.properties.cpu_family}")
-      expect(subject).to receive(:puts).with("Ram: #{server.properties.ram}")
-      expect(subject).to receive(:puts).with("Availability Zone: #{server.properties.availability_zone}")
-      expect(subject).to receive(:puts).with("Boot Volume: #{server.properties.boot_volume.id}")
-      expect(subject).to receive(:puts).with("Boot CDROM: #{server.properties.boot_cdrom.id}")
-
-      expect(subject.api_client).not_to receive(:wait_for)
-      mock_call_api(
-        subject,
-        [
-          {
-            method: 'GET',
-            path: "/datacenters/#{subject_config[:datacenter_id]}/servers/#{subject_config[:server_id]}",
-            operation: :'ServerApi.datacenters_servers_find_by_id',
-            return_type: 'Server',
-            result: server,
-          },
-        ],
-      )
-
-      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_server_update_spec.rb

@@ -1,102 +0,0 @@
-require 'spec_helper'
-require 'ionoscloud_server_update'
-
-Chef::Knife::IonoscloudServerUpdate.load_deps
-
-describe Chef::Knife::IonoscloudServerUpdate do
-  before :each do
-    subject { Chef::Knife::IonoscloudServerUpdate.new }
-
-    allow(subject).to receive(:puts)
-    allow(subject).to receive(:print)
-  end
-
-  describe '#run' do
-    it 'should call ServerApi.datacenters_servers_patch' do
-      server = server_mock
-      subject_config = {
-        ionoscloud_username: 'email',
-        ionoscloud_password: 'password',
-        datacenter_id: 'datacenter_id',
-        server_id: server.id,
-        name: server.properties.name + '_edited',
-        cores: server.properties.cores + 1,
-        cpu_family: 'AMD_OPTERON',
-        ram: server.properties.ram * 2,
-        availability_zone: 'AUTO',
-        boot_volume: SecureRandom.uuid,
-        boot_cdrom: SecureRandom.uuid,
-        yes: true,
-      }
-
-      subject_config.each { |key, value| subject.config[key] = value }
-
-      expect(subject).to receive(:puts).with("ID: #{server.id}")
-      expect(subject).to receive(:puts).with("Name: #{subject_config[:name]}")
-      expect(subject).to receive(:puts).with("Cores: #{subject_config[:cores]}")
-      expect(subject).to receive(:puts).with("CPU Family: #{subject_config[:cpu_family]}")
-      expect(subject).to receive(:puts).with("Ram: #{subject_config[:ram]}")
-      expect(subject).to receive(:puts).with("Availability Zone: #{subject_config[:availability_zone]}")
-      expect(subject).to receive(:puts).with("Boot Volume: #{subject_config[:boot_volume]}")
-      expect(subject).to receive(:puts).with("Boot CDROM: #{subject_config[:boot_cdrom]}")
-
-      server.properties.name = subject_config[:name]
-      server.properties.cores = subject_config[:cores]
-      server.properties.cpu_family = subject_config[:cpu_family]
-      server.properties.ram = subject_config[:ram]
-      server.properties.availability_zone = subject_config[:availability_zone]
-      server.properties.boot_volume = Ionoscloud::ResourceReference.new(id: subject_config[:boot_volume])
-      server.properties.boot_cdrom = Ionoscloud::ResourceReference.new(id: subject_config[:boot_cdrom])
-
-      mock_wait_for(subject)
-      mock_call_api(
-        subject,
-        [
-          {
-            method: 'PATCH',
-            path: "/datacenters/#{subject_config[:datacenter_id]}/servers/#{subject_config[:server_id]}",
-            operation: :'ServerApi.datacenters_servers_patch',
-            return_type: 'Server',
-            body: {
-              name: subject_config[:name],
-              cores: subject_config[:cores],
-              cpuFamily: subject_config[:cpu_family],
-              ram: subject_config[:ram],
-              availabilityZone: subject_config[:availability_zone],
-              bootVolume: { id: subject_config[:boot_volume] },
-              bootCdrom: { id: subject_config[:boot_cdrom] },
-            },
-            result: server,
-          },
-          {
-            method: 'GET',
-            path: "/datacenters/#{subject_config[:datacenter_id]}/servers/#{subject_config[:server_id]}",
-            operation: :'ServerApi.datacenters_servers_find_by_id',
-            return_type: 'Server',
-            result: server,
-          },
-        ],
-      )
-
-      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_share_get_spec.rb

@@ -1,66 +0,0 @@
-require 'spec_helper'
-require 'ionoscloud_share_get'
-
-Chef::Knife::IonoscloudShareGet.load_deps
-
-describe Chef::Knife::IonoscloudShareGet do
-  before :each do
-    subject { Chef::Knife::IonoscloudShareGet.new }
-
-    allow(subject).to receive(:puts)
-    allow(subject).to receive(:print)
-  end
-
-  describe '#run' do
-    it 'should call UserManagementApi.um_groups_shares_find_by_resource_id' do
-      share = group_share_mock
-      subject_config = {
-        ionoscloud_username: 'email',
-        ionoscloud_password: 'password',
-        group_id: 'group_id',
-        resource_id: share.id,
-        yes: true,
-      }
-
-      subject_config.each { |key, value| subject.config[key] = value }
-
-      expect(subject).to receive(:puts).with("ID: #{share.id}")
-      expect(subject).to receive(:puts).with("Edit Privilege: #{share.properties.edit_privilege.to_s}")
-      expect(subject).to receive(:puts).with("Share Privilege: #{share.properties.share_privilege.to_s}")
-
-      expect(subject.api_client).not_to receive(:wait_for)
-      mock_call_api(
-        subject,
-        [
-          {
-            method: 'GET',
-            path: "/um/groups/#{subject_config[:group_id]}/shares/#{subject_config[:resource_id]}",
-            operation: :'UserManagementApi.um_groups_shares_find_by_resource_id',
-            return_type: 'GroupShare',
-            result: share,
-          },
-        ],
-      )
-
-      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_share_update_spec.rb

@@ -1,91 +0,0 @@
-require 'spec_helper'
-require 'ionoscloud_share_update'
-
-Chef::Knife::IonoscloudShareUpdate.load_deps
-
-describe Chef::Knife::IonoscloudShareUpdate do
-  before :each do
-    subject { Chef::Knife::IonoscloudShareUpdate.new }
-
-    allow(subject).to receive(:puts)
-    allow(subject).to receive(:print)
-  end
-
-  describe '#run' do
-    it 'should call UserManagementApi.um_groups_shares_patch' do
-      share = group_share_mock
-      subject_config = {
-        ionoscloud_username: 'email',
-        ionoscloud_password: 'password',
-        group_id: 'group_id',
-        resource_id: share.id,
-        share_privilege: (!share.properties.share_privilege).to_s,
-        edit_privilege: (!share.properties.edit_privilege).to_s,
-        yes: true,
-      }
-
-      subject_config.each { |key, value| subject.config[key] = value }
-
-      expect(subject).to receive(:puts).with("ID: #{share.id}")
-      expect(subject).to receive(:puts).with("Edit Privilege: #{subject_config[:edit_privilege]}")
-      expect(subject).to receive(:puts).with("Share Privilege: #{subject_config[:share_privilege]}")
-
-      share.properties.edit_privilege = subject_config[:edit_privilege].to_s.downcase == 'true'
-      share.properties.share_privilege = subject_config[:share_privilege].to_s.downcase == 'true'
-
-      mock_wait_for(subject)
-      mock_call_api(
-        subject,
-        [
-          {
-            method: 'GET',
-            path: "/um/groups/#{subject_config[:group_id]}/shares/#{subject_config[:resource_id]}",
-            operation: :'UserManagementApi.um_groups_shares_find_by_resource_id',
-            return_type: 'GroupShare',
-            result: share,
-          },
-          {
-            method: 'PUT',
-            path: "/um/groups/#{subject_config[:group_id]}/shares/#{subject_config[:resource_id]}",
-            operation: :'UserManagementApi.um_groups_shares_put',
-            return_type: 'GroupShare',
-            body: {
-                properties: {
-                  editPrivilege: subject_config[:edit_privilege].to_s.downcase == 'true',
-                  sharePrivilege: subject_config[:share_privilege].to_s.downcase == 'true',
-              },
-            },
-            result: share,
-          },
-          {
-            method: 'GET',
-            path: "/um/groups/#{subject_config[:group_id]}/shares/#{subject_config[:resource_id]}",
-            operation: :'UserManagementApi.um_groups_shares_find_by_resource_id',
-            return_type: 'GroupShare',
-            result: share,
-          },
-        ],
-      )
-
-      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