hawkular-client 2.8.0 → 2.9.0

data/lib/hawkular/inventory/entities.rb

@@ -193,6 +193,15 @@ module Hawkular::Inventory
       CanonicalPath.new(hash)
     end
 
+    # Adds a resource to the path.
+    # @return CanonicalPath referring to resource_id using current as its ancestor.
+    def to_resource(resource_id)
+      hash = to_h
+      hash[:resource_ids] = [] if hash[:resource_ids].nil?
+      hash[:resource_ids].push resource_id
+      CanonicalPath.new(hash)
+    end
+
     def ==(other)
       self.equal?(other) || other.class == self.class && other.state == state
     end

data/lib/hawkular/inventory/inventory_api.rb

@@ -11,7 +11,7 @@ require 'hawkular/inventory/entities'
 #   and thus set to 'test' as default value.
 module Hawkular::Inventory
   # Client class to interact with Hawkular Inventory
-  class InventoryClient < Hawkular::BaseClient
+  class Client < Hawkular::BaseClient
     attr_reader :version
 
     # Create a new Inventory Client
@@ -35,7 +35,7 @@ module Hawkular::Inventory
       fail 'no parameter ":entrypoint" given' if hash[:entrypoint].nil?
       hash[:credentials] ||= {}
       hash[:options] ||= {}
-      InventoryClient.new(hash[:entrypoint], hash[:credentials], hash[:options])
+      Client.new(hash[:entrypoint], hash[:credentials], hash[:options])
     end
 
     # Retrieve the tenant id for the passed credentials.
@@ -194,7 +194,7 @@ module Hawkular::Inventory
     # @return inventory entity
     def get_entity(path)
       c_path = path.is_a?(CanonicalPath) ? path : CanonicalPath.parse(path)
-      http_get("/entity/#{c_path}")
+      http_get("/entity#{c_path}")
     end
 
     # List the metrics for the passed metric type. If feed is not passed in the path,
@@ -357,6 +357,13 @@ module Hawkular::Inventory
       rescue HawkularException => error
         # 409 We already exist -> that is ok
         raise unless error.status_code == 409
+        # Ensure we have a consistent behaviour if resource already exists Issue#180
+        if parent_res_path.nil?
+          hash = type_path.to_h
+          hash.delete(:metric_type_id)
+          path = CanonicalPath.new(hash)
+        end
+        res = get_resource(path.to_resource(resource_id)).to_h
       end
       Resource.new(res)
     end
@@ -558,4 +565,7 @@ module Hawkular::Inventory
       end
     end
   end
+
+  InventoryClient = Client
+  deprecate_constant :InventoryClient if self.respond_to? :deprecate_constant
 end

data/lib/hawkular/logger.rb

@@ -0,0 +1,14 @@
+require 'logger'
+require 'hawkular/env_config'
+
+module Hawkular
+  class Logger
+    def initialize(file = STDOUT)
+      @logger = ::Logger.new(file)
+    end
+
+    def log(message, priority = :info)
+      @logger.send(priority, message) if EnvConfig.log_response?
+    end
+  end
+end

data/lib/hawkular/metrics/metric_api.rb

@@ -12,6 +12,25 @@ module Hawkular::Metrics
       array
     end
 
+    def tags_param(tags)
+      tags.map { |k, v| "#{k}:#{v}" }.join(',')
+    end
+
+    # Retrieve all types of metrics datapoints by tags
+    # @param tags [Hash]
+    # @param buckets [Integer] optional number of buckets
+    # @param bucketDuration [String] optional interval (default no aggregation)
+    # @param starts [Integer] optional timestamp (default now - 8h)
+    # @param ends [Integer] optional timestamp (default now)
+    # @return [Array[Hash]] datapoints
+    def data_by_tags(tags, buckets: nil, bucketDuration:nil, start:nil, ends: nil)
+      data = {
+        tags: tags_param(tags), buckets: buckets, bucketDuration: bucketDuration, start: start, end: ends
+      }
+
+      http_post('metrics/stats/query', data)
+    end
+
     # Return version and status information for the used version of Hawkular-Metrics
     # @return [Hash{String=>String}]
     #         ('Implementation-Version', 'Built-From-Git-SHA1', 'Status')
@@ -112,7 +131,7 @@ module Hawkular::Metrics
       # @param tags [Hash]
       # @return [Array[MetricDefinition]]
       def query(tags = nil)
-        tags_filter = tags.nil? ? '' : "&tags=#{tags_param(tags)}"
+        tags_filter = tags.nil? ? '' : "&tags=#{@client.tags_param(tags)}"
         @client.http_get("/metrics/?type=#{@type}#{tags_filter}").map do |g|
           Hawkular::Metrics::MetricDefinition.new(g)
         end
@@ -189,21 +208,18 @@ module Hawkular::Metrics
       # @param starts [Integer] optional timestamp (default now - 8h)
       # @param ends [Integer] optional timestamp (default now)
       # @param bucketDuration [String] optional interval (default no aggregation)
+      # @param buckets [Integer] optional number of buckets
       # @return [Array[Hash]] datapoints
       # @see #push_data #push_data for datapoint detail
-      def get_data_by_tags(tags, starts: nil, ends: nil, bucketDuration: nil)
-        params = { tags: tags_param(tags), start: starts,
-                   end: ends, bucketDuration: bucketDuration }
+      def get_data_by_tags(tags, starts: nil, ends: nil, bucketDuration: nil, buckets:nil)
+        params = { tags: @client.tags_param(tags), start: starts,
+                   end: ends, bucketDuration: bucketDuration, buckets: buckets }
         path = "/#{@resource}/"
         @legacy_api ? path << 'data/?' : path << 'stats/?'
         resp = @client.http_get(path + encode_params(params))
         resp.is_a?(Array) ? resp : [] # API returns no content (empty Hash) instead of empty array
       end
 
-      def tags_param(tags)
-        tags.map { |k, v| "#{k}:#{v}" }.join(',')
-      end
-
       def encode_params(params)
         URI.encode_www_form(params.select { |_k, v| !v.nil? })
       end

data/lib/hawkular/operations/operations_api.rb

@@ -13,6 +13,7 @@ class Proc
       method_name = callable.to_sym
       define_method(method_name) { |&block| block.nil? ? true : block.call(result) }
       define_method("#{method_name}?") { true }
+
       # method_missing is here because we are not forcing the client to provide both success and error callbacks
       # rubocop:disable Lint/NestedMethodDefinition
       # https://github.com/bbatsov/rubocop/issues/2704
@@ -27,19 +28,17 @@ end
 # Operations module allows invoking operation on the WildFly agent.
 module Hawkular::Operations
   # Client class to interact with the agent via websockets
-  class OperationsClient < Hawkular::BaseClient
+  class Client < Hawkular::BaseClient
     include WebSocket::Client
 
-    attr_accessor :ws, :session_id
+    attr_accessor :ws, :session_id, :logger
 
     # helper for parsing the "OperationName=json_payload" messages
     class WebSocket::Frame::Data
       def to_msg_hash
         chunks = split('=', 2)
-        {
-          operationName: chunks[0],
-          data: JSON.parse(chunks[1])
-        }
+
+        { operationName: chunks[0], data: JSON.parse(chunks[1]) }
       rescue
         {}
       end
@@ -62,39 +61,52 @@ module Hawkular::Operations
     # @example
     #   Hawkular::Operations::OperationsClient.new(credentials: {username: 'jdoe', password: 'password'})
     def initialize(args)
-      args[:use_secure_connection] ||= false
-      ep = args[:entrypoint]
-
-      unless ep.nil?
-        uri = URI.parse ep.to_s
+      args = {
+        credentials: {},
+        options: {},
+        wait_time: 0.5,
+        use_secure_connection: false,
+        entrypoint: nil
+      }.merge(args)
+
+      if args[:entrypoint]
+        uri = URI.parse(args[:entrypoint].to_s)
         args[:host] = "#{uri.host}:#{uri.port}"
         args[:use_secure_connection] = %w(https wss).include?(uri.scheme) ? true : false
       end
 
       fail 'no parameter ":host" or ":entrypoint" given' if args[:host].nil?
-      args[:credentials] ||= {}
-      args[:options] ||= {}
-      args[:wait_time] ||= 0.5
+
       super(args[:host], args[:credentials], args[:options])
+
       url = "ws#{args[:use_secure_connection] ? 's' : ''}://#{args[:host]}/hawkular/command-gateway/ui/ws"
-      ws_options = {}
+
       creds = args[:credentials]
       base64_creds = ["#{creds[:username]}:#{creds[:password]}"].pack('m').delete("\r\n")
-      ws_options[:headers] = { 'Authorization' => 'Basic ' + base64_creds,
-                               'Hawkular-Tenant' => args[:options][:tenant],
-                               'Accept' => 'application/json'
+
+      ws_options = {
+        headers:  {
+          'Authorization' => 'Basic ' + base64_creds,
+          'Hawkular-Tenant' => args[:options][:tenant],
+          'Accept' => 'application/json'
+        }
       }
 
+      @logger = Hawkular::Logger.new
+
       @ws = Simple.connect url, ws_options do |client|
         client.on(:message, once: true) do |msg|
           parsed_message = msg.data.to_msg_hash
-          puts parsed_message if ENV['HAWKULARCLIENT_LOG_RESPONSE']
+
+          logger.log("Sent WebSocket message: #{parsed_message}")
+
           case parsed_message[:operationName]
           when 'WelcomeResponse'
             @session_id = parsed_message[:data]['sessionId']
           end
         end
       end
+
       sleep args[:wait_time]
     end
 
@@ -135,6 +147,7 @@ module Hawkular::Operations
     #
     # @param [Hash] hash Arguments for deployment
     # @option hash [String]  :resource_path canonical path of the WildFly server into which we deploy
+    #                        or of the domain controller if we deploy into a server group (in case of domain mode)
     # @option hash [String]  :destination_file_name resulting file name
     # @option hash [String]  :binary_content binary content representing the war file
     # @option hash [String]  :enabled whether the deployment should be enabled immediately, or not (default = true)
@@ -295,6 +308,22 @@ module Hawkular::Operations
       invoke_specific_operation({ resourcePath: resource_path }, 'ExportJdr', &callback)
     end
 
+    # Updates the collection intervals.
+    #
+    # @param [Hash] hash Arguments for update collection intervals
+    # @option hash {resourcePath} a resource managed by the target agent
+    # @option hash {metricTypes} A map with key=MetricTypeId, value=interval (seconds).
+    # MetricTypeId must be of form MetricTypeSet~MetricTypeName
+    # @option hash {availTypes} A map with key=AvailTypeId, value=interval (seconds).
+    # AvailTypeId must be of form AvailTypeSet~AvailTypeName
+    #
+    # @param callback [Block] callback that is run after the operation is done
+    def update_collection_intervals(hash, &callback)
+      required = [:resourcePath, :metricTypes, :availTypes]
+      check_pre_conditions hash, required, &callback
+      invoke_specific_operation(hash, 'UpdateCollectionIntervals', &callback)
+    end
+
     private
 
     def invoke_operation_helper(operation_payload, operation_name = nil, binary_content = nil, &callback)
@@ -333,12 +362,16 @@ module Hawkular::Operations
       # register a callback handler
       @ws.on :message do |msg|
         parsed = msg.data.to_msg_hash
-        OperationsClient.log_message(parsed)
+
+        logger = Hawkular::Logger.new
+        logger.log("Received WebSocket msg: #{parsed}")
+
         case parsed[:operationName]
         when "#{operation_name}Response"
           same_path = parsed[:data]['resourcePath'] == operation_payload[:resourcePath]
           # failed operations don't return the operation name from some strange reason
-          same_name = parsed[:data]['operationName'] == operation_payload[:operationName]
+          same_name = operation_payload[:operationName].nil? ||
+                      parsed[:data]['operationName'] == operation_payload[:operationName].to_s
           if same_path # using the resource path as a correlation id
             success = same_name && parsed[:data]['status'] == 'OK'
             success ? callback.perform(:success, parsed[:data]) : callback.perform(:failure, parsed[:data]['message'])
@@ -355,10 +388,6 @@ module Hawkular::Operations
       callback.perform(:failure, parsed_message == {} ? 'error' : parsed_message[:data]['errorMessage'])
     end
 
-    def self.log_message(message)
-      puts "\nreceived WebSocket msg: #{message}\n" if ENV['HAWKULARCLIENT_LOG_RESPONSE']
-    end
-
     def prepare_payload_hash(ignored_params, hash)
       # it filters out ignored params and convert keys from snake_case to camelCase
       Hash[hash.select { |k, _| !ignored_params.include? k }.map { |k, v| [to_camel_case(k.to_s).to_sym, v] }]
@@ -369,4 +398,7 @@ module Hawkular::Operations
       ret[0, 1].downcase + ret[1..-1]
     end
   end
+
+  OperationsClient = Client
+  deprecate_constant :OperationsClient if self.respond_to? :deprecate_constant
 end

data/lib/hawkular/tokens/tokens_api.rb

@@ -3,7 +3,7 @@ require 'hawkular/base_client'
 # Token module provides access to the Secret Store REST API.
 module Hawkular::Token
   # Client class to interact with the Secret Store
-  class TokenClient < Hawkular::BaseClient
+  class Client < Hawkular::BaseClient
     # Create a new Secret Store client
     # @param entrypoint [String] base url of Hawkular - e.g http://localhost:8080
     # @param credentials [Hash{String=>String}] Hash of username, password
@@ -31,4 +31,7 @@ module Hawkular::Token
       http_post('/secret-store/v1/tokens/create', token_attributes, auth_header)
     end
   end
+
+  TokenClient = Client
+  deprecate_constant :TokenClient if self.respond_to? :deprecate_constant
 end

data/lib/hawkular/version.rb

@@ -4,5 +4,5 @@
 # @see https://github.com/hawkular
 module Hawkular
   # Version of the Hawkular Ruby Gem
-  VERSION = '2.8.0'.freeze
+  VERSION = '2.9.0'.freeze
 end

data/lib/hawkularclient.rb

@@ -0,0 +1,8 @@
+require 'hawkular/version'
+require 'hawkular/inventory/inventory_api'
+require 'hawkular/metrics/metrics_client'
+require 'hawkular/alerts/alerts_api'
+require 'hawkular/tokens/tokens_api'
+require 'hawkular/operations/operations_api'
+require 'hawkular/base_client'
+require 'hawkular/hawkular_client'

data/spec/integration/alerts_spec.rb

@@ -1,5 +1,5 @@
-require "#{File.dirname(__FILE__)}/../vcr/vcr_setup"
-require "#{File.dirname(__FILE__)}/../spec_helper"
+require_relative '../vcr/vcr_setup'
+require_relative '../spec_helper'
 
 module Hawkular::Alerts::RSpec
   ALERTS_BASE = 'http://localhost:8080/hawkular/alerts'
@@ -10,7 +10,7 @@ module Hawkular::Alerts::RSpec
     before(:all) do
       # Setup for testing
       record('Alert/Triggers', credentials, 'setup') do
-        @client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, credentials, options)
+        @client = Hawkular::Alerts::Client.new(ALERTS_BASE, credentials, options)
         json = IO.read('spec/integration/alert-resources/triggers-test-data.json')
         trigger_hash = JSON.parse(json)
         @client.bulk_import_triggers trigger_hash
@@ -20,7 +20,7 @@ module Hawkular::Alerts::RSpec
     after(:all) do
       # cleanup test values
       record('Alert/Triggers', credentials, 'setup_cleanup') do
-        @client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, credentials, options)
+        @client = Hawkular::Alerts::Client.new(ALERTS_BASE, credentials, options)
         json = IO.read('spec/integration/alert-resources/triggers-test-data.json')
         trigger_hash = JSON.parse(json)
         trigger_hash['triggers'].each do |trigger|
@@ -39,7 +39,7 @@ module Hawkular::Alerts::RSpec
     end
 
     before(:each) do
-      @client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds, options)
+      @client = Hawkular::Alerts::Client.new(ALERTS_BASE, creds, options)
     end
 
     it 'Should List Triggers' do
@@ -192,7 +192,7 @@ module Hawkular::Alerts::RSpec
 
       ret = @client.get_action_definition 'email'
       expect(ret.size).to be(1)
-      expect(ret['email'].size).to be(7)
+      expect(ret['email'].size).to be(8)
 
       expect { @client.get_action_definition '-does-not-exist-' }
         .to raise_error(Hawkular::BaseClient::HawkularException)
@@ -229,7 +229,7 @@ module Hawkular::Alerts::RSpec
     end
 
     before(:each) do
-      @client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds, options)
+      @client = Hawkular::Alerts::Client.new(ALERTS_BASE, creds, options)
     end
 
     it 'Should operate a complex group trigger' do
@@ -414,7 +414,7 @@ module Hawkular::Alerts::RSpec
     before(:all) do
       # Setup for testing
       record('Alert/Alerts', credentials, 'setup') do
-        @client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, credentials, options)
+        @client = Hawkular::Alerts::Client.new(ALERTS_BASE, credentials, options)
         json = IO.read('spec/integration/alert-resources/alerts-test-data.json')
         trigger_hash = JSON.parse(json)
         @client.bulk_import_triggers trigger_hash
@@ -429,7 +429,7 @@ module Hawkular::Alerts::RSpec
     after(:all) do
       # cleanup test values
       record('Alert/Alerts', credentials, 'setup_cleanup') do
-        @client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, credentials, options)
+        @client = Hawkular::Alerts::Client.new(ALERTS_BASE, credentials, options)
         json = IO.read('spec/integration/alert-resources/alerts-test-data.json')
         trigger_hash = JSON.parse(json)
         trigger_hash['triggers'].each do |trigger|
@@ -451,11 +451,11 @@ module Hawkular::Alerts::RSpec
     end
 
     before(:each) do
-      @client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds, options)
+      @client = Hawkular::Alerts::Client.new(ALERTS_BASE, creds, options)
     end
 
     it 'Should list alerts' do
-      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds, options)
+      client = Hawkular::Alerts::Client.new(ALERTS_BASE, creds, options)
 
       alerts = client.list_alerts
 
@@ -464,7 +464,7 @@ module Hawkular::Alerts::RSpec
     end
 
     it 'Should list open alerts' do
-      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds, options)
+      client = Hawkular::Alerts::Client.new(ALERTS_BASE, creds, options)
 
       alerts = client.list_alerts('statuses' => 'OPEN')
 
@@ -473,7 +473,7 @@ module Hawkular::Alerts::RSpec
     end
 
     it 'Should list alerts for trigger' do
-      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds, options)
+      client = Hawkular::Alerts::Client.new(ALERTS_BASE, creds, options)
 
       alerts = client.get_alerts_for_trigger 'hello-world-trigger'
 
@@ -482,7 +482,7 @@ module Hawkular::Alerts::RSpec
     end
 
     it 'Should list alerts for unknown trigger' do
-      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds, options)
+      client = Hawkular::Alerts::Client.new(ALERTS_BASE, creds, options)
 
       alerts = client.get_alerts_for_trigger 'does-not-exist'
 
@@ -491,7 +491,7 @@ module Hawkular::Alerts::RSpec
     end
 
     it 'Should fetch single alert' do
-      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds, options)
+      client = Hawkular::Alerts::Client.new(ALERTS_BASE, creds, options)
 
       alert_id = client.list_alerts('statuses' => 'OPEN').first.id
 
@@ -502,7 +502,7 @@ module Hawkular::Alerts::RSpec
     end
 
     it 'Should resolve an alert' do
-      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds, options)
+      client = Hawkular::Alerts::Client.new(ALERTS_BASE, creds, options)
 
       alert_id = client.list_alerts('statuses' => 'OPEN').first.id
       alert = client.get_single_alert alert_id
@@ -517,7 +517,7 @@ module Hawkular::Alerts::RSpec
 
     # # TODO enable when the semantics on the server side is known
     #     it 'Should resolve an alert2' do
-    #       client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE,creds)
+    #       client = Hawkular::Alerts::Client.new(ALERTS_BASE,creds)
     #
     #       alert_id = '28026b36-8fe4-4332-84c8-524e173a68bf-snert~Local_jvm_garba-1446977734134'
     #       client.resolve_alert alert_id
@@ -525,7 +525,7 @@ module Hawkular::Alerts::RSpec
     #     end
 
     it 'Should acknowledge an alert' do
-      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds, options)
+      client = Hawkular::Alerts::Client.new(ALERTS_BASE, creds, options)
 
       alert_id = client.list_alerts('statuses' => 'OPEN').first.id
       client.get_single_alert alert_id
@@ -535,6 +535,29 @@ module Hawkular::Alerts::RSpec
       alert = client.get_single_alert alert_id
       expect(alert.ackBy).to eql('Heiko')
     end
+
+    it 'Should add tags to existing alert' do
+      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds, options)
+      alert_id = client.list_alerts.first.id
+      alert_not_found = client.list_alerts(tags: 'new-tag-name|tag_value', thin: true).first
+      client.add_tags([alert_id], ['new-tag-name|tag_value', 'othertag|othervalue'])
+      alert_found_by_new_tag_name = client.list_alerts(tags: 'new-tag-name|tag_value', thin: true).first
+
+      expect(alert_not_found).to be_nil
+      expect(alert_found_by_new_tag_name).to_not be_nil
+    end
+
+    it 'Should remove tags from existing alert' do
+      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds, options)
+      alert_id = client.list_alerts.first.id
+      client.add_tags([alert_id], ['new-tag-name|tag_value', 'othertag|othervalue'])
+      alert_found_by_new_tag_name = client.list_alerts(tags: 'new-tag-name|tag_value', thin: true).first
+      client.remove_tags([alert_id], ['new-tag-name'])
+      alert_not_found = client.list_alerts(tags: 'new-tag-name|tag_value', thin: true).first
+
+      expect(alert_found_by_new_tag_name).to_not be_nil
+      expect(alert_not_found).to be_nil
+    end
   end
 
   describe 'Alert' do
@@ -548,7 +571,7 @@ module Hawkular::Alerts::RSpec
     end
 
     before(:each) do
-      @client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds)
+      @client = Hawkular::Alerts::Client.new(ALERTS_BASE, creds)
     end
 
     it 'Should return the version' do
@@ -561,7 +584,7 @@ module Hawkular::Alerts::RSpec
     before(:all) do
       # Setup for testing
       record('Alert/Events', credentials, 'setup') do
-        @client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, credentials, options)
+        @client = Hawkular::Alerts::Client.new(ALERTS_BASE, credentials, options)
         json = IO.read('spec/integration/alert-resources/events-test-data.json')
         hash = JSON.parse(json)
         hash['events'].each do |event|
@@ -573,7 +596,7 @@ module Hawkular::Alerts::RSpec
     after(:all) do
       # cleanup test values
       record('Alert/Events', credentials, 'setup_cleanup') do
-        @client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, credentials, options)
+        @client = Hawkular::Alerts::Client.new(ALERTS_BASE, credentials, options)
         json = IO.read('spec/integration/alert-resources/events-test-data.json')
         hash = JSON.parse(json)
         hash['events'].each do |event|
@@ -592,7 +615,7 @@ module Hawkular::Alerts::RSpec
     end
 
     it 'Should list events' do
-      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds, options)
+      client = Hawkular::Alerts::Client.new(ALERTS_BASE, creds, options)
 
       events = client.list_events('thin' => true)
 
@@ -601,7 +624,7 @@ module Hawkular::Alerts::RSpec
     end
 
     it 'Should list events using criteria' do
-      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds, options)
+      client = Hawkular::Alerts::Client.new(ALERTS_BASE, creds, options)
 
       events = client.list_events('categories' => %w(my-category-01 my-category-02))
 
@@ -610,7 +633,7 @@ module Hawkular::Alerts::RSpec
     end
 
     it 'Should not list events using criteria' do
-      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds, options)
+      client = Hawkular::Alerts::Client.new(ALERTS_BASE, creds, options)
 
       events = client.list_events('startTime' => 0, 'endTime' => 1000)
 
@@ -622,7 +645,7 @@ module Hawkular::Alerts::RSpec
       the_id = "test-event@#{Time.new.to_i}"
       VCR.eject_cassette
       record('Alert/Events', credentials.merge(id: the_id), cassette_name) do
-        client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds, options)
+        client = Hawkular::Alerts::Client.new(ALERTS_BASE, creds, options)
 
         the_event = client.create_event(the_id, 'MyCategory', 'Li la lu',
                                         context: { message: 'This is a test' },
@@ -639,7 +662,7 @@ module Hawkular::Alerts::RSpec
       the_id = "test-event@#{Time.new.to_i}"
       VCR.eject_cassette
       record('Alert/Events', credentials.merge(id: the_id), cassette_name) do
-        client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds, options)
+        client = Hawkular::Alerts::Client.new(ALERTS_BASE, creds, options)
         client.create_event(the_id, 'MyCategory', 'Li la lu',
                             context: { message: 'This is a test' },
                             tags: { tag_name: 'tag-value' })
@@ -662,7 +685,7 @@ module Hawkular::Alerts::RSpec
     end
 
     before(:each) do
-      @client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds, options)
+      @client = Hawkular::Alerts::Client.new(ALERTS_BASE, creds, options)
     end
 
     it 'Should create and fire a trigger' do