knife-ionoscloud 6.0.0 → 6.1.0

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

data/spec/chef/knife/ionoscloud_dbaas_postgres_cluster_get_spec.rb

@@ -0,0 +1,73 @@
+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("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)
+
+      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_list_spec.rb

@@ -0,0 +1,84 @@
+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('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.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, 9)
+
+      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)
+
+      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_cluster_restore_spec.rb

@@ -0,0 +1,59 @@
+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)
+
+      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_cluster_update_spec.rb

@@ -0,0 +1,89 @@
+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("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)
+
+      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_logs_get_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+require 'ionoscloud_dbaas_postgres_logs_get'
+
+Chef::Knife::IonoscloudDbaasPostgresLogsGet.load_deps
+
+describe Chef::Knife::IonoscloudDbaasPostgresLogsGet do
+  before :each do
+    subject { Chef::Knife::IonoscloudDbaasPostgresLogsGet.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call LogsApi.cluster_logs_get' do
+      cluster_logs = cluster_logs_mock
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        cluster_id: 'cluster_id',
+        limit: 3,
+        yes: true,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      cluster_logs.instances.each do
+        |instance|
+        expect(subject).to receive(:puts).with("Instance Name: #{instance.name}")
+        expect(subject).to receive(:puts).with(instance.messages.map { |message| message.message })
+      end
+
+      mock_dbaas_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: "/clusters/#{subject_config[:cluster_id]}/logs",
+            operation: :'LogsApi.cluster_logs_get',
+            return_type: 'ClusterLogs',
+            result: cluster_logs,
+          },
+        ],
+      )
+
+      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_version_list_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+require 'ionoscloud_dbaas_postgres_version_list'
+
+Chef::Knife::IonoscloudDbaasPostgresVersionList.load_deps
+
+describe Chef::Knife::IonoscloudDbaasPostgresVersionList do
+  before :each do
+    subject { Chef::Knife::IonoscloudDbaasPostgresVersionList.new }
+
+    @postgres_versions = postgres_version_list_mock
+
+    @postgres_version_list = postgres_version_list = [
+      subject.ui.color('Version', :bold),
+      @postgres_versions.data.first.name,
+      @postgres_versions.data[1].name,
+    ]
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call ClustersApi.postgres_versions_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(@postgres_version_list, :uneven_columns_across, 1)
+
+      mock_dbaas_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: '/clusters/postgresversions',
+            operation: :'ClustersApi.postgres_versions_get',
+            return_type: 'PostgresVersionList',
+            result: @postgres_versions,
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should call ClustersApi.cluster_postgres_versions_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(@postgres_version_list, :uneven_columns_across, 1)
+
+      mock_dbaas_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: "/clusters/#{subject_config[:cluster_id]}/postgresversions",
+            operation: :'ClustersApi.cluster_postgres_versions_get',
+            return_type: 'PostgresVersionList',
+            result: @postgres_versions,
+          },
+        ],
+      )
+
+      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