knife-ionoscloud 6.1.2 → 6.2.0

data/spec/chef/knife/ionoscloud_applicationloadbalancer_rule_remove_spec.rb

@@ -0,0 +1,127 @@
+require 'spec_helper'
+require 'ionoscloud_applicationloadbalancer_rule_remove'
+
+Chef::Knife::IonoscloudApplicationloadbalancerRuleRemove.load_deps
+
+describe Chef::Knife::IonoscloudApplicationloadbalancerRuleRemove do
+  before :each do
+    subject { Chef::Knife::IonoscloudApplicationloadbalancerRuleRemove.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
+      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,
+        yes: true,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+      subject.name_args = [application_loadbalancer_rule.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).to receive(:print).with("Removing rules #{subject.name_args} from the Application Loadbalancer...")
+
+      mock_wait_for(subject)
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'DELETE',
+            path: "/datacenters/#{subject_config[:datacenter_id]}/applicationloadbalancers/#{application_loadbalancer.id}/forwardingrules/#{application_loadbalancer_rule.id}",
+            operation: :'ApplicationLoadBalancersApi.datacenters_applicationloadbalancers_forwardingrules_delete',
+          },
+          {
+            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 call ApplicationLoadBalancersApi.datacenters_applicationloadbalancers_delete when the ID is not valid' do
+      application_loadbalancer = application_loadbalancer_mock
+      rule_id = 'invalid_id'
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        datacenter_id: 'datacenter_id',
+        application_loadbalancer_id: application_loadbalancer.id,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+      subject.name_args = [rule_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("Error removing Forwarding Rule #{rule_id}. Skipping.")
+      expect(subject.ui).to receive(:warn).with('No valid rules to remove.')
+
+      expect(subject.api_client).not_to receive(:wait_for)
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'DELETE',
+            path: "/datacenters/#{subject_config[:datacenter_id]}/applicationloadbalancers/#{subject_config[:application_loadbalancer_id]}/forwardingrules/#{rule_id}",
+            operation: :'ApplicationLoadBalancersApi.datacenters_applicationloadbalancers_forwardingrules_delete',
+            exception: Ionoscloud::ApiError.new(code: 404),
+          },
+          {
+            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_rule_update_spec.rb

@@ -0,0 +1,219 @@
+require 'spec_helper'
+require 'ionoscloud_applicationloadbalancer_rule_update'
+
+Chef::Knife::IonoscloudApplicationloadbalancerRuleUpdate.load_deps
+
+describe Chef::Knife::IonoscloudApplicationloadbalancerRuleUpdate do
+  before :each do
+    subject { Chef::Knife::IonoscloudApplicationloadbalancerRuleUpdate.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call ApplicationLoadBalancersApi.datacenters_applicationloadbalancers_patch' do
+      application_loadbalancer_rule = application_loadbalancer_rule_mock
+      application_loadbalancer = application_loadbalancer_mock(
+        rules: Ionoscloud::ApplicationLoadBalancerForwardingRules.new(
+          id: 'application_loadbalancers_forwardingrules',
+          type: 'collection',
+          items: [application_loadbalancer_rule],
+        ),
+      )
+      application_loadbalancer_rule_httprule = application_loadbalancer_rule_httprule_mock(
+        name: 'test_name',
+        type: 'STATIC',
+        content_type: 'new_content_type',
+        conditions: [],
+      )
+
+      existing_httprule_new_name = application_loadbalancer_rule.properties.http_rules.first.name + '_edited'
+      existing_httprule_new_location = application_loadbalancer_rule.properties.http_rules.first.location + '_edited'
+      existing_httprule_new_status_code = 503
+      existing_httprule_new_response_message = application_loadbalancer_rule.properties.http_rules.first.response_message + '_edited'
+      existing_httprule_new_content_type = application_loadbalancer_rule.properties.http_rules.first.content_type + '_edited'
+
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        datacenter_id: 'datacenter_id',
+        application_loadbalancer_id: application_loadbalancer.id,
+        forwarding_rule_id: application_loadbalancer_rule.id,
+        name: application_loadbalancer_rule.properties.name + '_edit',
+        listener_ip: '127.1.1.1',
+        listener_port: 30,
+        client_timeout: 3000,
+        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' => existing_httprule_new_name,
+            'type' => hash[:type],
+            'target_group' => hash[:targetGroup],
+            'drop_query' => hash[:dropQuery],
+            'location' => existing_httprule_new_location,
+            'status_code' => existing_httprule_new_status_code,
+            'response_message' => existing_httprule_new_response_message,
+            'content_type' => existing_httprule_new_content_type,
+            'conditions' => hash[:conditions],
+          }
+        end + [application_loadbalancer_rule_httprule].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}")
+
+      application_loadbalancer.entities.forwardingrules.items.first.properties.name = subject_config[:name]
+      application_loadbalancer.entities.forwardingrules.items.first.properties.listener_ip = subject_config[:listener_ip]
+      application_loadbalancer.entities.forwardingrules.items.first.properties.listener_port = subject_config[:listener_port]
+      application_loadbalancer.entities.forwardingrules.items.first.properties.client_timeout = subject_config[:client_timeout]
+
+      application_loadbalancer.entities.forwardingrules.items.first.properties.http_rules.first.name = existing_httprule_new_name
+      application_loadbalancer.entities.forwardingrules.items.first.properties.http_rules.first.location = existing_httprule_new_location
+      application_loadbalancer.entities.forwardingrules.items.first.properties.http_rules.first.status_code = existing_httprule_new_status_code
+      application_loadbalancer.entities.forwardingrules.items.first.properties.http_rules.first.response_message = existing_httprule_new_response_message
+      application_loadbalancer.entities.forwardingrules.items.first.properties.http_rules.first.content_type = existing_httprule_new_content_type
+
+      application_loadbalancer.entities.forwardingrules.items.first.properties.http_rules << application_loadbalancer_rule_httprule
+
+      expect(subject).to receive(:puts).with("Rules: #{
+        application_loadbalancer.entities.forwardingrules.items.map do |rule|
+        {
+          id: rule.id,
+          name: subject_config[:name],
+          protocol: application_loadbalancer_rule.properties.protocol,
+          listener_ip: subject_config[:listener_ip],
+          listener_port: subject_config[:listener_port],
+          client_timeout: subject_config[:client_timeout],
+          server_certificates: application_loadbalancer_rule.properties.server_certificates,
+          http_rules: 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}")
+
+      http_rules_body = application_loadbalancer.entities.forwardingrules.items.first.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],
+          targetGroup: hash[:targetGroup],
+          dropQuery: hash[:dropQuery],
+          location: hash[:location],
+          statusCode: hash[:statusCode],
+          responseMessage: hash[:responseMessage],
+          contentType: hash[:contentType],
+          conditions: hash[:conditions].map do |condition|
+            condition
+            {
+              type: condition['type'],
+              condition: condition['condition'],
+              negate: condition['negate'],
+              key: condition['key'],
+              value: condition['value'],
+            }
+          end,
+        }
+      end
+
+      mock_wait_for(subject)
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'PATCH',
+            path: "/datacenters/#{subject_config[:datacenter_id]}/applicationloadbalancers/"\
+            "#{subject_config[:application_loadbalancer_id]}/forwardingrules/#{subject_config[:forwarding_rule_id]}",
+            operation: :'ApplicationLoadBalancersApi.datacenters_applicationloadbalancers_forwardingrules_patch',
+            return_type: 'ApplicationLoadBalancerForwardingRule',
+            body: {
+              name: subject_config[:name],
+              listenerIp: subject_config[:listener_ip],
+              listenerPort: subject_config[:listener_port],
+              clientTimeout: subject_config[:client_timeout],
+              httpRules: http_rules_body,
+            },
+            result: application_loadbalancer.entities.forwardingrules.items.first,
+          },
+          {
+            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

data/spec/chef/knife/ionoscloud_applicationloadbalancer_update_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+require 'ionoscloud_applicationloadbalancer_update'
+
+Chef::Knife::IonoscloudApplicationloadbalancerUpdate.load_deps
+
+describe Chef::Knife::IonoscloudApplicationloadbalancerUpdate do
+  before :each do
+    subject { Chef::Knife::IonoscloudApplicationloadbalancerUpdate.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call ApplicationLoadBalancersApi.datacenters_applicationloadbalancers_patch' do
+      application_loadbalancer = application_loadbalancer_mock
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        datacenter_id: 'datacenter_id',
+        application_loadbalancer_id: application_loadbalancer.id,
+        name: application_loadbalancer.properties.name + '_edited',
+        ips: (application_loadbalancer.properties.ips + ['127.3.3.3']).join(','),
+        lb_private_ips: (application_loadbalancer.properties.lb_private_ips + ['127.3.3.3']).join(','),
+        listener_lan: application_loadbalancer.properties.listener_lan + 1,
+        target_lan: application_loadbalancer.properties.target_lan + 1,
+        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: #{subject_config[:name]}")
+      expect(subject).to receive(:puts).with("Listener LAN: #{subject_config[:listener_lan]}")
+      expect(subject).to receive(:puts).with("IPS: #{subject_config[:ips].split(',')}")
+      expect(subject).to receive(:puts).with("Target LAN: #{subject_config[:target_lan]}")
+      expect(subject).to receive(:puts).with("Lb Private IPS: #{subject_config[:lb_private_ips].split(',')}")
+
+      application_loadbalancer.properties.name = subject_config[:name]
+      application_loadbalancer.properties.listener_lan = subject_config[:listener_lan]
+      application_loadbalancer.properties.target_lan = subject_config[:target_lan]
+      application_loadbalancer.properties.ips = subject_config[:ips].split(',')
+      application_loadbalancer.properties.lb_private_ips = subject_config[:lb_private_ips].split(',')
+
+      mock_wait_for(subject)
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'PATCH',
+            path: "/datacenters/#{subject_config[:datacenter_id]}/applicationloadbalancers/#{subject_config[:application_loadbalancer_id]}",
+            operation: :'ApplicationLoadBalancersApi.datacenters_applicationloadbalancers_patch',
+            return_type: 'ApplicationLoadBalancer',
+            body: {
+              name: subject_config[:name],
+              listenerLan: subject_config[:listener_lan],
+              targetLan: subject_config[:target_lan],
+              ips: subject_config[:ips].split(','),
+              lbPrivateIps: subject_config[:lb_private_ips].split(','),
+            },
+            result: application_loadbalancer,
+          },
+          {
+            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

data/spec/chef/knife/ionoscloud_targetgroup_create_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+require 'ionoscloud_targetgroup_create'
+
+Chef::Knife::IonoscloudTargetgroupCreate.load_deps
+
+describe Chef::Knife::IonoscloudTargetgroupCreate do
+  before :each do
+    subject { Chef::Knife::IonoscloudTargetgroupCreate.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call TargetGroupsApi.targetgroups_post_with_http_info with the expected arguments and output based on what it receives' 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(targets: [new_target])
+
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        name: target_group.properties.name,
+        algorithm: target_group.properties.algorithm,
+        protocol: target_group.properties.protocol,
+        check_timeout: target_group.properties.health_check.check_timeout,
+        check_interval: target_group.properties.health_check.check_interval,
+        retries: target_group.properties.health_check.retries,
+        path: target_group.properties.http_health_check.path,
+        method: target_group.properties.http_health_check.method,
+        match_type: target_group.properties.http_health_check.match_type,
+        response: target_group.properties.http_health_check.response,
+        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,
+        }],
+      }
+
+      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}")
+
+      expected_body = target_group.properties.to_hash
+
+      mock_wait_for(subject)
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'POST',
+            path: '/targetgroups',
+            operation: :'TargetGroupsApi.targetgroups_post',
+            return_type: 'TargetGroup',
+            body: { properties: expected_body },
+            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_delete_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+require 'ionoscloud_targetgroup_delete'
+
+Chef::Knife::IonoscloudTargetgroupDelete.load_deps
+
+describe Chef::Knife::IonoscloudTargetgroupDelete do
+  before :each do
+    subject { Chef::Knife::IonoscloudTargetgroupDelete.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call TargetGroupsApi.target_groups_delete when the ID is valid' do
+      target_group = target_group_mock
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        yes: true,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+      subject.name_args = [target_group.id]
+
+
+      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("Deleted Target Group #{target_group.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: "/targetgroups/#{target_group.id}",
+            operation: :'TargetGroupsApi.targetgroups_find_by_target_group_id',
+            return_type: 'TargetGroup',
+            result: target_group,
+          },
+          {
+            method: 'DELETE',
+            path: "/targetgroups/#{target_group.id}",
+            operation: :'TargetGroupsApi.target_groups_delete',
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should not call TargetGroupsApi.target_groups_delete when the user ID is not valid' do
+      target_group_id = 'invalid_id'
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+      subject.name_args = [target_group_id]
+
+      expect(subject.ui).to receive(:error).with("Target Group ID #{target_group_id} not found. Skipping.")
+
+      expect(subject.api_client).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',
+            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