knife-ionoscloud 5.1.2 → 6.0.0.alpha.1

data/spec/chef/knife/ionoscloud_lan_update_spec.rb

@@ -1,91 +0,0 @@
-require 'spec_helper'
-require 'ionoscloud_lan_update'
-
-Chef::Knife::IonoscloudLanUpdate.load_deps
-
-describe Chef::Knife::IonoscloudLanUpdate do
-  before :each do
-    subject { Chef::Knife::IonoscloudLanUpdate.new }
-
-    allow(subject).to receive(:puts)
-    allow(subject).to receive(:print)
-  end
-
-  describe '#run' do
-    it 'should call LanApi.datacenters_lans_patch' do
-      lan = lan_mock
-      uuid = SecureRandom.uuid
-      subject_config = {
-        ionoscloud_username: 'email',
-        ionoscloud_password: 'password',
-        datacenter_id: 'datacenter_id',
-        lan_id: lan.id,
-        name: lan.properties.name + '_edited',
-        public: (!lan.properties.public).to_s,
-        ip_failover: [{ 'ip' => '1.1.1.1', 'nic_uuid' => uuid }],
-        pcc: 'pcc_id',
-        yes: true,
-      }
-
-      subject_config.each { |key, value| subject.config[key] = value }
-
-      expect(subject).to receive(:puts).with("ID: #{lan.id}")
-      expect(subject).to receive(:puts).with("Name: #{subject_config[:name]}")
-      expect(subject).to receive(:puts).with("Public: #{subject_config[:public]}")
-      expect(subject).to receive(:puts).with("PCC: #{subject_config[:pcc]}")
-      expect(subject).to receive(:puts).with("IP Failover: #{[{ ip: '1.1.1.1', nicUuid: uuid }]}")
-
-      lan.properties.name = subject_config[:name]
-      lan.properties.public = subject_config[:public].to_s.downcase == 'true'
-      lan.properties.pcc = subject_config[:pcc]
-      lan.properties.ip_failover = [Ionoscloud::IPFailover.new(ip: '1.1.1.1', nic_uuid: uuid)]
-
-      mock_wait_for(subject)
-      mock_call_api(
-        subject,
-        [
-          {
-            method: 'PATCH',
-            path: "/datacenters/#{subject_config[:datacenter_id]}/lans/#{subject_config[:lan_id]}",
-            operation: :'LanApi.datacenters_lans_patch',
-            return_type: 'Lan',
-            body: {
-              name: subject_config[:name],
-              public: subject_config[:public].to_s.downcase == 'true',
-              pcc: subject_config[:pcc],
-              ipFailover: [{ ip: '1.1.1.1', nicUuid: uuid }],
-            },
-            result: lan,
-          },
-          {
-            method: 'GET',
-            path: "/datacenters/#{subject_config[:datacenter_id]}/lans/#{subject_config[:lan_id]}",
-            operation: :'LanApi.datacenters_lans_find_by_id',
-            return_type: 'Lan',
-            result: lan,
-          },
-        ],
-      )
-
-      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_loadbalancer_update_spec.rb

@@ -1,89 +0,0 @@
-require 'spec_helper'
-require 'ionoscloud_loadbalancer_update'
-
-Chef::Knife::IonoscloudLoadbalancerUpdate.load_deps
-
-describe Chef::Knife::IonoscloudLoadbalancerUpdate do
-  before :each do
-    subject { Chef::Knife::IonoscloudLoadbalancerUpdate.new }
-
-    allow(subject).to receive(:puts)
-    allow(subject).to receive(:print)
-  end
-
-  describe '#run' do
-    it 'should call LoadBalancerApi.datacenters_loadbalancers_patch' do
-      load_balancer = load_balancer_mock
-      subject_config = {
-        ionoscloud_username: 'email',
-        ionoscloud_password: 'password',
-        datacenter_id: 'datacenter_id',
-        loadbalancer_id: load_balancer.id,
-        name: load_balancer.properties.name + '_edited',
-        dhcp: (!load_balancer.properties.dhcp).to_s,
-        ip: '3.3.3.3',
-        yes: true,
-      }
-
-      subject_config.each { |key, value| subject.config[key] = value }
-
-      nics = load_balancer.entities.balancednics.items.map { |nic| nic.id }
-
-      expect(subject).to receive(:puts).with("ID: #{load_balancer.id}")
-      expect(subject).to receive(:puts).with("Name: #{subject_config[:name]}")
-      expect(subject).to receive(:puts).with("IP address: #{subject_config[:ip]}")
-      expect(subject).to receive(:puts).with("DHCP: #{subject_config[:dhcp]}")
-      expect(subject).to receive(:puts).with("Balanced Nics: #{nics.to_s}")
-
-      load_balancer.properties.name = subject_config[:name]
-      load_balancer.properties.dhcp = subject_config[:dhcp].to_s.downcase == 'true'
-      load_balancer.properties.ip = subject_config[:ip]
-
-      mock_wait_for(subject)
-      mock_call_api(
-        subject,
-        [
-          {
-            method: 'PATCH',
-            path: "/datacenters/#{subject_config[:datacenter_id]}/loadbalancers/#{subject_config[:loadbalancer_id]}",
-            operation: :'LoadBalancerApi.datacenters_loadbalancers_patch',
-            return_type: 'Loadbalancer',
-            body: {
-              name: subject_config[:name],
-              dhcp: subject_config[:dhcp].to_s.downcase == 'true',
-              ip: subject_config[:ip],
-            },
-            result: load_balancer,
-          },
-          {
-            method: 'GET',
-            path: "/datacenters/#{subject_config[:datacenter_id]}/loadbalancers/#{subject_config[:loadbalancer_id]}",
-            operation: :'LoadBalancerApi.datacenters_loadbalancers_find_by_id',
-            return_type: 'Loadbalancer',
-            result: load_balancer,
-          },
-        ],
-      )
-
-      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_nic_get_spec.rb

@@ -1,70 +0,0 @@
-require 'spec_helper'
-require 'ionoscloud_nic_get'
-
-Chef::Knife::IonoscloudNicGet.load_deps
-
-describe Chef::Knife::IonoscloudNicGet do
-  before :each do
-    subject { Chef::Knife::IonoscloudNicGet.new }
-
-    allow(subject).to receive(:puts)
-    allow(subject).to receive(:print)
-  end
-
-  describe '#run' do
-    it 'should call NicApi.datacenters_servers_nics_find_by_id' do
-      nic = nic_mock
-      subject_config = {
-        ionoscloud_username: 'email',
-        ionoscloud_password: 'password',
-        datacenter_id: 'datacenter_id',
-        server_id: 'server_id',
-        nic_id: nic.id,
-        yes: true,
-      }
-
-      subject_config.each { |key, value| subject.config[key] = value }
-
-      expect(subject).to receive(:puts).with("ID: #{nic.id}")
-      expect(subject).to receive(:puts).with("Name: #{nic.properties.name}")
-      expect(subject).to receive(:puts).with("IPs: #{nic.properties.ips.to_s}")
-      expect(subject).to receive(:puts).with("DHCP: #{nic.properties.dhcp}")
-      expect(subject).to receive(:puts).with("LAN: #{nic.properties.lan}")
-      expect(subject).to receive(:puts).with("NAT: #{nic.properties.nat}")
-
-      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]}/nics/#{subject_config[:nic_id]}",
-            operation: :'NicApi.datacenters_servers_nics_find_by_id',
-            return_type: 'Nic',
-            result: nic,
-          },
-        ],
-      )
-
-      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_nic_update_spec.rb

@@ -1,92 +0,0 @@
-require 'spec_helper'
-require 'ionoscloud_nic_update'
-
-Chef::Knife::IonoscloudNicUpdate.load_deps
-
-describe Chef::Knife::IonoscloudNicUpdate do
-  before :each do
-    subject { Chef::Knife::IonoscloudNicUpdate.new }
-
-    allow(subject).to receive(:puts)
-    allow(subject).to receive(:print)
-  end
-
-  describe '#run' do
-    it 'should call NicApi.datacenters_servers_nics_patch' do
-      nic = nic_mock
-      subject_config = {
-        ionoscloud_username: 'email',
-        ionoscloud_password: 'password',
-        datacenter_id: 'datacenter_id',
-        server_id: 'server_id',
-        nic_id: nic.id,
-        lan: 13,
-        name: nic.properties.name + '_edited',
-        dhcp: (!nic.properties.dhcp).to_s,
-        ips: (nic.properties.ips + ['3.3.3.3']).join(','),
-        yes: true,
-      }
-
-      subject_config.each { |key, value| subject.config[key] = value }
-
-      expect(subject).to receive(:puts).with("ID: #{nic.id}")
-      expect(subject).to receive(:puts).with("Name: #{subject_config[:name]}")
-      expect(subject).to receive(:puts).with("IPs: #{subject_config[:ips].split(',').to_s}")
-      expect(subject).to receive(:puts).with("DHCP: #{subject_config[:dhcp]}")
-      expect(subject).to receive(:puts).with("LAN: #{subject_config[:lan]}")
-      expect(subject).to receive(:puts).with("NAT: #{nic.properties.nat}")
-
-      nic.properties.name = subject_config[:name]
-      nic.properties.dhcp = subject_config[:dhcp].to_s.downcase == 'true'
-      nic.properties.ips = subject_config[:ips].split(',')
-      nic.properties.lan = subject_config[:lan]
-
-      mock_wait_for(subject)
-      mock_call_api(
-        subject,
-        [
-          {
-            method: 'PATCH',
-            path: "/datacenters/#{subject_config[:datacenter_id]}/servers/#{subject_config[:server_id]}/nics/#{subject_config[:nic_id]}",
-            operation: :'NicApi.datacenters_servers_nics_patch',
-            return_type: 'Nic',
-            body: {
-              name: subject_config[:name],
-              dhcp: subject_config[:dhcp].to_s.downcase == 'true',
-              ips: subject_config[:ips].split(','),
-              lan: subject_config[:lan],
-            },
-            result: nic,
-          },
-          {
-            method: 'GET',
-            path: "/datacenters/#{subject_config[:datacenter_id]}/servers/#{subject_config[:server_id]}/nics/#{subject_config[:nic_id]}",
-            operation: :'NicApi.datacenters_servers_nics_find_by_id',
-            return_type: 'Nic',
-            result: nic,
-          },
-        ],
-      )
-
-      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_node_get_spec.rb

@@ -1,70 +0,0 @@
-require 'spec_helper'
-require 'ionoscloud_node_get'
-
-Chef::Knife::IonoscloudNodeGet.load_deps
-
-describe Chef::Knife::IonoscloudNodeGet do
-  before :each do
-    subject { Chef::Knife::IonoscloudNodeGet.new }
-
-    allow(subject).to receive(:puts)
-    allow(subject).to receive(:print)
-  end
-
-  describe '#run' do
-    it 'should call KubernetesApi.k8s_nodepools_nodes_find_by_id' do
-      k8s_node = k8s_node_mock
-      subject_config = {
-        ionoscloud_username: 'email',
-        ionoscloud_password: 'password',
-        cluster_id: 'cluster_id',
-        nodepool_id: 'nodepool_id',
-        node_id: k8s_node.id,
-        yes: true,
-      }
-
-      subject_config.each { |key, value| subject.config[key] = value }
-
-      expect(subject).to receive(:puts).with("ID: #{k8s_node.id}")
-      expect(subject).to receive(:puts).with("Name: #{k8s_node.properties.name}")
-      expect(subject).to receive(:puts).with("Public IP: #{k8s_node.properties.public_ip}")
-      expect(subject).to receive(:puts).with("Private IP: #{k8s_node.properties.private_ip}")
-      expect(subject).to receive(:puts).with("K8s Version: #{k8s_node.properties.k8s_version}")
-      expect(subject).to receive(:puts).with("State: #{k8s_node.metadata.state}")
-
-      expect(subject.api_client).not_to receive(:wait_for)
-      mock_call_api(
-        subject,
-        [
-          {
-            method: 'GET',
-            path: "/k8s/#{subject_config[:cluster_id]}/nodepools/#{subject_config[:nodepool_id]}/nodes/#{subject_config[:node_id]}",
-            operation: :'KubernetesApi.k8s_nodepools_nodes_find_by_id',
-            return_type: 'KubernetesNode',
-            result: k8s_node,
-          },
-        ],
-      )
-
-      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_nodepool_get_spec.rb

@@ -1,83 +0,0 @@
-require 'spec_helper'
-require 'ionoscloud_nodepool_get'
-
-Chef::Knife::IonoscloudNodepoolGet.load_deps
-
-describe Chef::Knife::IonoscloudNodepoolGet do
-  before :each do
-    subject { Chef::Knife::IonoscloudNodepoolGet.new }
-
-    allow(subject).to receive(:puts)
-    allow(subject).to receive(:print)
-  end
-
-  describe '#run' do
-    it 'should call KubernetesApi.k8s_nodepools_nodes_find_by_id' do
-      nodepool = k8s_nodepool_mock
-      subject_config = {
-        ionoscloud_username: 'email',
-        ionoscloud_password: 'password',
-        cluster_id: 'cluster_id',
-        nodepool_id: nodepool.id,
-        yes: true,
-      }
-
-      subject_config.each { |key, value| subject.config[key] = value }
-
-      auto_scaling = "Min node count: #{nodepool.properties.auto_scaling.min_node_count}, Max node count:#{nodepool.properties.auto_scaling.max_node_count}"
-      maintenance_window = "#{nodepool.properties.maintenance_window.day_of_the_week}, #{nodepool.properties.maintenance_window.time}"
-      lans = nodepool.properties.lans.map { |lan| { id: lan.id } }
-
-      expect(subject).to receive(:puts).with("ID: #{nodepool.id}")
-      expect(subject).to receive(:puts).with("Name: #{nodepool.properties.name}")
-      expect(subject).to receive(:puts).with("K8s Version: #{nodepool.properties.k8s_version}")
-      expect(subject).to receive(:puts).with("Datacenter ID: #{nodepool.properties.datacenter_id}")
-      expect(subject).to receive(:puts).with("Node Count: #{nodepool.properties.node_count}")
-      expect(subject).to receive(:puts).with("CPU Family: #{nodepool.properties.cpu_family}")
-      expect(subject).to receive(:puts).with("Cores Count: #{nodepool.properties.cores_count}")
-      expect(subject).to receive(:puts).with("RAM: #{nodepool.properties.ram_size}")
-      expect(subject).to receive(:puts).with("Storage Type: #{nodepool.properties.storage_type}")
-      expect(subject).to receive(:puts).with("Storage Size: #{nodepool.properties.storage_size}")
-      expect(subject).to receive(:puts).with("Public IPs: #{nodepool.properties.public_ips}")
-      expect(subject).to receive(:puts).with("LANs: #{lans}")
-      expect(subject).to receive(:puts).with("Availability Zone: #{nodepool.properties.availability_zone}")
-      expect(subject).to receive(:puts).with("Auto Scaling: #{auto_scaling}")
-      expect(subject).to receive(:puts).with("Maintenance Window: #{maintenance_window}")
-      expect(subject).to receive(:puts).with("State: #{nodepool.metadata.state}")
-
-      expect(subject.api_client).not_to receive(:wait_for)
-      mock_call_api(
-        subject,
-        [
-          {
-            method: 'GET',
-            path: "/k8s/#{subject_config[:cluster_id]}/nodepools/#{subject_config[:nodepool_id]}",
-            operation: :'KubernetesApi.k8s_nodepools_find_by_id',
-            return_type: 'KubernetesNodePool',
-            result: nodepool,
-          },
-        ],
-      )
-
-      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_nodepool_update_spec.rb

@@ -1,130 +0,0 @@
-require 'spec_helper'
-require 'ionoscloud_nodepool_update'
-
-Chef::Knife::IonoscloudNodepoolUpdate.load_deps
-
-describe Chef::Knife::IonoscloudNodepoolUpdate do
-  before :each do
-    subject { Chef::Knife::IonoscloudNodepoolUpdate.new }
-
-    allow(subject).to receive(:puts)
-    allow(subject).to receive(:print)
-  end
-
-  describe '#run' do
-    it 'should call KubernetesApi.k8s_nodepools_put' do
-      nodepool = k8s_nodepool_mock
-      subject_config = {
-        ionoscloud_username: 'email',
-        ionoscloud_password: 'password',
-        cluster_id: 'cluster_id',
-        nodepool_id: nodepool.id,
-        k8s_version: '18.18.18',
-        node_count: nodepool.properties.node_count + 1,
-        public_ips: '1.1.1.1,2.2.2.2,3.3.3.3',
-        lans: '13',
-        maintenance_day: 'Tuesday',
-        maintenance_time: '03:48:30Z',
-        max_node_count: nodepool.properties.auto_scaling.max_node_count + 1,
-        yes: true,
-      }
-
-      subject_config.each { |key, value| subject.config[key] = value }
-
-      auto_scaling = "Min node count: #{nodepool.properties.auto_scaling.min_node_count}, Max node count:#{subject_config[:max_node_count]}"
-      maintenance_window = "#{subject_config[:maintenance_day]}, #{subject_config[:maintenance_time]}"
-      lans = subject_config[:lans].split(',').map { |lan| { id: lan } }
-
-      expect(subject).to receive(:puts).with("ID: #{nodepool.id}")
-      expect(subject).to receive(:puts).with("Name: #{nodepool.properties.name}")
-      expect(subject).to receive(:puts).with("K8s Version: #{subject_config[:k8s_version]}")
-      expect(subject).to receive(:puts).with("Datacenter ID: #{nodepool.properties.datacenter_id}")
-      expect(subject).to receive(:puts).with("Node Count: #{subject_config[:node_count]}")
-      expect(subject).to receive(:puts).with("CPU Family: #{nodepool.properties.cpu_family}")
-      expect(subject).to receive(:puts).with("Cores Count: #{nodepool.properties.cores_count}")
-      expect(subject).to receive(:puts).with("RAM: #{nodepool.properties.ram_size}")
-      expect(subject).to receive(:puts).with("Storage Type: #{nodepool.properties.storage_type}")
-      expect(subject).to receive(:puts).with("Storage Size: #{nodepool.properties.storage_size}")
-      expect(subject).to receive(:puts).with("Public IPs: #{subject_config[:public_ips].split(',')}")
-      expect(subject).to receive(:puts).with("LANs: #{lans}")
-      expect(subject).to receive(:puts).with("Availability Zone: #{nodepool.properties.availability_zone}")
-      expect(subject).to receive(:puts).with("Auto Scaling: #{auto_scaling}")
-      expect(subject).to receive(:puts).with("Maintenance Window: #{maintenance_window}")
-      expect(subject).to receive(:puts).with("State: #{nodepool.metadata.state}")
-
-      nodepool.properties.k8s_version = subject_config[:k8s_version]
-      nodepool.properties.node_count = subject_config[:node_count]
-      nodepool.properties.public_ips = subject_config[:public_ips].split(',')
-      nodepool.properties.lans = subject_config[:lans].split(',').map { |lan| Ionoscloud::KubernetesNodePoolLan.new(id: lan) }
-      nodepool.properties.maintenance_window.day_of_the_week = subject_config[:maintenance_day]
-      nodepool.properties.maintenance_window.time = subject_config[:maintenance_time]
-      nodepool.properties.auto_scaling.max_node_count = subject_config[:max_node_count]
-
-      expect(subject.api_client).not_to receive(:wait_for)
-      mock_call_api(
-        subject,
-        [
-          {
-            method: 'GET',
-            path: "/k8s/#{subject_config[:cluster_id]}/nodepools/#{subject_config[:nodepool_id]}",
-            operation: :'KubernetesApi.k8s_nodepools_find_by_id',
-            return_type: 'KubernetesNodePool',
-            result: nodepool,
-          },
-          {
-            method: 'PUT',
-            path: "/k8s/#{subject_config[:cluster_id]}/nodepools/#{subject_config[:nodepool_id]}",
-            operation: :'KubernetesApi.k8s_nodepools_put',
-            return_type: 'KubernetesNodePool',
-            body: {
-              properties: {
-                k8sVersion: subject_config[:k8s_version],
-                nodeCount: subject_config[:node_count],
-                publicIps: subject_config[:public_ips].split(','),
-                labels: nodepool.properties.labels,
-                annotations: nodepool.properties.annotations,
-                lans: subject_config[:lans].split(',').map { |lan| { id: Integer(lan) } },
-                maintenanceWindow: {
-                  dayOfTheWeek: subject_config[:maintenance_day],
-                  time: subject_config[:maintenance_time],
-                },
-                autoScaling: {
-                  minNodeCount: nodepool.properties.auto_scaling.min_node_count,
-                  maxNodeCount: subject_config[:max_node_count],
-                },
-              },
-            },
-            result: nodepool,
-          },
-          {
-            method: 'GET',
-            path: "/k8s/#{subject_config[:cluster_id]}/nodepools/#{subject_config[:nodepool_id]}",
-            operation: :'KubernetesApi.k8s_nodepools_find_by_id',
-            return_type: 'KubernetesNodePool',
-            result: nodepool,
-          },
-        ],
-      )
-
-      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