knife-ionoscloud 6.1.0 → 6.2.0

data/lib/chef/knife/ionoscloud_volume_delete.rb

@@ -18,7 +18,7 @@ class Chef
         'Deletes the specified volume. This will result in the volume being '\
         'removed from your virtual data center. Please use this with caution!'
         @directory = 'compute-engine'
-        @required_options = [:datacenter_id, :ionoscloud_username, :ionoscloud_password]
+        @required_options = [:datacenter_id]
       end
 
       def run
@@ -45,7 +45,7 @@ class Chef
 
           begin
             confirm('Do you really want to delete this volume')
-          rescue SystemExit => exc
+          rescue SystemExit
             next
           end
 

data/lib/chef/knife/ionoscloud_volume_detach.rb

@@ -20,12 +20,12 @@ class Chef
       def initialize(args = [])
         super(args)
         @description =
-        "This will detach the volume from the server. Depending on the volume "\
+        'This will detach the volume from the server. Depending on the volume '\
         "HotUnplug settings, this may result in the server being rebooted.\n\n"\
-        "This will NOT delete the volume from your virtual data center. You will "\
-        "need to make a separate request to delete a volume."
+        'This will NOT delete the volume from your virtual data center. You will '\
+        'need to make a separate request to delete a volume.'
         @directory = 'compute-engine'
-        @required_options = [:datacenter_id, :server_id, :ionoscloud_username, :ionoscloud_password]
+        @required_options = [:datacenter_id, :server_id]
       end
 
       def run
@@ -59,7 +59,7 @@ class Chef
 
           begin
             confirm('Do you really want to detach this volume')
-          rescue SystemExit => exc
+          rescue SystemExit
             next
           end
 

data/lib/chef/knife/ionoscloud_volume_get.rb

@@ -21,7 +21,7 @@ class Chef
         @description =
         'Retrieves the attributes of a given Volume.'
         @directory = 'compute-engine'
-        @required_options = [:datacenter_id, :volume_id, :ionoscloud_username, :ionoscloud_password]
+        @required_options = [:datacenter_id, :volume_id]
       end
 
       def run

data/lib/chef/knife/ionoscloud_volume_list.rb

@@ -23,7 +23,7 @@ class Chef
         'List all available volumes under a data center. '\
         'You can also list all volumes attached to a specific server.'
         @directory = 'compute-engine'
-        @required_options = [:datacenter_id, :ionoscloud_username, :ionoscloud_password]
+        @required_options = [:datacenter_id]
       end
 
       def run

data/lib/chef/knife/ionoscloud_volume_update.rb

@@ -60,7 +60,7 @@ class Chef
         @description =
         'Updates information about a Ionoscloud Volume.'
         @directory = 'compute-engine'
-        @required_options = [:datacenter_id, :volume_id, :ionoscloud_username, :ionoscloud_password]
+        @required_options = [:datacenter_id, :volume_id]
         @updatable_fields = [
           :name, :size, :bus, :cpu_hot_plug, :ram_hot_plug, :nic_hot_plug, :nic_hot_unplug, :disc_virtio_hot_plug, :disc_virtio_hot_unplug,
         ]

data/lib/knife-ionoscloud/version.rb

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

data/sonar-project.properties

@@ -1,6 +1,9 @@
 sonar.projectKey=knife-plugin
 sonar.organization=ionos-cloud
 
+sonar.ruby.coverage.reportPaths=coverage/coverage.json
+sonar.cpd.exclusions=spec/chef/knife/*.rb
+
 # This is the name and version displayed in the SonarCloud UI.
 #sonar.projectName=knife-plugin
 #sonar.projectVersion=1.0

data/spec/chef/knife/ionoscloud_applicationloadbalancer_create_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+require 'ionoscloud_applicationloadbalancer_create'
+
+Chef::Knife::IonoscloudApplicationloadbalancerCreate.load_deps
+
+describe Chef::Knife::IonoscloudApplicationloadbalancerCreate do
+  before :each do
+    subject { Chef::Knife::IonoscloudApplicationloadbalancerCreate.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call ApplicationLoadBalancersApi.datacenters_applicationloadbalancers_post with the expected arguments and output based on what it receives' do
+      application_loadbalancer = application_loadbalancer_mock
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        datacenter_id: 'datacenter_id',
+        name: application_loadbalancer.properties.name,
+        ips: application_loadbalancer.properties.ips.join(','),
+        listener_lan: application_loadbalancer.properties.listener_lan,
+        target_lan: application_loadbalancer.properties.target_lan,
+        lb_private_ips: application_loadbalancer.properties.lb_private_ips.join(','),
+      }.each do |key, value|
+        subject.config[key] = value
+      end
+
+      expect(subject).to receive(:puts).with("ID: #{application_loadbalancer.id}")
+      expect(subject).to receive(:puts).with("Name: #{application_loadbalancer.properties.name}")
+      expect(subject).to receive(:puts).with("Listener LAN: #{application_loadbalancer.properties.listener_lan}")
+      expect(subject).to receive(:puts).with("IPS: #{application_loadbalancer.properties.ips}")
+      expect(subject).to receive(:puts).with("Target LAN: #{application_loadbalancer.properties.target_lan}")
+      expect(subject).to receive(:puts).with("Lb Private IPS: #{application_loadbalancer.properties.lb_private_ips}")
+
+      mock_wait_for(subject)
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'POST',
+            path: "/datacenters/#{subject_config[:datacenter_id]}/applicationloadbalancers",
+            operation: :'ApplicationLoadBalancersApi.datacenters_applicationloadbalancers_post',
+            return_type: 'ApplicationLoadBalancer',
+            body: { properties: application_loadbalancer.properties.to_hash },
+            result: application_loadbalancer,
+          },
+          {
+            method: 'GET',
+            path: "/datacenters/#{subject_config[:datacenter_id]}/applicationloadbalancers/#{application_loadbalancer.id}",
+            operation: :'ApplicationLoadBalancersApi.datacenters_applicationloadbalancers_find_by_application_load_balancer_id',
+            return_type: 'ApplicationLoadBalancer',
+            result: application_loadbalancer,
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should not make any call if any required option is missing' do
+      required_options = subject.instance_variable_get(:@required_options)
+
+      if required_options.length > 0
+        arrays_without_one_element(required_options).each do |test_case|
+          subject.config[:ionoscloud_token] = 'token'
+          test_case[:array].each { |value| subject.config[value] = 'test' }
+
+          expect(subject).to receive(:puts).with("Missing required parameters #{test_case[:removed]}")
+          expect(subject.api_client).not_to receive(:call_api)
+
+          expect { subject.run }.to raise_error(SystemExit) do |error|
+            expect(error.status).to eq(1)
+          end
+
+          required_options.each { |value| subject.config[value] = nil }
+        end
+      end
+    end
+  end
+end

data/spec/chef/knife/ionoscloud_applicationloadbalancer_delete_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+require 'ionoscloud_applicationloadbalancer_delete'
+
+Chef::Knife::IonoscloudApplicationloadbalancerDelete.load_deps
+
+describe Chef::Knife::IonoscloudApplicationloadbalancerDelete do
+  before :each do
+    subject { Chef::Knife::IonoscloudApplicationloadbalancerDelete.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call ApplicationLoadBalancersApi.datacenters_applicationloadbalancers_delete when the ID is valid' do
+      application_loadbalancer = application_loadbalancer_mock
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        datacenter_id: 'datacenter_id',
+        yes: true,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+      subject.name_args = [application_loadbalancer.id]
+
+      expect(subject).to receive(:puts).with("ID: #{application_loadbalancer.id}")
+      expect(subject).to receive(:puts).with("Name: #{application_loadbalancer.properties.name}")
+      expect(subject).to receive(:puts).with("Listener LAN: #{application_loadbalancer.properties.listener_lan}")
+      expect(subject).to receive(:puts).with("IPS: #{application_loadbalancer.properties.ips}")
+      expect(subject).to receive(:puts).with("Target LAN: #{application_loadbalancer.properties.target_lan}")
+      expect(subject).to receive(:puts).with("Lb Private IPS: #{application_loadbalancer.properties.lb_private_ips}")
+      expect(subject).to receive(:puts).with("Rules: #{subject.get_application_loadbalancer_extended_properties(application_loadbalancer)}")
+
+      expect(subject.ui).to receive(:warn).with("Deleted Application Load balancer #{application_loadbalancer.id}. Request ID: ")
+
+      expect(subject.api_client).not_to receive(:wait_for)
+      expect(subject).to receive(:get_request_id).once
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: "/datacenters/#{subject_config[:datacenter_id]}/applicationloadbalancers/#{application_loadbalancer.id}",
+            operation: :'ApplicationLoadBalancersApi.datacenters_applicationloadbalancers_find_by_application_load_balancer_id',
+            return_type: 'ApplicationLoadBalancer',
+            result: application_loadbalancer,
+          },
+          {
+            method: 'DELETE',
+            path: "/datacenters/#{subject_config[:datacenter_id]}/applicationloadbalancers/#{application_loadbalancer.id}",
+            operation: :'ApplicationLoadBalancersApi.datacenters_applicationloadbalancers_delete',
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should not call ApplicationLoadBalancersApi.datacenters_applicationloadbalancers_delete when the ID is not valid' do
+      application_loadbalancer_id = 'invalid_id'
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        datacenter_id: 'datacenter_id',
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+      subject.name_args = [application_loadbalancer_id]
+
+      expect(subject.ui).to receive(:error).with("Application Load balancer ID #{application_loadbalancer_id} not found. Skipping.")
+
+      expect(subject.api_client).not_to receive(:wait_for)
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: "/datacenters/#{subject_config[:datacenter_id]}/applicationloadbalancers/#{application_loadbalancer_id}",
+            operation: :'ApplicationLoadBalancersApi.datacenters_applicationloadbalancers_find_by_application_load_balancer_id',
+            return_type: 'ApplicationLoadBalancer',
+            exception: Ionoscloud::ApiError.new(code: 404),
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should not make any call if any required option is missing' do
+      required_options = subject.instance_variable_get(:@required_options)
+
+      if required_options.length > 0
+        arrays_without_one_element(required_options).each do |test_case|
+          subject.config[:ionoscloud_token] = 'token'
+          test_case[:array].each { |value| subject.config[value] = 'test' }
+
+          expect(subject).to receive(:puts).with("Missing required parameters #{test_case[:removed]}")
+          expect(subject.api_client).not_to receive(:call_api)
+
+          expect { subject.run }.to raise_error(SystemExit) do |error|
+            expect(error.status).to eq(1)
+          end
+
+          required_options.each { |value| subject.config[value] = nil }
+        end
+      end
+    end
+  end
+end

data/spec/chef/knife/ionoscloud_applicationloadbalancer_get_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+require 'ionoscloud_applicationloadbalancer_get'
+
+Chef::Knife::IonoscloudApplicationloadbalancerGet.load_deps
+
+describe Chef::Knife::IonoscloudApplicationloadbalancerGet do
+  before :each do
+    subject { Chef::Knife::IonoscloudApplicationloadbalancerGet.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call LoadBalancersApi.datacenters_applicationloadbalancers_get' do
+      application_load_balancer = application_loadbalancer_mock
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        datacenter_id: 'datacenter_id',
+        application_loadbalancer_id: application_load_balancer.id,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      expect(subject).to receive(:puts).with("ID: #{application_load_balancer.id}")
+      expect(subject).to receive(:puts).with("Name: #{application_load_balancer.properties.name}")
+      expect(subject).to receive(:puts).with("Listener LAN: #{application_load_balancer.properties.listener_lan}")
+      expect(subject).to receive(:puts).with("IPS: #{application_load_balancer.properties.ips}")
+      expect(subject).to receive(:puts).with("Target LAN: #{application_load_balancer.properties.target_lan}")
+      expect(subject).to receive(:puts).with("Lb Private IPS: #{application_load_balancer.properties.lb_private_ips}")
+      expect(subject).to receive(:puts).with("Rules: #{subject.get_application_loadbalancer_extended_properties(application_load_balancer)}")
+
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: "/datacenters/#{subject_config[:datacenter_id]}/applicationloadbalancers/#{subject_config[:application_loadbalancer_id]}",
+            operation: :'ApplicationLoadBalancersApi.datacenters_applicationloadbalancers_find_by_application_load_balancer_id',
+            return_type: 'ApplicationLoadBalancer',
+            result: application_load_balancer,
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should not make any call if any required option is missing' do
+      required_options = subject.instance_variable_get(:@required_options)
+
+      if required_options.length > 0
+        arrays_without_one_element(required_options).each do |test_case|
+          subject.config[:ionoscloud_token] = 'token'
+          test_case[:array].each { |value| subject.config[value] = 'test' }
+
+          expect(subject).to receive(:puts).with("Missing required parameters #{test_case[:removed]}")
+          expect(subject.api_client).not_to receive(:call_api)
+
+          expect { subject.run }.to raise_error(SystemExit) do |error|
+            expect(error.status).to eq(1)
+          end
+
+          required_options.each { |value| subject.config[value] = nil }
+        end
+      end
+    end
+  end
+end

data/spec/chef/knife/ionoscloud_applicationloadbalancer_list_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+require 'ionoscloud_applicationloadbalancer_list'
+
+Chef::Knife::IonoscloudApplicationloadbalancerList.load_deps
+
+describe Chef::Knife::IonoscloudApplicationloadbalancerList do
+  before :each do
+    subject { Chef::Knife::IonoscloudApplicationloadbalancerList.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call ApplicationLoadBalancersApi.datacenters_applicationloadbalancers_get' do
+      application_loadbalancers = application_loadbalancers_mock
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        datacenter_id: 'datacenter_id',
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      application_loadbalancer_list = [
+        subject.ui.color('ID', :bold),
+        subject.ui.color('Name', :bold),
+        subject.ui.color('Listener LAN', :bold),
+        subject.ui.color('Target LAN', :bold),
+        subject.ui.color('Rules', :bold),
+        subject.ui.color('IPS', :bold),
+        subject.ui.color('Private IPS', :bold),
+        application_loadbalancers.items.first.id,
+        application_loadbalancers.items.first.properties.name,
+        application_loadbalancers.items.first.properties.listener_lan,
+        application_loadbalancers.items.first.properties.target_lan,
+        application_loadbalancers.items.first.entities.forwardingrules.items.length,
+        application_loadbalancers.items.first.properties.ips,
+        application_loadbalancers.items.first.properties.lb_private_ips,
+        application_loadbalancers.items[1].id,
+        application_loadbalancers.items[1].properties.name,
+        application_loadbalancers.items[1].properties.listener_lan,
+        application_loadbalancers.items[1].properties.target_lan,
+        application_loadbalancers.items[1].entities.forwardingrules.items.length,
+        application_loadbalancers.items[1].properties.ips,
+        application_loadbalancers.items[1].properties.lb_private_ips,
+      ]
+
+      expect(subject.ui).to receive(:list).with(application_loadbalancer_list, :uneven_columns_across, 7)
+
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: "/datacenters/#{subject_config[:datacenter_id]}/applicationloadbalancers",
+            operation: :'ApplicationLoadBalancersApi.datacenters_applicationloadbalancers_get',
+            return_type: 'ApplicationLoadBalancers',
+            result: application_loadbalancers,
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should not make any call if any required option is missing' do
+      required_options = subject.instance_variable_get(:@required_options)
+
+      if required_options.length > 0
+        arrays_without_one_element(required_options).each do |test_case|
+          subject.config[:ionoscloud_token] = 'token'
+          test_case[:array].each { |value| subject.config[value] = 'test' }
+
+          expect(subject).to receive(:puts).with("Missing required parameters #{test_case[:removed]}")
+          expect(subject.api_client).not_to receive(:call_api)
+
+          expect { subject.run }.to raise_error(SystemExit) do |error|
+            expect(error.status).to eq(1)
+          end
+
+          required_options.each { |value| subject.config[value] = nil }
+        end
+      end
+    end
+  end
+end

data/spec/chef/knife/ionoscloud_applicationloadbalancer_rule_add_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+require 'ionoscloud_applicationloadbalancer_rule_add'
+
+Chef::Knife::IonoscloudApplicationloadbalancerRuleAdd.load_deps
+
+describe Chef::Knife::IonoscloudApplicationloadbalancerRuleAdd do
+  before :each do
+    subject { Chef::Knife::IonoscloudApplicationloadbalancerRuleAdd.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call ApplicationLoadBalancersApi.datacenters_applicationloadbalancers_forwardingrules_post_with_http_info' do
+      application_loadbalancer = application_loadbalancer_mock
+      application_loadbalancer_rule = application_loadbalancer_rule_mock
+
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        datacenter_id: 'datacenter_id',
+        application_loadbalancer_id: application_loadbalancer.id,
+        name: application_loadbalancer_rule.properties.name,
+        protocol: application_loadbalancer_rule.properties.protocol,
+        listener_ip: application_loadbalancer_rule.properties.listener_ip,
+        listener_port: application_loadbalancer_rule.properties.listener_port,
+        client_timeout: application_loadbalancer_rule.properties.client_timeout,
+        server_certificates: application_loadbalancer_rule.properties.server_certificates.join(','),
+        http_rules: application_loadbalancer_rule.properties.http_rules.map do |el|
+          hash = el.to_hash
+          hash[:conditions].map! do |condition|
+            condition.collect { |k, v| [k.to_s, v] }.to_h
+          end
+          {
+            'name' => hash[:name],
+            'type' => hash[:type],
+            'target_group' => hash[:targetGroup],
+            'drop_query' => hash[:dropQuery],
+            'location' => hash[:location],
+            'status_code' => hash[:statusCode],
+            'response_message' => hash[:responseMessage],
+            'content_type' => hash[:contentType],
+            'conditions' => hash[:conditions],
+          }
+        end,
+        yes: true,
+
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      expect(subject).to receive(:puts).with("ID: #{application_loadbalancer.id}")
+      expect(subject).to receive(:puts).with("Name: #{application_loadbalancer.properties.name}")
+      expect(subject).to receive(:puts).with("Listener LAN: #{application_loadbalancer.properties.listener_lan}")
+      expect(subject).to receive(:puts).with("IPS: #{application_loadbalancer.properties.ips}")
+      expect(subject).to receive(:puts).with("Target LAN: #{application_loadbalancer.properties.target_lan}")
+      expect(subject).to receive(:puts).with("Lb Private IPS: #{application_loadbalancer.properties.lb_private_ips}")
+      expect(subject).to receive(:puts).with("Rules: #{
+        (application_loadbalancer.entities.forwardingrules.items + [application_loadbalancer_rule]).map do |rule|
+        {
+          id: rule.id,
+          name: application_loadbalancer_rule.properties.name,
+          protocol: application_loadbalancer_rule.properties.protocol,
+          listener_ip: application_loadbalancer_rule.properties.listener_ip,
+          listener_port: application_loadbalancer_rule.properties.listener_port,
+          client_timeout: application_loadbalancer_rule.properties.client_timeout,
+          server_certificates: application_loadbalancer_rule.properties.server_certificates,
+          http_rules: rule.properties.http_rules.nil? ? [] : rule.properties.http_rules.map do |http_rule|
+            {
+              name: http_rule.name,
+              type: http_rule.type,
+              target_group: http_rule.target_group,
+              drop_query: http_rule.drop_query,
+              location: http_rule.location,
+              status_code: http_rule.status_code,
+              response_message: http_rule.response_message,
+              content_type: http_rule.content_type,
+              conditions: http_rule.conditions.nil? ? [] : http_rule.conditions.map do |condition|
+                {
+                  type: condition.type,
+                  condition: condition.condition,
+                  negate: condition.negate,
+                  key: condition.key,
+                  value: condition.value,
+                }
+              end,
+            }
+          end,
+        }
+      end}")
+
+      application_loadbalancer.entities.forwardingrules.items << application_loadbalancer_rule
+      expected_properties = application_loadbalancer_rule.properties.to_hash
+
+      mock_wait_for(subject)
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'POST',
+            path: "/datacenters/#{subject_config[:datacenter_id]}/applicationloadbalancers/#{subject_config[:application_loadbalancer_id]}/forwardingrules",
+            operation: :'ApplicationLoadBalancersApi.datacenters_applicationloadbalancers_forwardingrules_post',
+            body: { properties: expected_properties },
+            return_type: 'ApplicationLoadBalancerForwardingRule',
+          },
+          {
+            method: 'GET',
+            path: "/datacenters/#{subject_config[:datacenter_id]}/applicationloadbalancers/#{subject_config[:application_loadbalancer_id]}",
+            operation: :'ApplicationLoadBalancersApi.datacenters_applicationloadbalancers_find_by_application_load_balancer_id',
+            return_type: 'ApplicationLoadBalancer',
+            result: application_loadbalancer,
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should not make any call if any required option is missing' do
+      required_options = subject.instance_variable_get(:@required_options)
+
+      if required_options.length > 0
+        arrays_without_one_element(required_options).each do |test_case|
+          subject.config[:ionoscloud_token] = 'token'
+          test_case[:array].each { |value| subject.config[value] = 'test' }
+
+          expect(subject).to receive(:puts).with("Missing required parameters #{test_case[:removed]}")
+          expect(subject.api_client).not_to receive(:call_api)
+
+          expect { subject.run }.to raise_error(SystemExit) do |error|
+            expect(error.status).to eq(1)
+          end
+
+          required_options.each { |value| subject.config[value] = nil }
+        end
+      end
+    end
+  end
+end