knife-ionoscloud 6.1.2 → 6.2.0

data/spec/chef/knife/ionoscloud_targetgroup_get_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require 'ionoscloud_targetgroup_get'
+
+Chef::Knife::IonoscloudTargetgroupGet.load_deps
+
+describe Chef::Knife::IonoscloudTargetgroupGet do
+  before :each do
+    subject { Chef::Knife::IonoscloudTargetgroupGet.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call TargetGroupsApi.targetgroups_find_by_target_group_id' do
+      target_group = target_group_mock
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        target_group_id: target_group.id,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      health_check, http_health_check, targets = subject.get_target_group_extended_properties(target_group)
+
+      expect(subject).to receive(:puts).with("ID: #{target_group.id}")
+      expect(subject).to receive(:puts).with("Name: #{target_group.properties.name}")
+      expect(subject).to receive(:puts).with("Algorithm: #{target_group.properties.algorithm}")
+      expect(subject).to receive(:puts).with("Protocol: #{target_group.properties.protocol}")
+      expect(subject).to receive(:puts).with("Health Check: #{health_check}")
+      expect(subject).to receive(:puts).with("HTTP Health Check: #{http_health_check}")
+      expect(subject).to receive(:puts).with("Targets: #{targets}")
+
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: "/targetgroups/#{subject_config[:target_group_id]}",
+            operation: :'TargetGroupsApi.targetgroups_find_by_target_group_id',
+            return_type: 'TargetGroup',
+            result: target_group,
+          },
+        ],
+      )
+
+      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_targetgroup_list_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+require 'ionoscloud_targetgroup_list'
+
+Chef::Knife::IonoscloudTargetgroupList.load_deps
+
+describe Chef::Knife::IonoscloudTargetgroupList do
+  before :each do
+    subject { Chef::Knife::IonoscloudTargetgroupList.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call DataCentersApi.datacenters_get' do
+      target_groups = target_groups_mock
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      target_group_list = [
+        subject.ui.color('ID', :bold),
+        subject.ui.color('Name', :bold),
+        subject.ui.color('Algorithm', :bold),
+        subject.ui.color('Protocol', :bold),
+        subject.ui.color('Targets', :bold),
+      ]
+
+      target_groups.items.each do |target_group|
+        target_group_list << target_group.id
+        target_group_list << target_group.properties.name
+        target_group_list << target_group.properties.algorithm
+        target_group_list << target_group.properties.protocol
+        target_group_list << target_group.properties.targets.nil? ? 0 : target_group.properties.targets.length
+      end
+
+      expect(subject.ui).to receive(:list).with(target_group_list, :uneven_columns_across, 5)
+
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: '/targetgroups',
+            operation: :'TargetGroupsApi.targetgroups_get',
+            return_type: 'TargetGroups',
+            result: target_groups,
+          },
+        ],
+      )
+
+      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_targetgroup_target_add_spec.rb

@@ -0,0 +1,164 @@
+require 'spec_helper'
+require 'ionoscloud_targetgroup_target_add'
+
+Chef::Knife::IonoscloudTargetgroupTargetAdd.load_deps
+
+describe Chef::Knife::IonoscloudTargetgroupTargetAdd do
+  before :each do
+    subject { Chef::Knife::IonoscloudTargetgroupTargetAdd.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call TargetGroupsApi.targetgroups_patch and add a new target when needed' do
+      target_group = target_group_mock
+      target = target_group_target_mock(ip: '127.0.0.2', port: 22)
+
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        target_group_id: target_group.id,
+        ip: target.ip,
+        port: target.port,
+        weight: target.weight,
+        health_check_disabled: !target.health_check_enabled,
+        maintenance_enabled: target.maintenance_enabled,
+        yes: true,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      health_check, http_health_check, targets = subject.get_target_group_extended_properties(target_group)
+
+      expect(subject).to receive(:puts).with("ID: #{target_group.id}")
+      expect(subject).to receive(:puts).with("Name: #{target_group.properties.name}")
+      expect(subject).to receive(:puts).with("Algorithm: #{target_group.properties.algorithm}")
+      expect(subject).to receive(:puts).with("Protocol: #{target_group.properties.protocol}")
+      expect(subject).to receive(:puts).with("Health Check: #{health_check}")
+      expect(subject).to receive(:puts).with("HTTP Health Check: #{http_health_check}")
+      expect(subject).to receive(:puts).with("Targets: #{targets + [{
+        ip: target.ip,
+        port: target.port,
+        weight: target.weight,
+        health_check_enabled: target.health_check_enabled,
+        maintenance_enabled: target.maintenance_enabled,
+      }]}")
+
+      expected_properties = target_group.properties.to_hash
+      expected_properties[:targets] << target.to_hash
+
+      mock_wait_for(subject)
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: "/targetgroups/#{target_group.id}",
+            operation: :'TargetGroupsApi.targetgroups_find_by_target_group_id',
+            return_type: 'TargetGroup',
+            result: target_group,
+          },
+          {
+            method: 'PATCH',
+            path: "/targetgroups/#{target_group.id}",
+            operation: :'TargetGroupsApi.targetgroups_patch',
+            body: expected_properties,
+            return_type: 'TargetGroup',
+            result: target_group,
+          },
+          {
+            method: 'GET',
+            path: "/targetgroups/#{target_group.id}",
+            operation: :'TargetGroupsApi.targetgroups_find_by_target_group_id',
+            return_type: 'TargetGroup',
+            result: target_group,
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should not call TargetGroupsApi.targetgroups_patch and notify the user when the target already exists' do
+      target_group = target_group_mock
+      target = target_group_target_mock(weight: 100, check: false, maintenance: true, check_interval: 3000)
+
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        target_group_id: target_group.id,
+        ip: target.ip,
+        port: target.port,
+        weight: target.weight,
+        health_check_disabled: !target.health_check_enabled,
+        maintenance_enabled: target.maintenance_enabled,
+        yes: true,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      health_check, http_health_check, _ = subject.get_target_group_extended_properties(target_group)
+
+      expect(subject.ui).to receive(:warn).with("Specified target already exists (#{target_group.properties.targets.first}).")
+
+      expect(subject).to receive(:puts).with("ID: #{target_group.id}")
+      expect(subject).to receive(:puts).with("Name: #{target_group.properties.name}")
+      expect(subject).to receive(:puts).with("Algorithm: #{target_group.properties.algorithm}")
+      expect(subject).to receive(:puts).with("Protocol: #{target_group.properties.protocol}")
+      expect(subject).to receive(:puts).with("Health Check: #{health_check}")
+      expect(subject).to receive(:puts).with("HTTP Health Check: #{http_health_check}")
+      expect(subject).to receive(:puts).with("Targets: #{[{
+        ip: target_group.properties.targets.first.ip,
+        port: target_group.properties.targets.first.port,
+        weight: target_group.properties.targets.first.weight,
+        health_check_enabled: target_group.properties.targets.first.health_check_enabled,
+        maintenance_enabled: target_group.properties.targets.first.maintenance_enabled,
+      }]}")
+
+      expect(subject).not_to receive(:wait_for)
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: "/targetgroups/#{target_group.id}",
+            operation: :'TargetGroupsApi.targetgroups_find_by_target_group_id',
+            return_type: 'TargetGroup',
+            result: target_group,
+          },
+          {
+            method: 'GET',
+            path: "/targetgroups/#{target_group.id}",
+            operation: :'TargetGroupsApi.targetgroups_find_by_target_group_id',
+            return_type: 'TargetGroup',
+            result: target_group,
+          },
+        ],
+      )
+
+      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_targetgroup_target_remove_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+require 'ionoscloud_targetgroup_target_remove'
+
+Chef::Knife::IonoscloudTargetgroupTargetRemove.load_deps
+
+describe Chef::Knife::IonoscloudTargetgroupTargetRemove do
+  before :each do
+    subject { Chef::Knife::IonoscloudTargetgroupTargetRemove.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should not call TargetGroupsApi.targetgroups_patch when the specified target does not exist in the Target Group' do
+      target_group = target_group_mock
+      target = target_group_target_mock(ip: '127.0.0.2', port: 22)
+
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        target_group_id: target_group.id,
+        ip: target.ip,
+        port: target.port,
+        yes: true,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      health_check, http_health_check, targets = subject.get_target_group_extended_properties(target_group)
+
+      expect(subject).to receive(:puts).with("ID: #{target_group.id}")
+      expect(subject).to receive(:puts).with("Name: #{target_group.properties.name}")
+      expect(subject).to receive(:puts).with("Algorithm: #{target_group.properties.algorithm}")
+      expect(subject).to receive(:puts).with("Protocol: #{target_group.properties.protocol}")
+      expect(subject).to receive(:puts).with("Health Check: #{health_check}")
+      expect(subject).to receive(:puts).with("HTTP Health Check: #{http_health_check}")
+      expect(subject).to receive(:puts).with("Targets: #{targets}")
+
+      expect(subject.ui).to receive(:warn).with("Specified target does not exist (#{subject_config[:ip]}:#{subject_config[:port]}).")
+
+      expect(subject).not_to receive(:wait_for)
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: "/targetgroups/#{target_group.id}",
+            operation: :'TargetGroupsApi.targetgroups_find_by_target_group_id',
+            return_type: 'TargetGroup',
+            result: target_group,
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should call TargetGroupsApi.targetgroups_patch and remove the target when it exists' do
+      target_group = target_group_mock
+      target = target_group_target_mock
+
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        target_group_id: target_group.id,
+        ip: target.ip,
+        port: target.port,
+        yes: true,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      health_check, http_health_check, _ = subject.get_target_group_extended_properties(target_group)
+
+      expect(subject).to receive(:puts).with("ID: #{target_group.id}")
+      expect(subject).to receive(:puts).with("Name: #{target_group.properties.name}")
+      expect(subject).to receive(:puts).with("Algorithm: #{target_group.properties.algorithm}")
+      expect(subject).to receive(:puts).with("Protocol: #{target_group.properties.protocol}")
+      expect(subject).to receive(:puts).with("Health Check: #{health_check}")
+      expect(subject).to receive(:puts).with("HTTP Health Check: #{http_health_check}")
+      expect(subject).to receive(:puts).with("Targets: #{[]}")
+
+      expected_properties = target_group.properties.to_hash
+      expected_properties[:targets] = []
+
+      mock_wait_for(subject)
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: "/targetgroups/#{target_group.id}",
+            operation: :'TargetGroupsApi.targetgroups_find_by_target_group_id',
+            return_type: 'TargetGroup',
+            result: target_group,
+          },
+          {
+            method: 'PATCH',
+            path: "/targetgroups/#{target_group.id}",
+            operation: :'TargetGroupsApi.targetgroups_patch',
+            body: expected_properties,
+            return_type: 'TargetGroup',
+            result: target_group,
+          },
+          {
+            method: 'GET',
+            path: "/targetgroups/#{target_group.id}",
+            operation: :'TargetGroupsApi.targetgroups_find_by_target_group_id',
+            return_type: 'TargetGroup',
+            result: target_group,
+          },
+        ],
+      )
+
+      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_targetgroup_update_spec.rb

@@ -0,0 +1,144 @@
+require 'spec_helper'
+require 'ionoscloud_targetgroup_update'
+
+Chef::Knife::IonoscloudTargetgroupUpdate.load_deps
+
+describe Chef::Knife::IonoscloudTargetgroupUpdate do
+  before :each do
+    subject { Chef::Knife::IonoscloudTargetgroupUpdate.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call TargetGroupsApi.targetgroups_patch' do
+      new_target = target_group_target_mock(
+        ip: '127.9.9.9',
+        port: 90,
+        weight: 50,
+        check: false,
+        check_interval: 1234,
+        maintenance: true,
+      )
+      target_group = target_group_mock
+
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        target_group_id: 'target_group_id',
+        name: target_group.properties.name + '_edited',
+        algorithm: 'RANDOM',
+        check_timeout: target_group.properties.health_check.check_timeout + 100,
+        check_interval: target_group.properties.health_check.check_interval + 100,
+        retries: target_group.properties.health_check.retries + 10,
+        path: target_group.properties.http_health_check.path + '_edited',
+        method: 'POST',
+        response: target_group.properties.http_health_check.response + ' edited',
+        regex: !target_group.properties.http_health_check.regex,
+        negate: !target_group.properties.http_health_check.negate,
+        targets: [{
+          'ip' => new_target.ip,
+          'port' => new_target.port,
+          'weight' => new_target.weight,
+          'health_check_enabled' => new_target.health_check_enabled,
+          'maintenance_enabled' => new_target.maintenance_enabled,
+        }],
+        yes: true,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+
+      target_group.properties.name = subject_config[:name]
+      target_group.properties.algorithm = subject_config[:algorithm]
+      target_group.properties.health_check.check_timeout = subject_config[:check_timeout]
+      target_group.properties.health_check.check_interval = subject_config[:check_interval]
+      target_group.properties.health_check.retries = subject_config[:retries]
+      target_group.properties.health_check.check_timeout = subject_config[:check_timeout]
+      target_group.properties.http_health_check.method = subject_config[:method]
+      target_group.properties.http_health_check.path = subject_config[:path]
+      target_group.properties.http_health_check.response = subject_config[:response]
+      target_group.properties.http_health_check.regex = subject_config[:regex]
+      target_group.properties.http_health_check.negate = subject_config[:negate]
+
+      target_group.properties.targets = [new_target]
+
+      health_check, http_health_check, targets = subject.get_target_group_extended_properties(target_group)
+
+      expect(subject).to receive(:puts).with("ID: #{target_group.id}")
+      expect(subject).to receive(:puts).with("Name: #{target_group.properties.name}")
+      expect(subject).to receive(:puts).with("Algorithm: #{target_group.properties.algorithm}")
+      expect(subject).to receive(:puts).with("Protocol: #{target_group.properties.protocol}")
+      expect(subject).to receive(:puts).with("Health Check: #{health_check}")
+      expect(subject).to receive(:puts).with("HTTP Health Check: #{http_health_check}")
+      expect(subject).to receive(:puts).with("Targets: #{targets}")
+
+      mock_wait_for(subject)
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'PATCH',
+            path: "/targetgroups/#{subject_config[:target_group_id]}",
+            operation: :'TargetGroupsApi.targetgroups_patch',
+            return_type: 'TargetGroup',
+            body: {
+              name: subject_config[:name],
+              algorithm: subject_config[:algorithm],
+              healthCheck: {
+                checkTimeout: subject_config[:check_timeout],
+                checkInterval: subject_config[:check_interval],
+                retries: subject_config[:retries],
+              },
+              httpHealthCheck: {
+                method: subject_config[:method],
+                path: subject_config[:path],
+                response: subject_config[:response],
+                regex: subject_config[:regex],
+                negate: subject_config[:negate],
+              },
+              targets: [{
+                ip: new_target.ip,
+                port: new_target.port,
+                weight: new_target.weight,
+                healthCheckEnabled: new_target.health_check_enabled,
+                maintenanceEnabled: new_target.maintenance_enabled,
+              }],
+            },
+            result: target_group,
+          },
+          {
+            method: 'GET',
+            path: "/targetgroups/#{subject_config[:target_group_id]}",
+            operation: :'TargetGroupsApi.targetgroups_find_by_target_group_id',
+            return_type: 'TargetGroup',
+            result: target_group,
+          },
+        ],
+      )
+
+      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