knife-ionoscloud 6.0.0 → 6.1.2

data/spec/chef/knife/ionoscloud_dbaas_postgres_backup_list_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+require 'ionoscloud_dbaas_postgres_backup_list'
+
+Chef::Knife::IonoscloudDbaasPostgresBackupList.load_deps
+
+describe Chef::Knife::IonoscloudDbaasPostgresBackupList do
+  before :each do
+    subject { Chef::Knife::IonoscloudDbaasPostgresBackupList.new }
+
+    @cluster_backups = cluster_backups_mock
+
+    @cluster_backup_list = [
+      subject.ui.color('ID', :bold),
+      subject.ui.color('Type', :bold),
+      subject.ui.color('Cluster ID', :bold),
+      subject.ui.color('Is Active', :bold),
+      subject.ui.color('Earliest Recovery Target Time', :bold),
+      subject.ui.color('Created Date', :bold),
+
+      @cluster_backups.items.first.id,
+      @cluster_backups.items.first.type,
+      @cluster_backups.items.first.properties.cluster_id,
+      @cluster_backups.items.first.properties.is_active,
+      @cluster_backups.items.first.properties.earliest_recovery_target_time,
+      @cluster_backups.items.first.metadata.created_date,
+
+      @cluster_backups.items[1].id,
+      @cluster_backups.items[1].type,
+      @cluster_backups.items[1].properties.cluster_id,
+      @cluster_backups.items[1].properties.is_active,
+      @cluster_backups.items[1].properties.earliest_recovery_target_time,
+      @cluster_backups.items[1].metadata.created_date,
+    ]
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call BackupsApi.clusters_backups_get when no cluster_id 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(@cluster_backup_list, :uneven_columns_across, 6)
+
+      mock_dbaas_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: '/clusters/backups',
+            operation: :'BackupsApi.clusters_backups_get',
+            return_type: 'ClusterBackupList',
+            result: @cluster_backups,
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should call BackupsApi.cluster_backups_get when cluster_id is set' do
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        cluster_id: 'cluster_id',
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      expect(subject.ui).to receive(:list).with(@cluster_backup_list, :uneven_columns_across, 6)
+
+      mock_dbaas_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: "/clusters/#{subject_config[:cluster_id]}/backups",
+            operation: :'BackupsApi.cluster_backups_get',
+            return_type: 'ClusterBackupList',
+            result: @cluster_backups,
+          },
+        ],
+      )
+
+      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)
+
+      if required_options.length > 0
+        arrays_without_one_element(required_options).each do |test_case|
+          subject.config[:ionoscloud_token] = 'token'
+          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
+end

data/spec/chef/knife/ionoscloud_dbaas_postgres_cluster_create_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+require 'ionoscloud_dbaas_postgres_cluster_create'
+
+Chef::Knife::IonoscloudDbaasPostgresClusterCreate.load_deps
+
+describe Chef::Knife::IonoscloudDbaasPostgresClusterCreate do
+  before :each do
+    subject { Chef::Knife::IonoscloudDbaasPostgresClusterCreate.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call ClustersApi.cluster_post with the expected arguments and output based on what it receives' do
+      cluster = cluster_mock
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        cluster_id: 'cluster_id',
+        display_name: cluster.properties.display_name,
+        postgres_version: cluster.properties.postgres_version,
+        location: cluster.properties.location,
+        backup_location: cluster.properties.backup_location,
+        instances: cluster.properties.instances,
+        ram: cluster.properties.ram,
+        cores: cluster.properties.cores,
+        storage_size: cluster.properties.storage_size,
+        storage_type: cluster.properties.storage_type,
+        connections: cluster.properties.connections.map do |connection|
+          {
+            'datacenter_id' => connection.datacenter_id,
+            'lan_id' => connection.lan_id,
+            'cidr' => connection.cidr,
+          }
+        end,
+        time: cluster.properties.maintenance_window.time,
+        day_of_the_week: cluster.properties.maintenance_window.day_of_the_week,
+        synchronization_mode: cluster.properties.synchronization_mode,
+        state: cluster.metadata.state,
+        username: 'usr',
+        password: 'pass123',
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      expect(subject).to receive(:puts).with("ID: #{cluster.id}")
+      expect(subject).to receive(:puts).with("Display Name: #{cluster.properties.display_name}")
+      expect(subject).to receive(:puts).with("Postgres Version: #{cluster.properties.postgres_version}")
+      expect(subject).to receive(:puts).with("Location: #{cluster.properties.location}")
+      expect(subject).to receive(:puts).with("Backup location: #{cluster.properties.backup_location}")
+      expect(subject).to receive(:puts).with("Instances: #{cluster.properties.instances}")
+      expect(subject).to receive(:puts).with("RAM Size: #{cluster.properties.ram}")
+      expect(subject).to receive(:puts).with("Cores: #{cluster.properties.cores}")
+      expect(subject).to receive(:puts).with("Storage Size: #{cluster.properties.storage_size}")
+      expect(subject).to receive(:puts).with("Storage Type: #{cluster.properties.storage_type}")
+      expect(subject).to receive(:puts).with("Connections: #{cluster.properties.connections.map { |connection| connection.to_hash }}")
+      expect(subject).to receive(:puts).with("Maintenance Window: #{cluster.properties.maintenance_window.to_hash}")
+      expect(subject).to receive(:puts).with("Synchronization Mode: #{cluster.properties.synchronization_mode}")
+      expect(subject).to receive(:puts).with("Lifecycle Status: #{cluster.metadata.state}")
+
+      expected_body = cluster.properties.to_hash
+      expected_body[:credentials] = { username: subject_config[:username], password: subject_config[:password] }
+      expected_body[:fromBackup] = {}
+
+      mock_dbaas_call_api(
+        subject,
+        [
+          {
+            method: 'POST',
+            path: '/clusters',
+            operation: :'ClustersApi.clusters_post',
+            return_type: 'ClusterResponse',
+            body: { properties: expected_body },
+            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)
+
+      if required_options.length > 0
+        arrays_without_one_element(required_options).each do |test_case|
+          subject.config[:ionoscloud_token] = 'token'
+          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
+end

data/spec/chef/knife/ionoscloud_dbaas_postgres_cluster_delete_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+require 'ionoscloud_dbaas_postgres_cluster_delete'
+
+Chef::Knife::IonoscloudDbaasPostgresClusterDelete.load_deps
+
+describe Chef::Knife::IonoscloudDbaasPostgresClusterDelete do
+  before :each do
+    subject { Chef::Knife::IonoscloudDbaasPostgresClusterDelete.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call ClustersApi.clusters_delete when the ID is valid' do
+      cluster = cluster_mock
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        yes: true,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+      subject.name_args = [cluster.id]
+
+      expect(subject).to receive(:puts).with("ID: #{cluster.id}")
+      expect(subject).to receive(:puts).with("Display Name: #{cluster.properties.display_name}")
+      expect(subject).to receive(:puts).with("Postgres Version: #{cluster.properties.postgres_version}")
+      expect(subject).to receive(:puts).with("Location: #{cluster.properties.location}")
+      expect(subject).to receive(:puts).with("Backup location: #{cluster.properties.backup_location}")
+      expect(subject).to receive(:puts).with("Instances: #{cluster.properties.instances}")
+      expect(subject).to receive(:puts).with("RAM Size: #{cluster.properties.ram}")
+      expect(subject).to receive(:puts).with("Cores: #{cluster.properties.cores}")
+      expect(subject).to receive(:puts).with("Storage Size: #{cluster.properties.storage_size}")
+      expect(subject).to receive(:puts).with("Storage Type: #{cluster.properties.storage_type}")
+      expect(subject).to receive(:puts).with("Connections: #{cluster.properties.connections.map { |connection| connection.to_hash }}")
+      expect(subject).to receive(:puts).with("Maintenance Window: #{cluster.properties.maintenance_window.to_hash}")
+      expect(subject).to receive(:puts).with("Synchronization Mode: #{cluster.properties.synchronization_mode}")
+      expect(subject).to receive(:puts).with("Lifecycle Status: #{cluster.metadata.state}")
+      expect(subject.ui).to receive(:warn).with("Deleted Cluster #{cluster.id}.")
+
+      mock_dbaas_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: "/clusters/#{cluster.id}",
+            operation: :'ClustersApi.clusters_find_by_id',
+            return_type: 'ClusterResponse',
+            result: cluster,
+          },
+          {
+            method: 'DELETE',
+            path: "/clusters/#{cluster.id}",
+            operation: :'ClustersApi.clusters_delete',
+            return_type: 'ClusterResponse',
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should not call ClustersApi.clusters_delete when the user ID is not valid' do
+      cluster_id = 'invalid_id'
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+      subject.name_args = [cluster_id]
+
+      expect(subject.ui).to receive(:error).with("Cluster ID #{cluster_id} not found. Skipping.")
+
+      mock_dbaas_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: "/clusters/#{cluster_id}",
+            operation: :'ClustersApi.clusters_find_by_id',
+            return_type: 'ClusterResponse',
+            exception: IonoscloudDbaasPostgres::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)
+
+      if required_options.length > 0
+        arrays_without_one_element(required_options).each do |test_case|
+          subject.config[:ionoscloud_token] = 'token'
+          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
+end

data/spec/chef/knife/ionoscloud_dbaas_postgres_cluster_get_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+require 'ionoscloud_dbaas_postgres_cluster_get'
+
+Chef::Knife::IonoscloudDbaasPostgresClusterGet.load_deps
+
+describe Chef::Knife::IonoscloudDbaasPostgresClusterGet do
+  before :each do
+    subject { Chef::Knife::IonoscloudDbaasPostgresClusterGet.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call ClustersApi.clusters_find_by_id' do
+      cluster = cluster_mock
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        cluster_id: cluster.id,
+        yes: true,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      expect(subject).to receive(:puts).with("ID: #{cluster.id}")
+      expect(subject).to receive(:puts).with("Display Name: #{cluster.properties.display_name}")
+      expect(subject).to receive(:puts).with("Postgres Version: #{cluster.properties.postgres_version}")
+      expect(subject).to receive(:puts).with("Location: #{cluster.properties.location}")
+      expect(subject).to receive(:puts).with("Backup location: #{cluster.properties.backup_location}")
+      expect(subject).to receive(:puts).with("Instances: #{cluster.properties.instances}")
+      expect(subject).to receive(:puts).with("RAM Size: #{cluster.properties.ram}")
+      expect(subject).to receive(:puts).with("Cores: #{cluster.properties.cores}")
+      expect(subject).to receive(:puts).with("Storage Size: #{cluster.properties.storage_size}")
+      expect(subject).to receive(:puts).with("Storage Type: #{cluster.properties.storage_type}")
+      expect(subject).to receive(:puts).with("Connections: #{cluster.properties.connections.map { |connection| connection.to_hash }}")
+      expect(subject).to receive(:puts).with("Maintenance Window: #{cluster.properties.maintenance_window}")
+      expect(subject).to receive(:puts).with("Synchronization Mode: #{cluster.properties.synchronization_mode}")
+      expect(subject).to receive(:puts).with("Lifecycle Status: #{cluster.metadata.state}")
+
+      mock_dbaas_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: "/clusters/#{cluster.id}",
+            operation: :'ClustersApi.clusters_find_by_id',
+            return_type: 'ClusterResponse',
+            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)
+
+      if required_options.length > 0
+        arrays_without_one_element(required_options).each do |test_case|
+          subject.config[:ionoscloud_token] = 'token'
+          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
+end

data/spec/chef/knife/ionoscloud_dbaas_postgres_cluster_list_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+require 'ionoscloud_dbaas_postgres_cluster_list'
+
+Chef::Knife::IonoscloudDbaasPostgresClusterList.load_deps
+
+describe Chef::Knife::IonoscloudDbaasPostgresClusterList do
+  before :each do
+    subject { Chef::Knife::IonoscloudDbaasPostgresClusterList.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call ClustersApi.clusters_get' do
+      clusters = clusters_mock
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      cluster_list = [
+        subject.ui.color('ID', :bold),
+        subject.ui.color('Display Name', :bold),
+        subject.ui.color('Postgres Version', :bold),
+        subject.ui.color('Location', :bold),
+        subject.ui.color('Backup location', :bold),
+        subject.ui.color('Instances', :bold),
+        subject.ui.color('Datacenter ID', :bold),
+        subject.ui.color('Lan ID', :bold),
+        subject.ui.color('cidr', :bold),
+        subject.ui.color('Status', :bold),
+      ]
+
+      clusters.items.each do |cluster|
+        cluster_list << cluster.id
+        cluster_list << cluster.properties.display_name
+        cluster_list << cluster.properties.postgres_version
+        cluster_list << cluster.properties.location
+        cluster_list << cluster.properties.backup_location
+        cluster_list << cluster.properties.instances
+        cluster_list << cluster.properties.connections.first.datacenter_id
+        cluster_list << cluster.properties.connections.first.lan_id
+        cluster_list << cluster.properties.connections.first.cidr
+        cluster_list << cluster.metadata.state
+      end
+
+      expect(subject.ui).to receive(:list).with(cluster_list, :uneven_columns_across, 10)
+
+      mock_dbaas_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: '/clusters',
+            operation: :'ClustersApi.clusters_get',
+            return_type: 'ClusterList',
+            result: clusters,
+          },
+        ],
+      )
+
+      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)
+
+      if required_options.length > 0
+        arrays_without_one_element(required_options).each do |test_case|
+          subject.config[:ionoscloud_token] = 'token'
+          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
+end

data/spec/chef/knife/ionoscloud_dbaas_postgres_cluster_restore_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+require 'ionoscloud_dbaas_postgres_cluster_restore'
+
+Chef::Knife::IonoscloudDbaasPostgresClusterRestore.load_deps
+
+describe Chef::Knife::IonoscloudDbaasPostgresClusterRestore do
+  before :each do
+    subject { Chef::Knife::IonoscloudDbaasPostgresClusterRestore.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call RestoresApi.cluster_restore_post with the expected arguments and output based on what it receives' do
+      cluster = cluster_mock
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        cluster_id: cluster.id,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      mock_dbaas_call_api(
+        subject,
+        [
+          {
+            method: 'POST',
+            path: "/clusters/#{subject_config[:cluster_id]}/restore",
+            operation: :'RestoresApi.cluster_restore_post',
+            result: nil,
+            body: {},
+          },
+        ],
+      )
+
+      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)
+
+      if required_options.length > 0
+        arrays_without_one_element(required_options).each do |test_case|
+          subject.config[:ionoscloud_token] = 'token'
+          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
+end

data/spec/chef/knife/ionoscloud_dbaas_postgres_cluster_update_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+require 'ionoscloud_dbaas_postgres_cluster_update'
+
+Chef::Knife::IonoscloudDbaasPostgresClusterUpdate.load_deps
+
+describe Chef::Knife::IonoscloudDbaasPostgresClusterUpdate do
+  before :each do
+    subject { Chef::Knife::IonoscloudDbaasPostgresClusterUpdate.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call ClustersApi.clusters_patch' do
+      cluster = cluster_mock
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        cluster_id: cluster.id,
+        display_name: cluster.properties.display_name + '_edited',
+        yes: true,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      expect(subject).to receive(:puts).with("ID: #{cluster.id}")
+      expect(subject).to receive(:puts).with("Display Name: #{subject_config[:display_name]}")
+      expect(subject).to receive(:puts).with("Postgres Version: #{cluster.properties.postgres_version}")
+      expect(subject).to receive(:puts).with("Location: #{cluster.properties.location}")
+      expect(subject).to receive(:puts).with("Backup location: #{cluster.properties.backup_location}")
+      expect(subject).to receive(:puts).with("Instances: #{cluster.properties.instances}")
+      expect(subject).to receive(:puts).with("RAM Size: #{cluster.properties.ram}")
+      expect(subject).to receive(:puts).with("Cores: #{cluster.properties.cores}")
+      expect(subject).to receive(:puts).with("Storage Size: #{cluster.properties.storage_size}")
+      expect(subject).to receive(:puts).with("Storage Type: #{cluster.properties.storage_type}")
+      expect(subject).to receive(:puts).with("Connections: #{cluster.properties.connections.map { |connection| connection.to_hash }}")
+      expect(subject).to receive(:puts).with("Maintenance Window: #{cluster.properties.maintenance_window.to_hash}")
+      expect(subject).to receive(:puts).with("Synchronization Mode: #{cluster.properties.synchronization_mode}")
+      expect(subject).to receive(:puts).with("Lifecycle Status: #{cluster.metadata.state}")
+
+      expected_body = {
+        displayName: subject_config[:display_name],
+      }
+
+      cluster.properties.display_name = subject_config[:display_name]
+
+      mock_dbaas_call_api(
+        subject,
+        [
+          {
+            method: 'PATCH',
+            path: "/clusters/#{cluster.id}",
+            operation: :'ClustersApi.clusters_patch',
+            return_type: 'ClusterResponse',
+            body: { properties: expected_body },
+            result: cluster,
+          },
+          {
+            method: 'GET',
+            path: "/clusters/#{cluster.id}",
+            operation: :'ClustersApi.clusters_find_by_id',
+            return_type: 'ClusterResponse',
+            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)
+
+      if required_options.length > 0
+        arrays_without_one_element(required_options).each do |test_case|
+          subject.config[:ionoscloud_token] = 'token'
+          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
+end