knife-ionoscloud 6.1.0 → 6.2.0

data/spec/chef/knife/ionoscloud_user_update_spec.rb

@@ -92,18 +92,20 @@ describe Chef::Knife::IonoscloudUserUpdate do
     it 'should not make any call if any required option is missing' do
       required_options = subject.instance_variable_get(:@required_options)
 
-      arrays_without_one_element(required_options).each do |test_case|
+      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' }
 
-        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).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
 
-        expect { subject.run }.to raise_error(SystemExit) do |error|
-          expect(error.status).to eq(1)
+          required_options.each { |value| subject.config[value] = nil }
         end
-
-        required_options.each { |value| subject.config[value] = nil }
       end
     end
   end

data/spec/chef/knife/ionoscloud_volume_attach_spec.rb

@@ -81,18 +81,20 @@ describe Chef::Knife::IonoscloudVolumeAttach do
     it 'should not make any call if any required option is missing' do
       required_options = subject.instance_variable_get(:@required_options)
 
-      arrays_without_one_element(required_options).each do |test_case|
+      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' }
 
-        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).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
 
-        expect { subject.run }.to raise_error(SystemExit) do |error|
-          expect(error.status).to eq(1)
+          required_options.each { |value| subject.config[value] = nil }
         end
-
-        required_options.each { |value| subject.config[value] = nil }
       end
     end
   end

data/spec/chef/knife/ionoscloud_volume_create_spec.rb

@@ -83,18 +83,20 @@ describe Chef::Knife::IonoscloudVolumeCreate do
     it 'should not make any call if any required option is missing' do
       required_options = subject.instance_variable_get(:@required_options)
 
-      arrays_without_one_element(required_options).each do |test_case|
+      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' }
 
-        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).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
 
-        expect { subject.run }.to raise_error(SystemExit) do |error|
-          expect(error.status).to eq(1)
+          required_options.each { |value| subject.config[value] = nil }
         end
-
-        required_options.each { |value| subject.config[value] = nil }
       end
     end
   end

data/spec/chef/knife/ionoscloud_volume_delete_spec.rb

@@ -100,18 +100,20 @@ describe Chef::Knife::IonoscloudVolumeDelete do
     it 'should not make any call if any required option is missing' do
       required_options = subject.instance_variable_get(:@required_options)
 
-      arrays_without_one_element(required_options).each do |test_case|
+      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' }
 
-        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).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
 
-        expect { subject.run }.to raise_error(SystemExit) do |error|
-          expect(error.status).to eq(1)
+          required_options.each { |value| subject.config[value] = nil }
         end
-
-        required_options.each { |value| subject.config[value] = nil }
       end
     end
   end

data/spec/chef/knife/ionoscloud_volume_detach_spec.rb

@@ -92,18 +92,20 @@ describe Chef::Knife::IonoscloudVolumeDetach do
     it 'should not make any call if any required option is missing' do
       required_options = subject.instance_variable_get(:@required_options)
 
-      arrays_without_one_element(required_options).each do |test_case|
+      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' }
 
-        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).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
 
-        expect { subject.run }.to raise_error(SystemExit) do |error|
-          expect(error.status).to eq(1)
+          required_options.each { |value| subject.config[value] = nil }
         end
-
-        required_options.each { |value| subject.config[value] = nil }
       end
     end
   end

data/spec/chef/knife/ionoscloud_volume_get_spec.rb

@@ -63,18 +63,20 @@ describe Chef::Knife::IonoscloudVolumeGet do
     it 'should not make any call if any required option is missing' do
       required_options = subject.instance_variable_get(:@required_options)
 
-      arrays_without_one_element(required_options).each do |test_case|
+      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' }
 
-        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).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
 
-        expect { subject.run }.to raise_error(SystemExit) do |error|
-          expect(error.status).to eq(1)
+          required_options.each { |value| subject.config[value] = nil }
         end
-
-        required_options.each { |value| subject.config[value] = nil }
       end
     end
   end

data/spec/chef/knife/ionoscloud_volume_list_spec.rb

@@ -9,7 +9,7 @@ describe Chef::Knife::IonoscloudVolumeList do
 
     @volumes = volumes_mock
 
-    @volume_list = volume_list = [
+    @volume_list = [
       subject.ui.color('ID', :bold),
       subject.ui.color('Name', :bold),
       subject.ui.color('Size', :bold),
@@ -73,7 +73,7 @@ describe Chef::Knife::IonoscloudVolumeList do
         ionoscloud_username: 'email',
         ionoscloud_password: 'password',
         datacenter_id: 'datacenter_id',
-        server_id: 'server_id'
+        server_id: 'server_id',
       }
 
       subject_config.each { |key, value| subject.config[key] = value }
@@ -100,18 +100,20 @@ describe Chef::Knife::IonoscloudVolumeList do
     it 'should not make any call if any required option is missing' do
       required_options = subject.instance_variable_get(:@required_options)
 
-      arrays_without_one_element(required_options).each do |test_case|
+      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' }
 
-        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).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
 
-        expect { subject.run }.to raise_error(SystemExit) do |error|
-          expect(error.status).to eq(1)
+          required_options.each { |value| subject.config[value] = nil }
         end
-
-        required_options.each { |value| subject.config[value] = nil }
       end
     end
   end

data/spec/chef/knife/ionoscloud_volume_update_spec.rb

@@ -98,18 +98,20 @@ describe Chef::Knife::IonoscloudVolumeUpdate do
     it 'should not make any call if any required option is missing' do
       required_options = subject.instance_variable_get(:@required_options)
 
-      arrays_without_one_element(required_options).each do |test_case|
+      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' }
 
-        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).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
 
-        expect { subject.run }.to raise_error(SystemExit) do |error|
-          expect(error.status).to eq(1)
+          required_options.each { |value| subject.config[value] = nil }
         end
-
-        required_options.each { |value| subject.config[value] = nil }
       end
     end
   end

data/spec/spec_helper.rb

@@ -3,16 +3,20 @@ require 'rspec'
 require 'chef'
 require 'securerandom'
 require 'simplecov'
+require 'simplecov_json_formatter'
 
 RSpec.configure do |config|
   config.pattern = 'spec/chef/knife/*_spec.rb'
 end
+SimpleCov.formatter = SimpleCov::Formatter::JSONFormatter
+
 SimpleCov.start do
   add_group 'Commands', 'lib/chef/knife/'
   add_group 'Spec files', 'spec/chef/knife/'
 end
 SimpleCov.coverage_dir 'coverage'
 
+
 def contract_mock(opts = {})
   Ionoscloud::Contract.new(
     type: opts[:type] || 'contract',
@@ -107,7 +111,7 @@ def server_mock(opts = {})
     entities: Ionoscloud::ServerEntities.new(
       volumes: opts[:volumes] || [],
       nics: opts[:nics] || [],
-    )
+    ),
   )
 end
 
@@ -121,13 +125,13 @@ end
 
 def token_mock
   Ionoscloud::Token.new(
-    token: 'test_token'
+    token: 'test_token',
   )
 end
 
 def console_mock
   Ionoscloud::RemoteConsoleUrl.new(
-    url: 'test_url'
+    url: 'test_url',
   )
 end
 
@@ -246,7 +250,7 @@ def nic_mock(opts = {})
     ),
     entities: Ionoscloud::NicEntities.new(
       firewallrules: opts[:firewallrules] || [],
-    )
+    ),
   )
 end
 
@@ -294,7 +298,7 @@ def load_balancer_mock(opts = {})
     ),
     entities: Ionoscloud::LoadbalancerEntities.new(
       balancednics: opts[:nics] || nics_mock,
-    )
+    ),
   )
 end
 
@@ -371,17 +375,15 @@ def k8s_cluster_mock(opts = {})
       k8s_version: opts[:k8s_version] || '1.15.4,',
       maintenance_window: opts[:maintenance_window] || maintenance_window_mock,
       api_subnet_allow_list: opts[:api_subnet_allow_list] || [
-        "1.2.3.4/32",
-        "2002::1234:abcd:ffff:c0a8:101/64",
-        "1.2.3.4",
-        "2002::1234:abcd:ffff:c0a8:101"
+        '127.0.0.1/32',
+        '127.0.0.1',
       ],
       s3_buckets: opts[:s3_buckets] || [
         Ionoscloud::S3Bucket.new(name: 'test_name1'),
         Ionoscloud::S3Bucket.new(name: 'test_name2'),
       ],
       available_upgrade_versions: opts[:available_upgrade_versions] || ['1.16.4', '1.17.7'],
-      viable_node_pool_versions: opts[:viable_node_pool_versions] || ['1.17.7', '1.18.2']
+      viable_node_pool_versions: opts[:viable_node_pool_versions] || ['1.17.7', '1.18.2'],
     ),
     metadata: Ionoscloud::DatacenterElementMetadata.new(
       state: opts[:state] || 'ACTIVE',
@@ -407,8 +409,8 @@ def nodepool_lan_mock(opts = {})
     dhcp: opts[:dhcp] || false,
     routes: opts[:routes] || [
       Ionoscloud::KubernetesNodePoolLanRoutes.new(
-        network: opts[:network] || '127.2.3.4/24',
-        gateway_ip: opts[:gateway_ip] || '127.1.5.16',
+        network: opts[:network] || '127.0.0.1/24',
+        gateway_ip: opts[:gateway_ip] || '127.0.0.1',
       ),
     ],
   )
@@ -433,8 +435,8 @@ def k8s_nodepool_mock(opts = {})
       lans: opts[:lans] || [nodepool_lan_mock(id: 12), nodepool_lan_mock(id: 15)],
       public_ips: opts[:public_ips] || ['127.173.1.2', '127.231.2.5', '127.221.2.4'],
       available_upgrade_versions: opts[:available_upgrade_versions] || ['1.16.4', '1.17.7'],
-      labels: opts[:labels] || { "test_labels": "test_labels" },
-      annotations: opts[:annotations] || { "test_annotations": "test_annotations" },
+      labels: opts[:labels] || { "test_labels": 'test_labels' },
+      annotations: opts[:annotations] || { "test_annotations": 'test_annotations' },
     ),
     metadata: Ionoscloud::KubernetesNodeMetadata.new(
       state: 'READY',
@@ -508,6 +510,7 @@ def cluster_mock(opts = {})
       display_name: opts[:display_name] || 'dbaas_Cluster',
       postgres_version: opts[:postgres_version] || '10',
       location: opts[:location] || 'us/las',
+      backup_location: opts[:backup_location] || 'eu-central-2',
       instances: opts[:instances] || 2,
       ram: opts[:ram] || 8192,
       cores: opts[:cores] || 4,
@@ -516,11 +519,11 @@ def cluster_mock(opts = {})
       connections: opts[:connections] || [IonoscloudDbaasPostgres::Connection.new(
         datacenter_id: opts[:datacenter_id] || SecureRandom.uuid,
         lan_id: opts[:lan_id] || '1',
-        cidr: opts[:cidr] || '192.168.1.100/24',
-      ),],
+        cidr: opts[:cidr] || '127.0.0.3/24',
+      )],
       maintenance_window: opts[:maintenance_window] || IonoscloudDbaasPostgres::MaintenanceWindow.new(
-        time: opts[:time] || "00:29:15", 
-        day_of_the_week: opts[:day_of_the_week] || "Monday", 
+        time: opts[:time] || '00:29:15',
+        day_of_the_week: opts[:day_of_the_week] || 'Monday',
       ),
       synchronization_mode: opts[:synchronization_mode] || 'ASYNCHRONOUS',
     ),
@@ -699,9 +702,9 @@ def user_mock(opts = {})
     ),
     entities: Ionoscloud::UsersEntities.new(
       groups: Ionoscloud::Groups.new(
-        items: opts[:groups] || []
-      )
-    )
+        items: opts[:groups] || [],
+      ),
+    ),
   )
 end
 
@@ -719,7 +722,7 @@ def request_status_mock(opts = {})
     metadata: Ionoscloud::RequestStatusMetadata.new(
       status: opts[:status] || 'DONE',
       message: opts[:message] || 'Message',
-      targets: opts[:targets] || []
+      targets: opts[:targets] || [],
     ),
   )
 end
@@ -738,8 +741,8 @@ def request_mock(opts = {})
       method: opts[:method] || 'POST',
     ),
     metadata: Ionoscloud::RequestMetadata.new(
-      request_status: request_status_mock(opts)
-    )
+      request_status: request_status_mock(opts),
+    ),
   )
 end
 
@@ -868,7 +871,7 @@ def network_loadbalancer_mock(opts = {})
         type: 'collection',
         items: [],
       ),
-    })
+    }),
   )
 end
 
@@ -921,6 +924,112 @@ def network_loadbalancer_rule_target_mock(opts = {})
   )
 end
 
+def application_loadbalancer_rule_httprule_condition_mock(opts = {})
+  Ionoscloud::ApplicationLoadBalancerHttpRuleCondition.new(
+    type: opts[:type] || 'HEADER',
+    condition: opts[:condition] || 'STARTS_WITH',
+    negate: opts[:negate].nil? ? true : opts[:negate],
+    key: opts[:key] || 'forward-at',
+    value: opts[:value] || 'Friday',
+  )
+end
+
+def application_loadbalancer_rule_httprule_mock(opts = {})
+  Ionoscloud::ApplicationLoadBalancerHttpRule.new(
+    name: opts[:name] || 'application_loadbalancer_rule_httprule_name',
+    type: opts[:type] || 'REDIRECT',
+    target_group: opts[:target_group] || SecureRandom.uuid,
+    drop_query: opts[:drop_query].nil? ? true : opts[:drop_query],
+    location: opts[:location] || 'www.ionos.com',
+    status_code: opts[:status_code] || 303,
+    response_message: opts[:response_message] || 'response_message',
+    content_type: opts[:content_type] || 'content_type',
+    conditions: opts.key?(:conditions) ? opts[:conditions] : [application_loadbalancer_rule_httprule_condition_mock],
+  )
+end
+
+def application_loadbalancer_rule_mock(opts = {})
+  Ionoscloud::ApplicationLoadBalancerForwardingRule.new(
+    id: opts[:id] || SecureRandom.uuid,
+    properties: Ionoscloud::ApplicationLoadBalancerForwardingRuleProperties.new(
+      name: opts[:name] || 'application_loadbalancer_rule_name',
+      protocol: opts[:protocol] || 'HTTP',
+      listener_ip: opts[:listener_ip] || '127.0.0.1',
+      listener_port: opts[:listener_port] || '22',
+      client_timeout: opts[:client_timeout] || 2000,
+      server_certificates: opts[:server_certificates] || [],
+      http_rules: opts.key?(:http_rules) ? opts[:http_rules] : [application_loadbalancer_rule_httprule_mock],
+    ),
+  )
+end
+
+def application_loadbalancer_rules_mock(opts = {})
+  Ionoscloud::ApplicationLoadBalancerForwardingRules.new(
+    id: 'application_loadbalancers_forwardingrules',
+    type: 'collection',
+    items: [application_loadbalancer_rule_mock, application_loadbalancer_rule_mock],
+  )
+end
+
+def application_loadbalancer_mock(opts = {})
+  Ionoscloud::ApplicationLoadBalancer.new(
+    id: opts[:id] || SecureRandom.uuid,
+    properties: Ionoscloud::ApplicationLoadBalancerProperties.new({
+      name: opts[:name] || 'application_loadbalancer_name',
+      ips: opts[:ips] || ['127.0.0.123'],
+      listener_lan: opts[:listener_lan] || 1,
+      target_lan: opts[:target_lan] || 2,
+      lb_private_ips: opts[:lb_private_ips] || ['127.0.0.12'],
+    }),
+    entities: Ionoscloud::ApplicationLoadBalancerEntities.new({
+      forwardingrules: opts.key?(:rules) ? opts[:rules] : application_loadbalancer_rules_mock,
+    }),
+  )
+end
+
+def application_loadbalancers_mock(opts = {})
+  Ionoscloud::ApplicationLoadBalancers.new(
+    id: 'application_loadbalancers',
+    type: 'collection',
+    items: [application_loadbalancer_mock, application_loadbalancer_mock],
+  )
+end
+
+def target_group_target_mock(opts = {})
+  Ionoscloud::TargetGroupTarget.new(
+    ip: opts[:ip] || '127.0.0.1',
+    port: opts[:port] || 20,
+    weight: opts[:weight] || 15,
+    health_check_enabled: opts[:health_check_enabled] || true,
+    maintenance_enabled: opts[:maintenance_enabled] || false,
+  )
+end
+
+def target_group_mock(opts = {})
+  Ionoscloud::TargetGroup.new(
+    id: opts[:id] || SecureRandom.uuid,
+    properties: Ionoscloud::TargetGroupProperties.new(
+      name: opts[:name] || 'target_group_name',
+      algorithm: opts[:algorithm] || 'LEAST_CONNECTION',
+      protocol: opts[:protocol] || 'HTTP',
+      health_check: Ionoscloud::TargetGroupHealthCheck.new(
+        check_timeout: opts[:check_timeout] || 60,
+        check_interval: opts[:check_interval] || 4000,
+        retries: opts[:retries] || 3,
+      ),
+      http_health_check: Ionoscloud::TargetGroupHttpHealthCheck.new(
+        path: opts[:path] || '/.',
+        method: opts[:method] || 'GET',
+        match_type: opts[:match_type] || 'STATUS_CODE',
+        response: opts[:response] || 'response example',
+        regex: opts[:regex] || false,
+        negate: opts[:negate] || false,
+      ),
+      targets: opts[:targets] || [target_group_target_mock],
+    ),
+  )
+end
+
 def postgres_version_data_mock(opts = {})
   IonoscloudDbaasPostgres::PostgresVersionListData.new(name: opts[:name] || 12)
 end
@@ -955,7 +1064,7 @@ def cluster_backup_mock(opts = {})
       cluster_id: SecureRandom.uuid.to_s,
       is_active: true,
       version: opts[:version] || '10',
-      earliest_recovery_target_time: Time.now
+      earliest_recovery_target_time: Time.now,
     ),
     metadata: IonoscloudDbaasPostgres::Metadata.new(
       created_date: Time.now,
@@ -963,6 +1072,14 @@ def cluster_backup_mock(opts = {})
   )
 end
 
+def target_groups_mock(opts = {})
+  Ionoscloud::TargetGroups.new(
+    id: 'target_groups',
+    type: 'collection',
+    items: [target_group_mock, target_group_mock],
+  )
+end
+
 def cluster_backups_mock(opts = {})
   IonoscloudDbaasPostgres::ClusterBackupList.new(items: [cluster_backup_mock, cluster_backup_mock])
 end
@@ -980,7 +1097,6 @@ end
 def mock_dbaas_call_api(subject, rules)
   rules.each do |rule|
     expect(subject.api_client_dbaas).to receive(:call_api).once do |method, path, opts|
-      result = nil
       received_body = opts[:body].nil? ? opts[:body] : JSON.parse(opts[:body], symbolize_names: true)
 
       expect(method.to_s).to eq(rule[:method])
@@ -991,9 +1107,7 @@ def mock_dbaas_call_api(subject, rules)
       expect(received_body).to eq(rule[:body] || nil)
       expect(opts.slice(*(rule[:options] || {}).keys)).to eql((rule[:options] || {}))
 
-      if rule[:exception]
-        raise rule[:exception]
-      end
+      raise rule[:exception] if rule[:exception]
 
       rule[:result]
     end
@@ -1004,7 +1118,6 @@ end
 def mock_call_api(subject, rules)
   rules.each do |rule|
     expect(subject.api_client).to receive(:call_api).once do |method, path, opts|
-      result = nil
       received_body = opts[:body].nil? ? opts[:body] : JSON.parse(opts[:body], symbolize_names: true)
 
       expect(method.to_s).to eq(rule[:method])
@@ -1015,9 +1128,7 @@ def mock_call_api(subject, rules)
       expect(received_body).to eq(rule[:body] || nil)
       expect(opts.slice(*(rule[:options] || {}).keys)).to eql((rule[:options] || {}))
 
-      if rule[:exception]
-        raise rule[:exception]
-      end
+      raise rule[:exception] if rule[:exception]
 
       rule[:result]
     end