knife-ionoscloud 5.1.2 → 6.0.0.alpha.1

data/spec/chef/knife/ionoscloud_firewall_update_spec.rb

@@ -1,116 +0,0 @@
-require 'spec_helper'
-require 'ionoscloud_firewall_update'
-
-Chef::Knife::IonoscloudFirewallUpdate.load_deps
-
-describe Chef::Knife::IonoscloudFirewallUpdate do
-  before :each do
-    subject { Chef::Knife::IonoscloudFirewallUpdate.new }
-
-    allow(subject).to receive(:puts)
-    allow(subject).to receive(:print)
-  end
-
-  describe '#run' do
-    it 'should call NicApi.datacenters_servers_nics_firewallrules_patch' do
-      firewall = firewall_mock
-      subject_config = {
-        ionoscloud_username: 'email',
-        ionoscloud_password: 'password',
-        datacenter_id: 'datacenter_id',
-        server_id: 'server_id',
-        nic_id: 'nic_id',
-        firewall_id: firewall.id,
-        name: firewall.properties.name + '_edited',
-        protocol: 'TCP',
-        source_mac: '01:11:11:11:22:00',
-        source_ip: '1.2.3.4',
-        target_ip: '2.2.3.1',
-        port_range_start: 100,
-        port_range_end: 145,
-        icmp_type: 15,
-        icmp_code: 14,
-        yes: true,
-      }
-
-      subject_config.each { |key, value| subject.config[key] = value }
-
-      expect(subject).to receive(:puts).with("ID: #{firewall.id}")
-      expect(subject).to receive(:puts).with("Name: #{subject_config[:name]}")
-      expect(subject).to receive(:puts).with("Protocol: #{subject_config[:protocol]}")
-      expect(subject).to receive(:puts).with("Source MAC: #{subject_config[:source_mac]}")
-      expect(subject).to receive(:puts).with("Source IP: #{subject_config[:source_ip]}")
-      expect(subject).to receive(:puts).with("Target IP: #{subject_config[:target_ip]}")
-      expect(subject).to receive(:puts).with("Port Range Start: #{subject_config[:port_range_start]}")
-      expect(subject).to receive(:puts).with("Port Range End: #{subject_config[:port_range_end]}")
-      expect(subject).to receive(:puts).with("ICMP Type: #{subject_config[:icmp_type]}")
-      expect(subject).to receive(:puts).with("ICMP Code: #{subject_config[:icmp_code]}")
-
-      firewall.properties.name = subject_config[:name]
-      firewall.properties.protocol = subject_config[:protocol]
-      firewall.properties.source_mac = subject_config[:source_mac]
-      firewall.properties.source_ip = subject_config[:source_ip]
-      firewall.properties.target_ip = subject_config[:target_ip]
-      firewall.properties.port_range_start = subject_config[:port_range_start]
-      firewall.properties.port_range_end = subject_config[:port_range_end]
-      firewall.properties.icmp_type = subject_config[:icmp_type]
-      firewall.properties.icmp_code = subject_config[:icmp_code]
-
-      expected_body = {
-        name: subject_config[:name],
-        protocol: subject_config[:protocol],
-        sourceMac: subject_config[:source_mac],
-        sourceIp: subject_config[:source_ip],
-        targetIp: subject_config[:target_ip],
-        portRangeStart: subject_config[:port_range_start],
-        portRangeEnd: subject_config[:port_range_end],
-        icmpType: subject_config[:icmp_type],
-        icmpCode: subject_config[:icmp_code],
-      }
-
-      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]}/firewallrules/#{firewall.id}",
-            operation: :'NicApi.datacenters_servers_nics_firewallrules_patch',
-            return_type: 'FirewallRule',
-            body: expected_body,
-            result: firewall,
-          },
-          {
-            method: 'GET',
-            path: "/datacenters/#{subject_config[:datacenter_id]}/servers/#{subject_config[:server_id]}/"\
-                  "nics/#{subject_config[:nic_id]}/firewallrules/#{firewall.id}",
-            operation: :'NicApi.datacenters_servers_nics_firewallrules_find_by_id',
-            return_type: 'FirewallRule',
-            result: firewall,
-          },
-        ],
-      )
-
-      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_group_update_spec.rb

@@ -1,109 +0,0 @@
-require 'spec_helper'
-require 'ionoscloud_group_update'
-
-Chef::Knife::IonoscloudGroupUpdate.load_deps
-
-describe Chef::Knife::IonoscloudGroupUpdate do
-  before :each do
-    subject { Chef::Knife::IonoscloudGroupUpdate.new }
-
-    allow(subject).to receive(:puts)
-    allow(subject).to receive(:print)
-  end
-
-  describe '#run' do
-    it 'should call UserManagementApi.um_groups_put' do
-      group = group_mock
-      subject_config = {
-        ionoscloud_username: 'email',
-        ionoscloud_password: 'password',
-        group_id: group.id,
-        name: group.properties.name + '_edited',
-        create_snapshot: !group.properties.create_snapshot,
-        reserve_ip: group.properties.reserve_ip,
-        access_activity_log: !group.properties.access_activity_log,
-        create_backup_unit: !group.properties.create_backup_unit,
-        create_pcc: !group.properties.create_pcc,
-        yes: true,
-      }
-
-      subject_config.each { |key, value| subject.config[key] = value }
-
-      expect(subject).to receive(:puts).with("ID: #{group.id}")
-      expect(subject).to receive(:puts).with("Name: #{subject_config[:name]}")
-      expect(subject).to receive(:puts).with("Create Datacenter: #{group.properties.create_data_center.to_s}")
-      expect(subject).to receive(:puts).with("Create Snapshot: #{subject_config[:create_snapshot].to_s}")
-      expect(subject).to receive(:puts).with("Reserve IP: #{group.properties.reserve_ip.to_s}")
-      expect(subject).to receive(:puts).with("Access Activity Log: #{subject_config[:access_activity_log].to_s}")
-      expect(subject).to receive(:puts).with("S3 Privilege: #{group.properties.s3_privilege.to_s}")
-      expect(subject).to receive(:puts).with("Create Backup Unit: #{subject_config[:create_backup_unit].to_s}")
-      expect(subject).to receive(:puts).with("Create K8s Clusters: #{group.properties.create_k8s_cluster.to_s}")
-      expect(subject).to receive(:puts).with("Create PCC: #{subject_config[:create_pcc].to_s}")
-      expect(subject).to receive(:puts).with("Create Internet Acess: #{group.properties.create_internet_access.to_s}")
-
-      group.properties.name = subject_config[:name]
-      group.properties.create_snapshot = subject_config[:create_snapshot]
-      group.properties.access_activity_log = subject_config[:access_activity_log]
-      group.properties.create_backup_unit = subject_config[:create_backup_unit]
-      group.properties.create_pcc = subject_config[:create_pcc]
-
-      expected_body = {
-        name: subject_config[:name],
-        createSnapshot: subject_config[:create_snapshot],
-        reserveIp: subject_config[:reserve_ip],
-        accessActivityLog: subject_config[:access_activity_log],
-        createBackupUnit: subject_config[:create_backup_unit],
-        createPcc: subject_config[:create_pcc],
-      }.merge(group.properties.to_hash)
-
-      mock_wait_for(subject)
-      mock_call_api(
-        subject,
-        [
-          {
-            method: 'GET',
-            path: "/um/groups/#{group.id}",
-            operation: :'UserManagementApi.um_groups_find_by_id',
-            return_type: 'Group',
-            result: group,
-          },
-          {
-            method: 'PUT',
-            path: "/um/groups/#{group.id}",
-            operation: :'UserManagementApi.um_groups_put',
-            return_type: 'Group',
-            body: { properties: expected_body },
-            result: group,
-          },
-          {
-            method: 'GET',
-            path: "/um/groups/#{group.id}",
-            operation: :'UserManagementApi.um_groups_find_by_id',
-            return_type: 'Group',
-            result: group,
-          },
-        ],
-      )
-
-      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_ipblock_get_spec.rb

@@ -1,66 +0,0 @@
-require 'spec_helper'
-require 'ionoscloud_ipblock_get'
-
-Chef::Knife::IonoscloudIpblockGet.load_deps
-
-describe Chef::Knife::IonoscloudIpblockGet do
-  before :each do
-    subject { Chef::Knife::IonoscloudIpblockGet.new }
-
-    allow(subject).to receive(:puts)
-    allow(subject).to receive(:print)
-  end
-
-  describe '#run' do
-    it 'should call IPBlocksApi.ipblocks_find_by_id' do
-      ipblock = ipblock_mock
-      subject_config = {
-        ionoscloud_username: 'email',
-        ionoscloud_password: 'password',
-        ipblock_id: ipblock.id,
-      }
-
-      subject_config.each { |key, value| subject.config[key] = value }
-
-      ip_consumers = (ipblock.properties.ip_consumers.nil? ? [] : ipblock.properties.ip_consumers.map { |el| el.to_hash })
-      expect(subject).to receive(:puts).with("ID: #{ipblock.id}")
-      expect(subject).to receive(:puts).with("Name: #{ipblock.properties.name}")
-      expect(subject).to receive(:puts).with("IP Addresses: #{ipblock.properties.ips.to_s}")
-      expect(subject).to receive(:puts).with("Location: #{ipblock.properties.location}")
-      expect(subject).to receive(:puts).with("IP Consumers: #{ip_consumers}")
-
-      mock_call_api(
-        subject,
-        [
-          {
-            method: 'GET',
-            path: "/ipblocks/#{ipblock.id}",
-            operation: :'IPBlocksApi.ipblocks_find_by_id',
-            return_type: 'IpBlock',
-            result: ipblock,
-          },
-        ],
-      )
-
-      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_ipblock_update_spec.rb

@@ -1,79 +0,0 @@
-require 'spec_helper'
-require 'ionoscloud_ipblock_update'
-
-Chef::Knife::IonoscloudIpblockUpdate.load_deps
-
-describe Chef::Knife::IonoscloudIpblockUpdate do
-  before :each do
-    subject { Chef::Knife::IonoscloudIpblockUpdate.new }
-
-    allow(subject).to receive(:puts)
-    allow(subject).to receive(:print)
-  end
-
-  describe '#run' do
-    it 'should call DataCenterApi.datacenters_patch' do
-      ipblock = ipblock_mock
-      subject_config = {
-        ionoscloud_username: 'email',
-        ionoscloud_password: 'password',
-        ipblock_id: ipblock.id,
-        name: ipblock.properties.name + '_edited',
-        yes: true,
-      }
-
-      subject_config.each { |key, value| subject.config[key] = value }
-
-      ip_consumers = (ipblock.properties.ip_consumers.nil? ? [] : ipblock.properties.ip_consumers.map { |el| el.to_hash })
-      expect(subject).to receive(:puts).with("ID: #{ipblock.id}")
-      expect(subject).to receive(:puts).with("Name: #{subject_config[:name]}")
-      expect(subject).to receive(:puts).with("IP Addresses: #{ipblock.properties.ips.to_s}")
-      expect(subject).to receive(:puts).with("Location: #{ipblock.properties.location}")
-      expect(subject).to receive(:puts).with("IP Consumers: #{ip_consumers}")
-
-      ipblock.properties.name = subject_config[:name]
-
-      mock_wait_for(subject)
-      mock_call_api(
-        subject,
-        [
-          {
-            method: 'PATCH',
-            path: "/ipblocks/#{ipblock.id}",
-            operation: :'IPBlocksApi.ipblocks_patch',
-            return_type: 'IpBlock',
-            body: { name: subject_config[:name] },
-            result: ipblock,
-          },
-          {
-            method: 'GET',
-            path: "/ipblocks/#{ipblock.id}",
-            operation: :'IPBlocksApi.ipblocks_find_by_id',
-            return_type: 'IpBlock',
-            result: ipblock,
-          },
-        ],
-      )
-
-      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_k8s_get_spec.rb

@@ -1,73 +0,0 @@
-require 'spec_helper'
-require 'ionoscloud_k8s_get'
-
-Chef::Knife::IonoscloudK8sGet.load_deps
-
-describe Chef::Knife::IonoscloudK8sGet do
-  before :each do
-    subject { Chef::Knife::IonoscloudK8sGet.new }
-
-    allow(subject).to receive(:puts)
-    allow(subject).to receive(:print)
-  end
-
-  describe '#run' do
-    it 'should call KubernetesApi.k8s_find_by_cluster_id' do
-      cluster = k8s_cluster_mock
-      subject_config = {
-        ionoscloud_username: 'email',
-        ionoscloud_password: 'password',
-        cluster_id: cluster.id,
-      }
-
-      subject_config.each { |key, value| subject.config[key] = value }
-
-      maintenance_window = "#{cluster.properties.maintenance_window.day_of_the_week}, #{cluster.properties.maintenance_window.time}"
-      s3_buckets = (cluster.properties.s3_buckets.nil? ? [] : cluster.properties.s3_buckets.map { |el| el.name })
-
-      expect(subject).to receive(:puts).with("ID: #{cluster.id}")
-      expect(subject).to receive(:puts).with("Name: #{cluster.properties.name}")
-      expect(subject).to receive(:puts).with("Public: #{cluster.properties.public}")
-      expect(subject).to receive(:puts).with("k8s Version: #{cluster.properties.k8s_version}")
-      expect(subject).to receive(:puts).with("Maintenance Window: #{maintenance_window}")
-      expect(subject).to receive(:puts).with("State: #{cluster.metadata.state}")
-      expect(subject).to receive(:puts).with("Api Subnet Allow List: #{cluster.properties.api_subnet_allow_list}")
-      expect(subject).to receive(:puts).with("S3 Buckets: #{s3_buckets}")
-      expect(subject).to receive(:puts).with("Available Upgrade Versions: #{cluster.properties.available_upgrade_versions}")
-      expect(subject).to receive(:puts).with("Viable NodePool Versions: #{cluster.properties.viable_node_pool_versions}")
-
-      mock_call_api(
-        subject,
-        [
-          {
-            method: 'GET',
-            path: "/k8s/#{cluster.id}",
-            operation: :'KubernetesApi.k8s_find_by_cluster_id',
-            return_type: 'KubernetesCluster',
-            result: cluster,
-          },
-        ],
-      )
-
-      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_k8s_update_spec.rb

@@ -1,115 +0,0 @@
-require 'spec_helper'
-require 'ionoscloud_k8s_update'
-
-Chef::Knife::IonoscloudK8sUpdate.load_deps
-
-describe Chef::Knife::IonoscloudK8sUpdate do
-  before :each do
-    subject { Chef::Knife::IonoscloudK8sUpdate.new }
-
-    allow(subject).to receive(:puts)
-    allow(subject).to receive(:print)
-  end
-
-  describe '#run' do
-    it 'should call NicApi.datacenters_servers_nics_clusterrules_patch' do
-      cluster = k8s_cluster_mock
-
-      subject_config = {
-        ionoscloud_username: 'email',
-        ionoscloud_password: 'password',
-        cluster_id: cluster.id,
-        name: cluster.properties.name + '_edited',
-        version: '19.9.9',
-        maintenance_day: 'Monday',
-        maintenance_time: '13:03:19Z',
-        api_subnet_allow_list: (cluster.properties.api_subnet_allow_list + ['1.1.1.1']).join(','),
-        s3_buckets: (cluster.properties.s3_buckets.map { |el| el.name } + ['new_bucket']).join(','),
-        yes: true,
-      }
-
-      subject_config.each { |key, value| subject.config[key] = value }
-
-      maintenance_window = "#{subject_config[:maintenance_day]}, #{subject_config[:maintenance_time]}"
-      s3_buckets = (cluster.properties.s3_buckets.map { |el| el.name } + ['new_bucket'])
-
-      expect(subject).to receive(:puts).with("ID: #{cluster.id}")
-      expect(subject).to receive(:puts).with("Name: #{subject_config[:name]}")
-      expect(subject).to receive(:puts).with("Public: #{cluster.properties.public}")
-      expect(subject).to receive(:puts).with("k8s Version: #{subject_config[:version]}")
-      expect(subject).to receive(:puts).with("Maintenance Window: #{maintenance_window}")
-      expect(subject).to receive(:puts).with("State: #{cluster.metadata.state}")
-      expect(subject).to receive(:puts).with("Api Subnet Allow List: #{cluster.properties.api_subnet_allow_list + ['1.1.1.1']}")
-      expect(subject).to receive(:puts).with("S3 Buckets: #{s3_buckets}")
-      expect(subject).to receive(:puts).with("Available Upgrade Versions: #{cluster.properties.available_upgrade_versions}")
-      expect(subject).to receive(:puts).with("Viable NodePool Versions: #{cluster.properties.viable_node_pool_versions}")
-
-      cluster.properties.name = subject_config[:name]
-      cluster.properties.k8s_version = subject_config[:version]
-      cluster.properties.maintenance_window.day_of_the_week = subject_config[:maintenance_day]
-      cluster.properties.maintenance_window.time = subject_config[:maintenance_time]
-      cluster.properties.api_subnet_allow_list = subject_config[:api_subnet_allow_list].split(',')
-      cluster.properties.s3_buckets = subject_config[:s3_buckets].split(',').map { |el| Ionoscloud::S3Bucket.new(name: el) }
-
-      expected_body = {
-        name: subject_config[:name],
-        k8sVersion: subject_config[:version],
-        maintenanceWindow: {
-          dayOfTheWeek: subject_config[:maintenance_day],
-          time: subject_config[:maintenance_time],
-        },
-        apiSubnetAllowList: subject_config[:api_subnet_allow_list].split(','),
-        s3Buckets: subject_config[:s3_buckets].split(',').map { |el| { name: el } },
-      }
-
-      expect(subject.api_client).not_to receive(:wait_for)
-      mock_call_api(
-        subject,
-        [
-          {
-            method: 'GET',
-            path: "/k8s/#{cluster.id}",
-            operation: :'KubernetesApi.k8s_find_by_cluster_id',
-            return_type: 'KubernetesCluster',
-            result: cluster,
-          },
-          {
-            method: 'PUT',
-            path: "/k8s/#{cluster.id}",
-            operation: :'KubernetesApi.k8s_put',
-            return_type: 'KubernetesCluster',
-            body: { properties: expected_body },
-            result: cluster,
-          },
-          {
-            method: 'GET',
-            path: "/k8s/#{cluster.id}",
-            operation: :'KubernetesApi.k8s_find_by_cluster_id',
-            return_type: 'KubernetesCluster',
-            result: cluster,
-          },
-        ],
-      )
-
-      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_lan_get_spec.rb

@@ -1,68 +0,0 @@
-require 'spec_helper'
-require 'ionoscloud_lan_get'
-
-Chef::Knife::IonoscloudLanGet.load_deps
-
-describe Chef::Knife::IonoscloudLanGet do
-  before :each do
-    subject { Chef::Knife::IonoscloudLanGet.new }
-
-    allow(subject).to receive(:puts)
-    allow(subject).to receive(:print)
-  end
-
-  describe '#run' do
-    it 'should call LanApi.datacenters_lans_find_by_id' do
-      lan = lan_mock
-      subject_config = {
-        ionoscloud_username: 'email',
-        ionoscloud_password: 'password',
-        datacenter_id: 'datacenter_id',
-        lan_id: lan.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: #{lan.properties.name}")
-      expect(subject).to receive(:puts).with("Public: #{lan.properties.public.to_s}")
-      expect(subject).to receive(:puts).with("PCC: #{lan.properties.pcc}")
-      expect(subject).to receive(:puts).with("IP Failover: #{[]}")
-
-      expect(subject.api_client).not_to receive(:wait_for)
-      mock_call_api(
-        subject,
-        [
-          {
-            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