knife-ionoscloud 6.0.0.beta.2 → 6.1.1

data/spec/chef/knife/ionoscloud_base_spec.rb

@@ -99,14 +99,13 @@ describe Chef::Knife::IonoscloudBaseTest do
       expect { subject.is_done? request_id }.to raise_error(SystemExit) do |error|
         expect(error.status).to eq(1)
       end
-
     end
   end
 
   describe '#get_request_id' do
     it 'should return nil when Headers has no Location key' do
       headers = {
-        'another_key' => '/requests/123'
+        'another_key' => '/requests/123',
       }
 
       expect(subject.get_request_id headers).to be_nil
@@ -114,7 +113,7 @@ describe Chef::Knife::IonoscloudBaseTest do
 
     it 'should return nil when Headers[\'Location\'] contains no uuid' do
       headers = {
-        'Location' => '/requests/123'
+        'Location' => '/requests/123',
       }
 
       expect(subject.get_request_id headers).to be_nil
@@ -123,7 +122,7 @@ describe Chef::Knife::IonoscloudBaseTest do
     it 'should extract the ID from the headers' do
       request_id = SecureRandom.uuid
       headers = {
-        'Location' => "/requests/#{request_id}"
+        'Location' => "/requests/#{request_id}",
       }
 
       expect(subject.get_request_id headers).to eql(request_id)

data/spec/chef/knife/ionoscloud_composite_server_create_spec.rb

@@ -97,7 +97,6 @@ describe Chef::Knife::IonoscloudCompositeServerCreate 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]}")

data/spec/chef/knife/ionoscloud_contract_list_spec.rb

@@ -69,7 +69,6 @@ describe Chef::Knife::IonoscloudContractList 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]}")

data/spec/chef/knife/ionoscloud_cube_server_create_spec.rb

@@ -60,7 +60,7 @@ describe Chef::Knife::IonoscloudCubeServerCreate do
       expect(subject).to receive(:puts).with("Ram: #{server.properties.ram}")
       expect(subject).to receive(:puts).with("Availability Zone: #{server.properties.availability_zone}")
       expect(subject).to receive(:puts).with("Boot Volume: #{server.entities.volumes.items.first.id}")
-      expect(subject).to receive(:puts).with("Boot CDROM: ")
+      expect(subject).to receive(:puts).with('Boot CDROM: ')
 
       expected_properties = server.properties.to_hash
       expected_properties.delete(:bootCdrom)
@@ -176,7 +176,7 @@ describe Chef::Knife::IonoscloudCubeServerCreate do
       expect(subject).to receive(:puts).with("Ram: #{server.properties.ram}")
       expect(subject).to receive(:puts).with("Availability Zone: #{server.properties.availability_zone}")
       expect(subject).to receive(:puts).with("Boot Volume: #{server.entities.volumes.items.first.id}")
-      expect(subject).to receive(:puts).with("Boot CDROM: ")
+      expect(subject).to receive(:puts).with('Boot CDROM: ')
 
       expected_properties = server.properties.to_hash
       expected_properties.delete(:bootCdrom)
@@ -232,7 +232,6 @@ describe Chef::Knife::IonoscloudCubeServerCreate 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]}")

data/spec/chef/knife/ionoscloud_datacenter_create_spec.rb

@@ -59,7 +59,6 @@ describe Chef::Knife::IonoscloudDatacenterCreate 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]}")

data/spec/chef/knife/ionoscloud_datacenter_delete_spec.rb

@@ -88,7 +88,6 @@ describe Chef::Knife::IonoscloudDatacenterDelete 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]}")

data/spec/chef/knife/ionoscloud_datacenter_get_spec.rb

@@ -52,7 +52,6 @@ describe Chef::Knife::IonoscloudDatacenterGet 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]}")

data/spec/chef/knife/ionoscloud_datacenter_list_spec.rb

@@ -61,7 +61,6 @@ describe Chef::Knife::IonoscloudDatacenterList 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]}")

data/spec/chef/knife/ionoscloud_datacenter_update_spec.rb

@@ -65,7 +65,6 @@ describe Chef::Knife::IonoscloudDatacenterUpdate 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]}")

data/spec/chef/knife/ionoscloud_dbaas_postgres_backup_get_spec.rb

@@ -0,0 +1,66 @@
+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,110 @@
+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,100 @@
+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)
+
+      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("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)
+
+      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("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)
+
+      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,85 @@
+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)
+
+      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