hawkular-client 2.8.0 → 2.9.0

data/spec/integration/env_config_spec.rb

@@ -0,0 +1,39 @@
+require_relative '../spec_helper'
+
+require 'hawkular/env_config'
+
+describe Hawkular::EnvConfig do
+  subject(:config) { Hawkular::EnvConfig }
+  describe '.log_response?' do
+    it 'is true if defined' do
+      swap_env('HAWKULARCLIENT_LOG_RESPONSE', 'true') do
+        expect(config.log_response?).to be_truthy
+      end
+    end
+
+    it 'is false if null' do
+      swap_env('HAWKULARCLIENT_LOG_RESPONSE', nil) do
+        expect(config.log_response?).to be_falsey
+      end
+    end
+  end
+
+  describe '.rest_timeout' do
+    it 'returns the value for the environment' do
+      swap_env('HAWKULARCLIENT_REST_TIMEOUT', '20') do
+        expect(config.rest_timeout).to eq '20'
+      end
+    end
+  end
+
+  private
+
+  def swap_env(name, value)
+    old_value = ENV[name]
+    ENV[name] = value
+
+    yield
+  ensure
+    ENV[name] = old_value
+  end
+end

data/spec/integration/hawkular_client_spec.rb

@@ -1,5 +1,6 @@
-require "#{File.dirname(__FILE__)}/../vcr/vcr_setup"
-require "#{File.dirname(__FILE__)}/../spec_helper"
+require_relative '../vcr/vcr_setup'
+require_relative '../spec_helper'
+
 require 'securerandom'
 
 # examples that tests the main client which delegates all the calls to Hawkular component clients
@@ -16,6 +17,8 @@ module Hawkular::Client::RSpec
         mock_inventory_client '0.17.2.Final'
         mock_metrics_version
         @hawkular_client = Hawkular::Client.new(entrypoint: HOST, credentials: @creds, options: { tenant: 'hawkular' })
+        @hawkular_client.inventory
+        @hawkular_client.metrics
       end
       @state = {
         hostname: 'localhost.localdomain',
@@ -30,7 +33,7 @@ module Hawkular::Client::RSpec
           password: 'password'
         }
         expect do
-          Hawkular::Client.new(entrypoint: HOST, credentials: @creds)
+          Hawkular::Client.new(entrypoint: HOST, credentials: @creds).inventory_list_feeds
         end.to raise_error(Hawkular::BaseClient::HawkularException, 'Unauthorized')
       end
     end
@@ -83,9 +86,9 @@ module Hawkular::Client::RSpec
       before(:all) do
         ::RSpec::Mocks.with_temporary_scope do
           mock_inventory_client '0.17.2.Final'
-          @client = Hawkular::Inventory::InventoryClient.create(entrypoint: HOST,
-                                                                credentials: @creds,
-                                                                options: { tenant: 'hawkular' })
+          @client = Hawkular::Inventory::Client.create(entrypoint: HOST,
+                                                       credentials: @creds,
+                                                       options: { tenant: 'hawkular' })
         end
       end
 
@@ -249,7 +252,7 @@ module Hawkular::Client::RSpec
           }
 
           actual_data = {}
-          client = Hawkular::Operations::OperationsClient.new(entrypoint: HOST, credentials: @creds)
+          client = Hawkular::Operations::Client.new(entrypoint: HOST, credentials: @creds)
           client.invoke_generic_operation(redeploy) do |on|
             on.success do |data|
               actual_data[:data] = data

data/spec/integration/inventory_spec.rb

@@ -1,5 +1,6 @@
-require "#{File.dirname(__FILE__)}/../vcr/vcr_setup"
-require "#{File.dirname(__FILE__)}/../spec_helper"
+require_relative '../vcr/vcr_setup'
+require_relative '../spec_helper'
+
 require 'securerandom'
 
 module Hawkular::Inventory::RSpec
@@ -71,7 +72,7 @@ module Hawkular::Inventory::RSpec
           VCR.eject_cassette
           record("Inventory/#{security_context}/Connection", @creds, cassette_name) do
             expect do
-              Hawkular::Inventory::InventoryClient.create(entrypoint: entrypoint, credentials: @creds)
+              Hawkular::Inventory::Client.create(entrypoint: entrypoint, credentials: @creds)
             end.to raise_error(Hawkular::BaseClient::HawkularException, 'Unauthorized')
           end
         end
@@ -522,6 +523,34 @@ module Hawkular::Inventory::RSpec
           expect(r2.properties).not_to be_empty
         end
 
+        it 'Should have a consistent behaviour when creating an already existing resource' do
+          new_feed_id = "#{security_context}_feed_may_exist"
+          @client.create_feed new_feed_id
+          ret = @client.create_resource_type new_feed_id, 'rt-123', 'ResourceType'
+          type_path = ret.path
+
+          r1 = @client.create_resource type_path, 'r999', 'My Resource', 'version' => 1.0
+          r2 = @client.create_resource type_path, 'r999', 'My Resource', 'version' => 1.0
+
+          r3 = @client.create_resource_under_resource type_path, r1.path, 'r1000', 'My Resource', 'version' => 1.0
+          r4 = @client.create_resource_under_resource type_path, r1.path, 'r1000', 'My Resource', 'version' => 1.0
+
+          expect(r1).to eq(r2)
+          expect(r3).to eq(r4)
+        end
+
+        it 'Should return data from get_entity' do
+          new_feed_id = 'feed_may_exist'
+          @client.create_feed new_feed_id
+          ret = @client.create_resource_type new_feed_id, 'dummy-resource-type', 'ResourceType'
+          type_path = ret.path
+          entity = @client.get_entity(type_path)
+
+          expect(entity['path']).to eq(type_path)
+          expect(entity['name']).to eq('ResourceType')
+          expect(entity['id']).to eq('dummy-resource-type')
+        end
+
         it 'Should not find an unknown resource' do
           new_feed_id = 'feed_may_exist'
           path = Hawkular::Inventory::CanonicalPath.new(
@@ -591,6 +620,10 @@ module Hawkular::Inventory::RSpec
               # create 3 resources
               @client.create_resource type_path, id_1, 'My Resource 1', 'version' => 1.0
               @client.create_resource type_path, id_2, 'My Resource 2', 'version' => 1.1
+              # Wait for id_1 and id_2 before stop listening.
+              wait_while do
+                !hash_include_all(new_resource_events, [id_1, id_2])
+              end
               resources_closable.close
               @client.create_resource type_path, id_3, 'My Resource 3', 'version' => 1.2
 

data/spec/integration/logger_spec.rb

@@ -0,0 +1,36 @@
+require_relative '../spec_helper'
+require 'hawkular/logger'
+
+describe Hawkular::Logger do
+  let(:file) { Tempfile.new('hawkular_spec') }
+  subject(:logger) { described_class.new(file) }
+
+  describe '#log' do
+    before { allow(Hawkular::EnvConfig).to receive(:log_response?) { true } }
+
+    it 'logs the message to a file' do
+      logger.log('this is a message')
+      file.flush
+
+      expect(File.read(file)).to include 'this is a message'
+    end
+
+    it 'does not log anything if the config does not allow it' do
+      allow(Hawkular::EnvConfig).to receive(:log_response?) { false }
+
+      logger.log('this is a message')
+      file.flush
+
+      expect(File.read(file)).to be_empty
+    end
+
+    %w(debug info warn error fatal).each do |priority|
+      it "allows to log with #{priority} priority" do
+        logger.log('this is a message', priority)
+        file.flush
+
+        expect(File.read(file)).to include priority.upcase
+      end
+    end
+  end
+end

data/spec/integration/metric_spec.rb

@@ -1,5 +1,6 @@
-require "#{File.dirname(__FILE__)}/../vcr/vcr_setup"
-require "#{File.dirname(__FILE__)}/../spec_helper"
+require_relative '../vcr/vcr_setup'
+require_relative '../spec_helper'
+
 require 'securerandom'
 
 SKIP_SECURE_CONTEXT = ENV['SKIP_SECURE_CONTEXT'] || '1'
@@ -751,7 +752,7 @@ security_contexts.each do |security_context|
 
       describe 'All Tags for metrics', run_for: [services_context] do
         before(:each) do
-          @tenant = 'all_tags_tenant'
+          @tenant = SecureRandom.uuid
           options = setup_options.merge(tenant: @tenant)
           record("Metrics/#{security_context}/#{metrics_context}",
                  options,
@@ -760,6 +761,64 @@ security_contexts.each do |security_context|
           end
         end
 
+        it 'Should fetch all metrics with some tags', :skip_auto_vcr do
+          id1 = SecureRandom.uuid
+          id2 = SecureRandom.uuid
+          id3 = SecureRandom.uuid
+          id4 = SecureRandom.uuid
+
+          bindings = { id1: id1, id2: id2, id3: id3, id4: id4 }
+          tag = { miq_metric: true }
+          example = proc do
+            create_metric_using_md @client.gauges, id1, tag
+            create_metric_using_md @client.gauges, id2, tag
+            create_metric_using_md @client.gauges, id3, tag
+            create_metric_using_md @client.gauges, id4, tag
+
+            create_metric_using_md @client.avail, id1, tag
+            create_metric_using_md @client.avail, id2, tag
+            create_metric_using_md @client.avail, id3, tag
+            create_metric_using_md @client.avail, id4, tag
+
+            create_metric_using_md @client.counters, id1, tag
+            create_metric_using_md @client.counters, id2, tag
+            create_metric_using_md @client.counters, id3, tag
+            create_metric_using_md @client.counters, id4, tag
+
+            @client.push_data(
+              counters: [
+                { id: id1, data: [{ value: 1 }] },
+                { id: id2, data: [{ value: 2 }] },
+                { id: id3, data: [{ value: 3 }] }
+              ],
+              availabilities: [
+                { id: id1, data: [{ value: 'up' }] },
+                { id: id2, data: [{ value: 'down' }] },
+                { id: id3, data: [{ value: 'up' }] },
+                { id: id4, data: [{ value: 'up', timestamp: 10_000 },
+                                  { value: 'down', timestamp: 100_000 },
+                                  { value: 'admin', timestamp: 1_000_000 }] }
+              ],
+              gauges: [
+                { id: id1, data: [{ value: 1.1 }] },
+                { id: id2, data: [{ value: 2.2 }] },
+                { id: id3, data: [{ value: 3.3 }] }
+              ]
+            )
+            data = @client.data_by_tags(tag, buckets: 1)
+
+            expect(data.size).to eql(3)
+            expect(data['gauge'].size).to eql(4)
+            expect(data['availability'].size).to eql(4)
+            expect(data['counter'].size).to eql(4)
+          end
+
+          record("Metrics/#{security_context}/#{metrics_context}",
+                 vcr_bindings.merge(bindings),
+                 cassette_name,
+                 example: example)
+        end
+
         it 'Should fetch all metric tags for metrics definitions' do
           tags_m1 = {
             tag1: 'value1',

data/spec/integration/operations_spec.rb

@@ -1,5 +1,6 @@
-require "#{File.dirname(__FILE__)}/../vcr/vcr_setup"
-require "#{File.dirname(__FILE__)}/../spec_helper"
+require_relative '../vcr/vcr_setup'
+require_relative '../spec_helper'
+
 require 'securerandom'
 
 include Hawkular::Inventory
@@ -11,6 +12,7 @@ SKIP_SECURE_CONTEXT = ENV['SKIP_SECURE_CONTEXT'] || '1'
 module Hawkular::Operations::RSpec
   NON_SECURE_CONTEXT = :NonSecure
   SECURE_CONTEXT = :Secure
+
   [NON_SECURE_CONTEXT, SECURE_CONTEXT].each do |security_context|
     next if security_context == SECURE_CONTEXT && SKIP_SECURE_CONTEXT == '1'
     if security_context == NON_SECURE_CONTEXT && ENV['SKIP_NON_SECURE_CONTEXT'] == '1'
@@ -47,7 +49,7 @@ module Hawkular::Operations::RSpec
       end
 
       let(:client) do
-        OperationsClient.new(options)
+        Client.new(options)
       end
 
       before(:all) do
@@ -73,7 +75,7 @@ module Hawkular::Operations::RSpec
         it 'should be established via entrypoint' do
           ep = host_with_scheme(host, security_context == SECURE_CONTEXT)
 
-          client = OperationsClient.new(options.merge entrypoint: ep, host: nil)
+          client = Client.new(options.merge entrypoint: ep, host: nil)
           ws = client.ws
           expect(ws).not_to be nil
           expect(ws.open?).to be true
@@ -126,7 +128,7 @@ module Hawkular::Operations::RSpec
 
         it 'should bail with no host' do
           expect do
-            OperationsClient.new(options.merge host: nil)
+            Client.new(options.merge host: nil)
           end.to raise_error(StandardError, 'no parameter ":host" or ":entrypoint" given')
         end
       end
@@ -141,7 +143,7 @@ module Hawkular::Operations::RSpec
           record("Operation/#{security_context}/Helpers", nil, 'get_tenant') do
             ::RSpec::Mocks.with_temporary_scope do
               mock_inventory_client
-              @inventory_client = InventoryClient.create(
+              @inventory_client = ::Hawkular::Inventory::Client.create(
                 options.merge entrypoint: host_with_scheme(host, security_context == SECURE_CONTEXT))
             end
             inventory_client = @inventory_client
@@ -150,6 +152,15 @@ module Hawkular::Operations::RSpec
             record("Operation/#{security_context}/Helpers", { tenant_id: @tenant_id }, 'get_feed') do
               @feed_id = inventory_client.list_feeds[0]
             end
+            record("Operation/#{security_context}/Helpers", { tenant_id: @tenant_id, feed_id: @feed_id },
+                   'agent_properties') do
+              @wf_server_resource_id = 'Local~~'
+              wf_path = CanonicalPath.new(tenant_id: @tenant_id,
+                                          feed_id: @feed_id,
+                                          resource_ids: [@wf_server_resource_id])
+              wf_agent_path = path_for_installed_agent(wf_path)
+              @agent_immutable = immutable(inventory_client, wf_agent_path)
+            end
           end
           @bindings = { random_uuid: @random_uuid, tenant_id: @tenant_id, feed_id: @feed_id }
           record_websocket("Operation/#{security_context}/Operation",
@@ -158,13 +169,12 @@ module Hawkular::Operations::RSpec
                            example)
         end
 
-        it 'Add JDBC driver should add the driver' do
-          wf_server_resource_id = 'Local~~'
+        it 'Add JDBC driver should add the driver' do # Unless it runs in a container
           driver_name = 'CreatedByRubyDriver' + @not_so_random_uuid
           driver_bits = IO.binread("#{File.dirname(__FILE__)}/../resources/driver.jar")
           wf_path = CanonicalPath.new(tenant_id: @tenant_id,
                                       feed_id: @feed_id,
-                                      resource_ids: [wf_server_resource_id]).to_s
+                                      resource_ids: [@wf_server_resource_id]).to_s
 
           actual_data = {}
 
@@ -178,26 +188,27 @@ module Hawkular::Operations::RSpec
               actual_data[:data] = data
             end
             on.failure do |error|
-              actual_data[:data] = {}
-              puts 'error callback was called, reason: ' + error.to_s
+              actual_data[:data] = error
+              puts 'error callback was called, reason: ' + error.to_s unless @agent_immutable
             end
           end
           actual_data = wait_for actual_data
-          expect(actual_data['status']).to eq('OK')
-          expect(actual_data['message']).to start_with('Added JDBC Driver')
-          expect(actual_data['driverName']).to eq(driver_name)
+          expect(actual_data['status']).to eq('OK') unless @agent_immutable
+          expect(actual_data['message']).to start_with('Added JDBC Driver') unless @agent_immutable
+          expect(actual_data['driverName']).to eq(driver_name) unless @agent_immutable
+          expect(actual_data).to include('Command not allowed because the agent is immutable') if @agent_immutable
         end
 
         it 'Restart should be performed and eventually respond with success' do
           wf_server_resource_id = 'Local~~'
-          alerts_war_resource_id = 'Local~%2Fdeployment%3Dhawkular-alerts-actions-email.war'
+          status_war_resource_id = 'Local~%2Fdeployment%3Dhawkular-status.war'
           path = CanonicalPath.new(tenant_id: @tenant_id,
                                    feed_id: @feed_id,
-                                   resource_ids: [wf_server_resource_id, alerts_war_resource_id])
+                                   resource_ids: [wf_server_resource_id, status_war_resource_id])
 
           restart = {
             resource_path: path.to_s,
-            deployment_name: 'hawkular-alerts-actions-email.war'
+            deployment_name: 'hawkular-status.war'
           }
 
           actual_data = {}
@@ -244,14 +255,14 @@ module Hawkular::Operations::RSpec
 
         it 'Disable should be performed and eventually respond with success' do
           wf_server_resource_id = 'Local~~'
-          alerts_war_resource_id = 'Local~%2Fdeployment%3Dhawkular-alerts-actions-email.war'
+          status_war_resource_id = 'Local~%2Fdeployment%3Dhawkular-status.war'
           path = CanonicalPath.new(tenant_id: @tenant_id,
                                    feed_id: @feed_id,
-                                   resource_ids: [wf_server_resource_id, alerts_war_resource_id])
+                                   resource_ids: [wf_server_resource_id, status_war_resource_id])
 
           disable = {
             resource_path: path.to_s,
-            deployment_name: 'hawkular-alerts-actions-email.war'
+            deployment_name: 'hawkular-status.war'
           }
           actual_data = {}
           client.disable_deployment(disable) do |on|
@@ -259,13 +270,14 @@ module Hawkular::Operations::RSpec
               actual_data[:data] = data
             end
             on.failure do |error|
-              actual_data[:data] = {}
-              puts 'error callback was called, reason: ' + error.to_s
+              actual_data[:data] = error
+              puts 'error callback was called, reason: ' + error.to_s unless @agent_immutable
             end
           end
           actual_data = wait_for actual_data
-          expect(actual_data['status']).to eq('OK')
-          expect(actual_data['message']).to start_with('Performed [Disable Deployment] on')
+          expect(actual_data['status']).to eq('OK') unless @agent_immutable
+          expect(actual_data['message']).to start_with('Performed [Disable Deployment] on') unless @agent_immutable
+          expect(actual_data).to include('Command not allowed because the agent is immutable') if @agent_immutable
         end
 
         it 'Add non-XA datasource should be doable' do
@@ -300,16 +312,17 @@ module Hawkular::Operations::RSpec
               actual_data[:data] = data
             end
             on.failure do |error|
-              actual_data[:data] = { 'status' => 'ERROR' }
-              puts 'error callback was called, reason: ' + error.to_s
+              actual_data[:data] = error
+              puts 'error callback was called, reason: ' + error.to_s unless @agent_immutable
             end
           end
           actual_data = wait_for actual_data
-          expect(actual_data['status']).to eq('OK')
-          expect(actual_data['message']).to start_with('Added Datasource')
-          expect(actual_data['xaDatasource']).to be_falsey
-          expect(actual_data['datasourceName']).to eq(payload[:datasourceName])
-          expect(actual_data['resourcePath']).to eq(payload[:resourcePath])
+          expect(actual_data['status']).to eq('OK') unless @agent_immutable
+          expect(actual_data['message']).to start_with('Added Datasource') unless @agent_immutable
+          expect(actual_data['xaDatasource']).to be_falsey unless @agent_immutable
+          expect(actual_data['datasourceName']).to eq(payload[:datasourceName]) unless @agent_immutable
+          expect(actual_data['resourcePath']).to eq(payload[:resourcePath]) unless @agent_immutable
+          expect(actual_data).to include('Command not allowed because the agent is immutable') if @agent_immutable
         end
 
         it 'Add XA datasource should be doable' do
@@ -344,16 +357,17 @@ module Hawkular::Operations::RSpec
               actual_data[:data] = data
             end
             on.failure do |error|
-              actual_data[:data] = { 'status' => 'ERROR' }
-              puts 'error callback was called, reason: ' + error.to_s
+              actual_data[:data] = error
+              puts 'error callback was called, reason: ' + error.to_s unless @agent_immutable
             end
           end
           actual_data = wait_for actual_data
-          expect(actual_data['status']).to eq('OK')
-          expect(actual_data['message']).to start_with('Added Datasource')
-          expect(actual_data['xaDatasource']).to be_truthy
-          expect(actual_data['datasourceName']).to eq(payload[:datasourceName])
-          expect(actual_data['resourcePath']).to eq(payload[:resourcePath])
+          expect(actual_data['status']).to eq('OK') unless @agent_immutable
+          expect(actual_data['message']).to start_with('Added Datasource') unless @agent_immutable
+          expect(actual_data['xaDatasource']).to be_truthy unless @agent_immutable
+          expect(actual_data['datasourceName']).to eq(payload[:datasourceName]) unless @agent_immutable
+          expect(actual_data['resourcePath']).to eq(payload[:resourcePath]) unless @agent_immutable
+          expect(actual_data).to include('Command not allowed because the agent is immutable') if @agent_immutable
         end
 
         it 'should not be possible to perform on closed client' do
@@ -371,18 +385,18 @@ module Hawkular::Operations::RSpec
 
         it 'Restart can be run multiple times in parallel' do
           wf_server_resource_id = 'Local~~'
-          alerts_war_resource_id = 'Local~%2Fdeployment%3Dhawkular-alerts-actions-email.war'
+          status_war_resource_id = 'Local~%2Fdeployment%3Dhawkular-status.war'
           console_war_resource_id = 'Local~%2Fdeployment%3Dhawkular-wildfly-agent-download.war'
           path1 = CanonicalPath.new(tenant_id: @tenant_id,
                                     feed_id: @feed_id,
-                                    resource_ids: [wf_server_resource_id, alerts_war_resource_id])
+                                    resource_ids: [wf_server_resource_id, status_war_resource_id])
           path2 = CanonicalPath.new(tenant_id: @tenant_id,
                                     feed_id: @feed_id,
                                     resource_ids: [wf_server_resource_id, console_war_resource_id])
 
           restart1 = {
             resource_path: path1.to_s,
-            deployment_name: 'hawkular-alerts-actions-email.war'
+            deployment_name: 'hawkular-status.war'
           }
 
           restart2 = {
@@ -427,15 +441,16 @@ module Hawkular::Operations::RSpec
               actual_data[:data] = data
             end
             on.failure do |error|
-              actual_data[:data] = {}
-              puts 'error callback was called, reason: ' + error.to_s
+              actual_data[:data] = error
+              puts 'error callback was called, reason: ' + error.to_s unless @agent_immutable
             end
           end
           actual_data = wait_for actual_data
-          expect(actual_data['status']).to eq('OK')
-          expect(actual_data['message']).to start_with('Performed [Deploy] on')
-          expect(actual_data['destinationFileName']).to eq(app_name)
-          expect(actual_data['resourcePath']).to eq(wf_path)
+          expect(actual_data['status']).to eq('OK') unless @agent_immutable
+          expect(actual_data['message']).to start_with('Performed [Deploy] on') unless @agent_immutable
+          expect(actual_data['destinationFileName']).to eq(app_name) unless @agent_immutable
+          expect(actual_data['resourcePath']).to eq(wf_path) unless @agent_immutable
+          expect(actual_data).to include('Command not allowed because the agent is immutable') if @agent_immutable
         end
 
         it 'Undeploy deployment should be performed and eventually respond with success' do
@@ -454,13 +469,14 @@ module Hawkular::Operations::RSpec
               actual_data[:data] = data
             end
             on.failure do |error|
-              actual_data[:data] = { 'status' => 'ERROR' }
-              puts 'error callback was called, reason: ' + error.to_s
+              actual_data[:data] = error
+              puts 'error callback was called, reason: ' + error.to_s unless @agent_immutable
             end
           end
           actual_data = wait_for actual_data
-          expect(actual_data['status']).to eq('OK')
-          expect(actual_data['message']).to start_with('Performed [Undeploy] on')
+          expect(actual_data['status']).to eq('OK') unless @agent_immutable
+          expect(actual_data['message']).to start_with('Performed [Undeploy] on') unless @agent_immutable
+          expect(actual_data).to include('Command not allowed because the agent is immutable') if @agent_immutable
         end
 
         it 'Remove datasource should be performed and eventually respond with success' do
@@ -480,23 +496,24 @@ module Hawkular::Operations::RSpec
               actual_data[:data] = data
             end
             on.failure do |error|
-              actual_data[:data] = {}
-              puts 'error callback was called, reason: ' + error.to_s
+              actual_data[:data] = error
+              puts 'error callback was called, reason: ' + error.to_s unless @agent_immutable
             end
           end
           actual_data = wait_for actual_data
-          expect(actual_data['status']).to eq('OK')
-          expect(actual_data['message']).to start_with('Performed [Remove] on')
-          expect(actual_data['serverRefreshIndicator']).to eq('RELOAD-REQUIRED')
+          expect(actual_data['status']).to eq('OK') unless @agent_immutable
+          expect(actual_data['message']).to start_with('Performed [Remove] on') unless @agent_immutable
+          expect(actual_data['serverRefreshIndicator']).to eq('RELOAD-REQUIRED') unless @agent_immutable
+          expect(actual_data).to include('Command not allowed because the agent is immutable') if @agent_immutable
         end
 
         it 'Remove JDBC driver should be performed and eventually respond with success' do
-          wf_server_resource_id = 'Local~~'
+          # Unless it runs in a container
           driver_resource_id = 'Local~%2Fsubsystem%3Ddatasources%2Fjdbc-driver%3DCreatedByRubyDriver'
           driver_resource_id << @not_so_random_uuid
           path = CanonicalPath.new(tenant_id: @tenant_id,
                                    feed_id: @feed_id,
-                                   resource_ids: [wf_server_resource_id, driver_resource_id]).to_s
+                                   resource_ids: [@wf_server_resource_id, driver_resource_id]).to_s
 
           actual_data = {}
           client.invoke_specific_operation({ resourcePath: path }, 'RemoveJdbcDriver') do |on|
@@ -504,14 +521,16 @@ module Hawkular::Operations::RSpec
               actual_data[:data] = data
             end
             on.failure do |error|
-              actual_data[:data] = {}
-              puts 'error callback was called, reason: ' + error.to_s
+              actual_data[:data] = error
+              puts 'error callback was called, reason: ' + error.to_s unless @agent_immutable
             end
           end
           actual_data = wait_for actual_data
-          expect(actual_data['status']).to eq('OK')
-          expect(actual_data['resourcePath']).to eq(path)
-          expect(actual_data['message']).to start_with('Performed [Remove] on a [JDBC Driver]')
+          expect(actual_data['status']).to eq('OK') unless @agent_immutable
+          expect(actual_data['resourcePath']).to eq(path) unless @agent_immutable
+          expect(actual_data['message']).to start_with(
+            'Performed [Remove] on a [JDBC Driver]') unless @agent_immutable
+          expect(actual_data).to include('Command not allowed because the agent is immutable') if @agent_immutable
         end
 
         xit 'Export JDR should retrieve the zip file with the report' do
@@ -536,6 +555,36 @@ module Hawkular::Operations::RSpec
           expect(actual_data['message']).to start_with('Performed [Export JDR] on')
           expect(actual_data['fileName']).to start_with('jdr_')
         end
+
+        it 'Update collection intervals should be performed and eventually respond with success' do
+          wf_server_resource_id = 'Local~~'
+          wf_agent_id = 'Local~%2Fsubsystem%3Dhawkular-wildfly-agent'
+          path = CanonicalPath.new(tenant_id: @tenant_id,
+                                   feed_id: @feed_id,
+                                   resource_ids: [wf_server_resource_id, wf_agent_id])
+
+          hash = {
+            resourcePath: path.to_s,
+            metricTypes: { 'WildFly Memory Metrics~Heap Max' => 77, 'Unknown~Metric' => 666 },
+            availTypes: { 'Server Availability~Server Availability' => 77, 'Unknown~Avail' => 666 }
+          }
+
+          actual_data = {}
+          client.update_collection_intervals(hash) do |on|
+            on.success do |data|
+              actual_data[:data] = data
+            end
+            on.failure do |error|
+              actual_data[:data] = error
+              puts 'error callback was called, reason: ' + error.to_s unless @agent_immutable
+            end
+          end
+          actual_data = wait_for actual_data
+          expect(actual_data['status']).to eq('OK') unless @agent_immutable
+          expect(
+            actual_data['message']).to start_with('Performed [Update Collection Intervals] on') unless @agent_immutable
+          expect(actual_data).to include('Command not allowed because the agent is immutable') if @agent_immutable
+        end
       end
     end
   end