knife-ionoscloud 6.0.0.alpha.1 → 6.1.0

data/spec/chef/knife/ionoscloud_backupunit_update_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+require 'ionoscloud_backupunit_update'
+
+Chef::Knife::IonoscloudBackupunitUpdate.load_deps
+
+describe Chef::Knife::IonoscloudBackupunitUpdate do
+  before :each do
+    subject { Chef::Knife::IonoscloudBackupunitUpdate.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call BackupUnitsApi.backupunits_patch' do
+      backupunit = backupunit_mock
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        backupunit_id: backupunit.id,
+        email: 'edited' + backupunit.properties.email,
+        password: 'password_edited',
+        yes: true,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+
+      expect(subject).to receive(:puts).with("ID: #{backupunit.id}")
+      expect(subject).to receive(:puts).with("Name: #{backupunit.properties.name}")
+      expect(subject).to receive(:puts).with("Email: #{subject_config[:email]}")
+
+      backupunit.properties.email = subject_config[:email]
+
+      mock_wait_for(subject)
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'PATCH',
+            path: "/backupunits/#{backupunit.id}",
+            operation: :'BackupUnitsApi.backupunits_patch',
+            return_type: 'BackupUnit',
+            body: { email: subject_config[:email], password: subject_config[:password] },
+            result: backupunit,
+          },
+          {
+            method: 'GET',
+            path: "/backupunits/#{backupunit.id}",
+            operation: :'BackupUnitsApi.backupunits_find_by_id',
+            return_type: 'BackupUnit',
+            result: backupunit,
+          },
+        ],
+      )
+
+      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_datacenter_create_spec.rb

@@ -29,6 +29,9 @@ describe Chef::Knife::IonoscloudDatacenterCreate do
       expect(subject).to receive(:puts).with("Name: #{datacenter.properties.name}")
       expect(subject).to receive(:puts).with("Description: #{datacenter.properties.description}")
       expect(subject).to receive(:puts).with("Location: #{datacenter.properties.location}")
+      expect(subject).to receive(:puts).with("Version: #{datacenter.properties.version}")
+      expect(subject).to receive(:puts).with("Features: #{datacenter.properties.features}")
+      expect(subject).to receive(:puts).with("Sec Auth Protection: #{datacenter.properties.sec_auth_protection}")
 
       expected_body = datacenter.properties.to_hash
       expected_body.delete(:version)

data/spec/chef/knife/ionoscloud_datacenter_delete_spec.rb

@@ -27,6 +27,9 @@ describe Chef::Knife::IonoscloudDatacenterDelete do
       expect(subject).to receive(:puts).with("Name: #{datacenter.properties.name}")
       expect(subject).to receive(:puts).with("Description: #{datacenter.properties.description}")
       expect(subject).to receive(:puts).with("Location: #{datacenter.properties.location}")
+      expect(subject).to receive(:puts).with("Version: #{datacenter.properties.version}")
+      expect(subject).to receive(:puts).with("Features: #{datacenter.properties.features}")
+      expect(subject).to receive(:puts).with("Sec Auth Protection: #{datacenter.properties.sec_auth_protection}")
       expect(subject.ui).to receive(:warn).with("Deleted Data center #{datacenter.id}. Request ID: ")
 
       expect(subject.api_client).not_to receive(:wait_for)

data/spec/chef/knife/ionoscloud_datacenter_get_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+require 'ionoscloud_datacenter_get'
+
+Chef::Knife::IonoscloudDatacenterGet.load_deps
+
+describe Chef::Knife::IonoscloudDatacenterGet do
+  before :each do
+    subject { Chef::Knife::IonoscloudDatacenterGet.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call DataCentersApi.datacenters_find_by_id' do
+      datacenter = datacenter_mock
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        datacenter_id: datacenter.id,
+        yes: true,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      expect(subject).to receive(:puts).with("ID: #{datacenter.id}")
+      expect(subject).to receive(:puts).with("Name: #{datacenter.properties.name}")
+      expect(subject).to receive(:puts).with("Description: #{datacenter.properties.description}")
+      expect(subject).to receive(:puts).with("Location: #{datacenter.properties.location}")
+      expect(subject).to receive(:puts).with("Version: #{datacenter.properties.version}")
+      expect(subject).to receive(:puts).with("Features: #{datacenter.properties.features}")
+      expect(subject).to receive(:puts).with("Sec Auth Protection: #{datacenter.properties.sec_auth_protection}")
+
+      expect(subject.api_client).not_to receive(:wait_for)
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: "/datacenters/#{datacenter.id}",
+            operation: :'DataCentersApi.datacenters_find_by_id',
+            return_type: 'Datacenter',
+            result: datacenter,
+          },
+        ],
+      )
+
+      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_datacenter_update_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+require 'ionoscloud_datacenter_update'
+
+Chef::Knife::IonoscloudDatacenterUpdate.load_deps
+
+describe Chef::Knife::IonoscloudDatacenterUpdate do
+  before :each do
+    subject { Chef::Knife::IonoscloudDatacenterUpdate.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call DataCentersApi.datacenters_patch' do
+      datacenter = datacenter_mock
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        datacenter_id: datacenter.id,
+        name: datacenter.properties.name + '_edited',
+        description: datacenter.properties.description + '_edited',
+        yes: true,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      expect(subject).to receive(:puts).with("ID: #{datacenter.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("Location: #{datacenter.properties.location}")
+      expect(subject).to receive(:puts).with("Version: #{datacenter.properties.version}")
+      expect(subject).to receive(:puts).with("Features: #{datacenter.properties.features}")
+      expect(subject).to receive(:puts).with("Sec Auth Protection: #{datacenter.properties.sec_auth_protection}")
+
+      datacenter.properties.name = subject_config[:name]
+      datacenter.properties.description = subject_config[:description]
+
+      mock_wait_for(subject)
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'PATCH',
+            path: "/datacenters/#{datacenter.id}",
+            operation: :'DataCentersApi.datacenters_patch',
+            return_type: 'Datacenter',
+            body: { name: subject_config[:name], description: subject_config[:description] },
+            result: datacenter,
+          },
+          {
+            method: 'GET',
+            path: "/datacenters/#{datacenter.id}",
+            operation: :'DataCentersApi.datacenters_find_by_id',
+            return_type: 'Datacenter',
+            result: datacenter,
+          },
+        ],
+      )
+
+      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_dbaas_postgres_backup_get_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+require 'ionoscloud_dbaas_postgres_backup_get'
+
+Chef::Knife::IonoscloudDbaasPostgresBackupGet.load_deps
+
+describe Chef::Knife::IonoscloudDbaasPostgresBackupGet do
+  before :each do
+    subject { Chef::Knife::IonoscloudDbaasPostgresBackupGet.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call BackupsApi.clusters_backups_find_by_id' do
+      backup = cluster_backup_mock
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        backup_id: backup.id,
+        yes: true,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      expect(subject).to receive(:puts).with("ID: #{backup.id}")
+      expect(subject).to receive(:puts).with("Cluster ID: #{backup.properties.cluster_id}")
+      expect(subject).to receive(:puts).with("Is Active: #{backup.properties.is_active}")
+      expect(subject).to receive(:puts).with("Version: #{backup.properties.version}")
+      expect(subject).to receive(:puts).with("Earliest Recovery Target Time: #{backup.properties.earliest_recovery_target_time}")
+      expect(subject).to receive(:puts).with("Created Date: #{backup.metadata.created_date}")
+
+      mock_dbaas_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: "/clusters/backups/#{backup.id}",
+            operation: :'BackupsApi.clusters_backups_find_by_id',
+            return_type: 'BackupResponse',
+            result: backup,
+          },
+        ],
+      )
+
+      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_dbaas).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_dbaas_postgres_backup_list_spec.rb

@@ -0,0 +1,111 @@
+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)
+
+      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_dbaas).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_dbaas_postgres_cluster_create_spec.rb

@@ -0,0 +1,99 @@
+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,
+        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("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)
+
+      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_dbaas).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_dbaas_postgres_cluster_delete_spec.rb

@@ -0,0 +1,109 @@
+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("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)
+
+      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