knife-ionoscloud 5.0.0 → 5.1.0

data/lib/chef/knife/ionoscloud_volume_list.rb

@@ -39,7 +39,7 @@ class Chef
           ui.color('Image', :bold),
           ui.color('Type', :bold),
           ui.color('Zone', :bold),
-          ui.color('Device Number', :bold)
+          ui.color('Device Number', :bold),
         ]
 
         opts = { depth: 1 }

data/lib/knife-ionoscloud/version.rb

@@ -1,6 +1,6 @@
 module Knife
   module Ionoscloud
-    VERSION = '5.0.0'
+    VERSION = '5.1.0'
     MAJOR, MINOR, TINY = VERSION.split('.')
   end
 end

data/spec/chef/knife/ionoscloud_group_create_spec.rb

@@ -24,6 +24,9 @@ describe Chef::Knife::IonoscloudGroupCreate do
         access_activity_log: group.properties.access_activity_log,
         s3_privilege: group.properties.s3_privilege,
         create_backup_unit: group.properties.create_backup_unit,
+        create_k8s_cluster: group.properties.create_k8s_cluster,
+        create_pcc: group.properties.create_pcc,
+        create_internet_access: group.properties.create_internet_access,
       }
 
       subject_config.each { |key, value| subject.config[key] = value }
@@ -36,6 +39,9 @@ describe Chef::Knife::IonoscloudGroupCreate do
       expect(subject).to receive(:puts).with("Access Activity Log: #{group.properties.access_activity_log.to_s}")
       expect(subject).to receive(:puts).with("S3 Privilege: #{group.properties.s3_privilege.to_s}")
       expect(subject).to receive(:puts).with("Create Backup Unit: #{group.properties.create_backup_unit.to_s}")
+      expect(subject).to receive(:puts).with("Create K8s Clusters: #{group.properties.create_k8s_cluster.to_s}")
+      expect(subject).to receive(:puts).with("Create PCC: #{group.properties.create_pcc.to_s}")
+      expect(subject).to receive(:puts).with("Create Internet Acess: #{group.properties.create_internet_access.to_s}")
 
       mock_wait_for(subject)
       mock_call_api(

data/spec/chef/knife/ionoscloud_image_list_spec.rb

@@ -24,16 +24,16 @@ describe Chef::Knife::IonoscloudImageList do
       image_list = [
         subject.ui.color('ID', :bold),
         subject.ui.color('Name', :bold),
-        subject.ui.color('Description', :bold),
         subject.ui.color('Location', :bold),
         subject.ui.color('Size', :bold),
         subject.ui.color('Public', :bold),
+        subject.ui.color('Aliases', :bold),
         images.items.first.id,
         images.items.first.properties.name,
-        images.items.first.properties.description,
         images.items.first.properties.location,
         images.items.first.properties.size.to_s,
         images.items.first.properties.public.to_s,
+        images.items.first.properties.image_aliases,
       ]
 
       expect(subject.ui).to receive(:list).with(image_list, :uneven_columns_across, 6)

data/spec/chef/knife/ionoscloud_ipblock_list_spec.rb

@@ -26,6 +26,7 @@ describe Chef::Knife::IonoscloudIpblockList do
         subject.ui.color('Name', :bold),
         subject.ui.color('Location', :bold),
         subject.ui.color('IP Addresses', :bold),
+        subject.ui.color('IP Consumers count', :bold),
       ]
 
       ipblocks.items.each do |ipblock|
@@ -33,9 +34,10 @@ describe Chef::Knife::IonoscloudIpblockList do
         ipblock_list << ipblock.properties.name
         ipblock_list << ipblock.properties.location
         ipblock_list << ipblock.properties.ips.join(', ')
+        ipblock_list << ipblock.properties.ip_consumers.nil? ? 0 : ipblock.properties.ip_consumers.length
       end
 
-      expect(subject.ui).to receive(:list).with(ipblock_list, :uneven_columns_across, 4)
+      expect(subject.ui).to receive(:list).with(ipblock_list, :uneven_columns_across, 5)
 
       mock_call_api(
         subject,

data/spec/chef/knife/ionoscloud_lan_create_spec.rb

@@ -20,6 +20,7 @@ describe Chef::Knife::IonoscloudLanCreate do
         datacenter_id: 'datacenter_id',
         name: lan.properties.name,
         public: lan.properties.public,
+        pcc: lan.properties.pcc,
       }
 
       subject_config.each { |key, value| subject.config[key] = value }
@@ -27,6 +28,7 @@ describe Chef::Knife::IonoscloudLanCreate do
       expect(subject).to receive(:puts).with("ID: #{lan.id}")
       expect(subject).to receive(:puts).with("Name: #{lan.properties.name}")
       expect(subject).to receive(:puts).with("Public: #{lan.properties.public.to_s}")
+      expect(subject).to receive(:puts).with("PCC: #{lan.properties.pcc}")
 
       expected_body = lan.properties.to_hash
       expected_body.delete(:ipFailover)

data/spec/chef/knife/ionoscloud_lan_list_spec.rb

@@ -26,15 +26,17 @@ describe Chef::Knife::IonoscloudLanList do
         subject.ui.color('ID', :bold),
         subject.ui.color('Name', :bold),
         subject.ui.color('Public', :bold),
+        subject.ui.color('PCC', :bold),
       ]
 
       lans.items.each do |lan|
         lan_list << lan.id
         lan_list << lan.properties.name
         lan_list << lan.properties.public.to_s
+        lan_list << lan.properties.pcc
       end
 
-      expect(subject.ui).to receive(:list).with(lan_list, :uneven_columns_across, 3)
+      expect(subject.ui).to receive(:list).with(lan_list, :uneven_columns_across, 4)
 
       mock_call_api(
         subject,

data/spec/chef/knife/ionoscloud_node_list_spec.rb

@@ -27,16 +27,18 @@ describe Chef::Knife::IonoscloudNodeList do
         subject.ui.color('ID', :bold),
         subject.ui.color('Name', :bold),
         subject.ui.color('Public IP', :bold),
+        subject.ui.color('Private IP', :bold),
         subject.ui.color('K8s Version', :bold),
         subject.ui.color('State', :bold),
         k8s_nodes.items.first.id,
         k8s_nodes.items.first.properties.name,
         k8s_nodes.items.first.properties.public_ip,
+        k8s_nodes.items.first.properties.private_ip,
         k8s_nodes.items.first.properties.k8s_version,
         k8s_nodes.items.first.metadata.state,
       ]
 
-      expect(subject.ui).to receive(:list).with(node_list, :uneven_columns_across, 5)
+      expect(subject.ui).to receive(:list).with(node_list, :uneven_columns_across, 6)
 
       mock_call_api(
         subject,

data/spec/chef/knife/ionoscloud_pcc_create_spec.rb

@@ -14,13 +14,14 @@ describe Chef::Knife::IonoscloudPccCreate do
   describe '#run' do
     it 'should call PrivateCrossConnectApi.pccs_post with the expected arguments and output based on what it receives' do
       pcc = pcc_mock
+      datacenter_ids = pcc.properties.connectable_datacenters.map { |datacenter| datacenter.id }
+      lan_ids = pcc.properties.peers.map { |peer| peer.id }
       subject_config = {
         ionoscloud_username: 'email',
         ionoscloud_password: 'password',
         name: pcc.properties.name,
         description: pcc.properties.description,
-        peers: pcc.properties.peers.join(','),
-        datacenters: pcc.properties.connectable_datacenters.join(','),
+        peers: datacenter_ids.zip(lan_ids).flatten.compact.join(','),
       }
 
       subject_config.each { |key, value| subject.config[key] = value }
@@ -31,7 +32,7 @@ describe Chef::Knife::IonoscloudPccCreate do
       expect(subject).to receive(:puts).with("Peers: #{pcc.properties.peers.to_s}")
       expect(subject).to receive(:puts).with("Datacenters: #{pcc.properties.connectable_datacenters.to_s}")
 
-      mock_wait_for(subject)
+      3.times { mock_wait_for(subject) }
       mock_call_api(
         subject,
         [
@@ -43,6 +44,36 @@ describe Chef::Knife::IonoscloudPccCreate do
             body: { properties: { name: pcc.properties.name, description: pcc.properties.description } },
             result: pcc,
           },
+          {
+            method: 'GET',
+            path: "/pccs/#{pcc.id}",
+            operation: :'PrivateCrossConnectApi.pccs_find_by_id',
+            return_type: 'PrivateCrossConnect',
+            result: pcc,
+          },
+          {
+            method: 'PATCH',
+            path: "/datacenters/#{pcc.properties.connectable_datacenters[0].id}/lans/#{pcc.properties.peers[0].id}",
+            operation: :'LanApi.datacenters_lans_patch',
+            return_type: 'Lan',
+            body: { pcc: pcc.id },
+            result: pcc.properties.peers[0],
+          },
+          {
+            method: 'PATCH',
+            path: "/datacenters/#{pcc.properties.connectable_datacenters[1].id}/lans/#{pcc.properties.peers[1].id}",
+            operation: :'LanApi.datacenters_lans_patch',
+            return_type: 'Lan',
+            body: { pcc: pcc.id },
+            result: pcc.properties.peers[1],
+          },
+          {
+            method: 'GET',
+            path: "/pccs/#{pcc.id}",
+            operation: :'PrivateCrossConnectApi.pccs_find_by_id',
+            return_type: 'PrivateCrossConnect',
+            result: pcc,
+          },
         ],
       )
 

data/spec/chef/knife/ionoscloud_request_list_spec.rb

@@ -84,7 +84,7 @@ describe Chef::Knife::IonoscloudRequestList do
       expect { subject.run }.not_to raise_error(Exception)
     end
 
-    it 'should call RequestApi.resources_get with default limit if it is not an Integers' do
+    it 'should call RequestApi.resources_get with default limit if it is not an Integer' do
       subject_config = {
         ionoscloud_username: 'email',
         ionoscloud_password: 'password',
@@ -144,6 +144,125 @@ describe Chef::Knife::IonoscloudRequestList do
       expect { subject.run }.not_to raise_error(Exception)
     end
 
+    it 'should call RequestApi.resources_get with the expected status when set' do
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        status: 'FAILED',
+        limit: 12,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      expect(subject.ui).to receive(:list).with(@request_list, :uneven_columns_across, 4)
+
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: '/requests',
+            operation: :'RequestApi.requests_get',
+            options: { depth: 2, limit: subject_config[:limit], offset: 0, filter_request_status: subject_config[:status] },
+            return_type: 'Requests',
+            result: @requests,
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should call RequestApi.resources_get with no status when set wrong' do
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        status: 'invalid',
+        limit: 12,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      expect(subject.ui).to receive(:list).with(@request_list, :uneven_columns_across, 4)
+      expect(subject.ui).to receive(:warn).with('status should be one of [QUEUED, RUNNING, DONE, FAILED]')
+
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: '/requests',
+            operation: :'RequestApi.requests_get',
+            options: { depth: 2, limit: subject_config[:limit], offset: 0 },
+            return_type: 'Requests',
+            result: @requests,
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+
+    it 'should call RequestApi.resources_get with the expected method when set' do
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        method: 'DELETE',
+        limit: 12,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      expect(subject.ui).to receive(:list).with(@request_list, :uneven_columns_across, 4)
+
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: '/requests',
+            operation: :'RequestApi.requests_get',
+            options: { depth: 2, limit: subject_config[:limit], offset: 0, filter_method: subject_config[:method] },
+            return_type: 'Requests',
+            result: @requests,
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should call RequestApi.resources_get with no method when set wrong' do
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        method: 'invalid',
+        limit: 12,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      expect(subject.ui).to receive(:list).with(@request_list, :uneven_columns_across, 4)
+      expect(subject.ui).to receive(:warn).with('method should be one of [POST, PUT, PATCH, DELETE]')
+
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: '/requests',
+            operation: :'RequestApi.requests_get',
+            options: { depth: 2, limit: subject_config[:limit], offset: 0 },
+            return_type: 'Requests',
+            result: @requests,
+          },
+        ],
+      )
+
+      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)
 

data/spec/chef/knife/ionoscloud_server_list_spec.rb

@@ -42,8 +42,8 @@ describe Chef::Knife::IonoscloudServerList do
         server_list << server.properties.ram.to_s
         server_list << server.properties.availability_zone
         server_list << server.properties.vm_state
-        server_list << server.properties.boot_volume || ''
-        server_list << server.properties.boot_cdrom || ''
+        server_list << (server.properties.boot_volume.nil? ? '' : server.properties.boot_volume.id)
+        server_list << (server.properties.boot_cdrom.nil? ? '' : server.properties.boot_cdrom.id)
       end
 
       expect(subject.ui).to receive(:list).with(server_list, :uneven_columns_across, 9)

data/spec/chef/knife/ionoscloud_snapshot_create_spec.rb

@@ -19,6 +19,10 @@ describe Chef::Knife::IonoscloudSnapshotCreate do
         ionoscloud_password: 'password',
         datacenter_id: 'datacenter_id',
         volume_id: 'volume_id',
+        name: snapshot_mock.properties.name,
+        description: snapshot_mock.properties.description,
+        licence_type: snapshot_mock.properties.licence_type,
+        sec_auth_protection: snapshot_mock.properties.sec_auth_protection,
       }
 
       subject_config.each { |key, value| subject.config[key] = value }
@@ -39,6 +43,12 @@ describe Chef::Knife::IonoscloudSnapshotCreate do
             operation: :'VolumeApi.datacenters_volumes_create_snapshot_post',
             return_type: 'Snapshot',
             result: snapshot,
+            form_params: {
+              'name' => snapshot_mock.properties.name,
+              'description' => snapshot_mock.properties.description,
+              'licenceType' => snapshot_mock.properties.licence_type,
+              'secAuthProtection' => snapshot_mock.properties.sec_auth_protection,
+            },
           },
           {
             method: 'GET',

data/spec/spec_helper.rb

@@ -34,7 +34,7 @@ def contract_mock(opts = {})
         ram_provisioned: opts[:ram_provisioned] || 4096,
         reservable_ips: opts[:reservable_ips] || 10,
         reserved_ips_in_use: opts[:reserved_ips_in_use] || 12,
-        reserved_ips_on_contract: opts[:reserved_ips_on_contract] || 20, 
+        reserved_ips_on_contract: opts[:reserved_ips_on_contract] || 20,
         ssd_limit_per_contract: opts[:ssd_limit_per_contract] || 600,
         ssd_limit_per_volume: opts[:ssd_limit_per_volume] || 300,
         ssd_volume_provisioned: opts[:ssd_volume_provisioned] || 50,
@@ -198,6 +198,7 @@ def lan_mock(opts = {})
     properties: Ionoscloud::LanProperties.new(
       name: opts[:name] || 'lan_name',
       public: opts[:public] || true,
+      pcc: opts[:pcc] || SecureRandom.uuid,
       ip_failover: opts[:ip_failover] || [],
     ),
   )
@@ -289,7 +290,7 @@ def image_mock(opts = {})
     id: opts[:id] || SecureRandom.uuid,
     properties: Ionoscloud::ImageProperties.new(
       name: opts[:name] || 'image_name',
-      description: opts[:description] || 'image_description',
+      image_aliases: opts[:image_aliases] || ['alias1', 'alias2'],
       location: opts[:location] || 'image_location',
       size: opts[:size] || 10,
       public: opts[:public] || true,
@@ -341,14 +342,14 @@ end
 
 def maintenance_window_mock(opts = {})
   Ionoscloud::KubernetesMaintenanceWindow.new(
-    day_of_the_week: opts[:day_of_the_week] || 'Sunday', 
+    day_of_the_week: opts[:day_of_the_week] || 'Sunday',
     time: opts[:time] || '23:03:19Z',
   )
 end
 
 def auto_scaling_mock(opts = {})
   Ionoscloud::KubernetesAutoScaling.new(
-    min_node_count: opts[:min_node_count] || 2, 
+    min_node_count: opts[:min_node_count] || 2,
     max_node_count: opts[:max_node_count] || 3,
   )
 end
@@ -559,6 +560,7 @@ def snapshot_mock(opts = {})
       name: opts[:name] || 'snapshot_name',
       description: opts[:description] || 'snapshot_description',
       licence_type: opts[:licence_type] || 'LINUX',
+      sec_auth_protection: opts[:sec_auth_protection] || true,
       location: opts[:location] || 'de/fra',
       size: opts[:size] || 10.0,
     ),
@@ -584,6 +586,9 @@ def group_mock(opts = {})
       access_activity_log: opts[:access_activity_log] || true,
       s3_privilege: opts[:s3_privilege] || true,
       create_backup_unit: opts[:create_backup_unit] || true,
+      create_k8s_cluster: opts[:create_k8s_cluster] || true,
+      create_pcc: opts[:create_pcc] || true,
+      create_internet_access: opts[:create_internet_access] || true,
     ),
     entities: Ionoscloud::GroupEntities.new(
       users: group_members_mock,
@@ -610,7 +615,7 @@ end
 def user_mock(opts = {})
   Ionoscloud::User.new(
     id: opts[:id] || SecureRandom.uuid,
-    properties: Ionoscloud::UserProperties.new(
+    properties: Ionoscloud::UserPropertiesPost.new(
       firstname: opts[:firstname] || 'Firstname',
       lastname: opts[:lastname] || 'Lastname',
       email: opts[:email] || 'a@a.a',
@@ -668,8 +673,8 @@ def requests_mock(opts = {})
 end
 
 def arrays_without_one_element(arr)
-  result = [{ array: arr[1..], removed: [arr[0]]}]
-  (1..arr.length - 1).each { |i| result.append({ array: arr[0..i-1] + arr[i+1..], removed: [arr[i]]}) }
+  result = [{ array: arr[1..], removed: [arr[0]] }]
+  (1..arr.length - 1).each { |i| result.append({ array: arr[0..i - 1] + arr[i + 1..], removed: [arr[i]] }) }
   result
 end