hawkular-client 0.2.0 → 0.2.1

data/lib/metrics/metric_api.rb

@@ -43,12 +43,12 @@ module Hawkular::Metrics
     # types (counters, gauges, availabilities).
     class Metrics
       # @param client [Client]
-      # @param metricType [String] metric type (one of "counter", "gauge", "availability")
+      # @param metric_type [String] metric type (one of "counter", "gauge", "availability")
       # @param resource [String] REST resource name for accessing metrics
       #    of given type (one of "counters", "gauges", "availability")
-      def initialize(client, metricType, resource)
+      def initialize(client, metric_type, resource)
         @client = client
-        @type = metricType
+        @type = metric_type
         @resource = resource
       end
 
@@ -84,9 +84,9 @@ module Hawkular::Metrics
       end
 
       # update tags for given metric definition
-      # @param metricDefinition [MetricDefinition]
-      def update_tags(metricDefinition)
-        @client.http_put("/#{@resource}/#{metricDefinition.id}/tags", metricDefinition.hash[:tags])
+      # @param metric_definition [MetricDefinition]
+      def update_tags(metric_definition)
+        @client.http_put("/#{@resource}/#{metric_definition.id}/tags", metric_definition.hash[:tags])
       end
 
       # Push metric data
@@ -114,10 +114,15 @@ 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 percentiles [String] optional percentiles to calculate
+      # @param limit [Integer] optional limit the number of data points returned
+      # @param order [String] optional Data point sort order, based on timestamp (ASC, DESC)
       # @return [Array[Hash]] datapoints
       # @see #push_data #push_data for datapoint detail
-      def get_data(id, starts: nil, ends: nil, bucketDuration: nil, buckets: nil)
-        params = { start: starts, end: ends, bucketDuration: bucketDuration, buckets: buckets }
+      def get_data(id, starts: nil, ends: nil, bucketDuration: nil, buckets: nil, percentiles: nil, limit: nil,
+                   order: nil)
+        params = { start: starts, end: ends, bucketDuration: bucketDuration, buckets: buckets,
+                   percentiles: percentiles, limit: limit, order: order }
         resp = @client.http_get("/#{@resource}/#{ERB::Util.url_encode(id)}/data/?" +
                  encode_params(params))
         resp.is_a?(Array) ? resp : [] # API returns no content (empty Hash) instead of empty array
@@ -146,7 +151,7 @@ module Hawkular::Metrics
       end
     end
 
-    # Class that interracts with "gauge" metric types
+    # Class that interacts with "gauge" metric types
     class Gauges < Metrics
       # @param client [Client]
       def initialize(client)

data/lib/operations/operations_api.rb

@@ -0,0 +1,247 @@
+require 'hawkular'
+require 'websocket-client-simple'
+require 'json'
+
+# Adding a method `perform` for each block so that we can write nice callbacks for this client
+class Proc
+  def perform(callable, result)
+    call(Class.new do
+      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
+      def method_missing(_method_name, *_args, &_block)
+        false
+      end
+      # rubocop:enable Lint/NestedMethodDefinition
+    end.new)
+  end
+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
+    include WebSocket::Client
+
+    attr_accessor :ws
+
+    # 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])
+        }
+      rescue
+        {}
+      end
+    end
+
+    # Initialize new OperationsClient
+    #
+    # @param [Hash] args Arguments for client
+    #
+    # @option args [String]  :host base url of Hawkular - e.g http://localhost:8080
+    # @option args [Hash{String=>String}]  :credentials Hash of {username, password} or token
+    # @option args [Fixnum]  :wait_time Time in seconds describing how long the constructor should block - handshake
+    #
+    # @example
+    #   Hawkular::Operations::OperationsClient.new(credentials: {username: 'jdoe', password: 'password'})
+    def initialize(args)
+      args[:host] ||= 'localhost:8080'
+      args[:credentials] ||= {}
+      args[:wait_time] ||= 0.5
+      super(args[:host], args[:credentials])
+      # note: if we start using the secured WS, change the protocol to wss://
+      url = "ws://#{entrypoint}/hawkular/command-gateway/ui/ws"
+      @ws = Simple.connect url do |client|
+        client.on(:message, once: true) do |msg|
+          parsed_message = msg.data.to_msg_hash
+          puts parsed_message if ENV['HAWKULARCLIENT_LOG_RESPONSE']
+          case parsed_message[:operationName]
+          when 'WelcomeResponse'
+            @session_id = parsed_message[:data]['sessionId']
+          end
+        end
+      end
+      sleep args[:wait_time]
+    end
+
+    # Closes the WebSocket connection
+    def close_connection!
+      @ws.close
+    end
+
+    # Invokes a generic operation on the Wildfly agent
+    # (the operation name must be specified in the hash)
+    # Note: if success and failure callbacks are omitted, the client will not wait for the Response message
+    # @param hash [Hash{String=>Object}] a hash containing: resourcePath [String] denoting the resource on
+    # which the operation is about to run, operationName [String]
+    # @param callback [Block] callback that is run after the operation is done
+    def invoke_generic_operation(hash, &callback)
+      required = [:resourcePath, :operationName]
+      check_pre_conditions hash, required, &callback
+
+      invoke_operation_helper(hash, &callback)
+    end
+
+    # Invokes operation on the wildfly agent that has it's own message type
+    # @param operation_payload [Hash{String=>Object}] a hash containing: resourcePath [String] denoting
+    # the resource on which the operation is about to run
+    # @param operation_name [String] the name of the operation. This must correspond with the message type, they can be
+    # found here https://git.io/v2h1a (Use only the first part of the name without the Request/Response suffix), e.g.
+    # RemoveDatasource (and not RemoveDatasourceRequest)
+    # @param callback [Block] callback that is run after the operation is done
+    def invoke_specific_operation(operation_payload, operation_name, &callback)
+      fail 'Operation must be specified' if operation_name.nil?
+      required = [:resourcePath]
+      check_pre_conditions operation_payload, required, &callback
+
+      invoke_operation_helper(operation_payload, operation_name, &callback)
+    end
+
+    # Deploys a war file into WildFly
+    #
+    # @param [Hash] hash Arguments for deployment
+    # @option hash [String]  :resource_path canonical path of the WildFly server into which we deploy
+    # @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 or not
+    #
+    # @param callback [Block] callback that is run after the operation is done
+    def add_deployment(hash, &callback)
+      hash[:enabled] ||= true
+      required = [:resource_path, :destination_file_name, :binary_content]
+      check_pre_conditions hash, required, &callback
+
+      operation_payload = prepare_payload_hash([:binary_content], hash)
+      invoke_operation_helper(operation_payload, 'DeployApplication', hash[:binary_content], &callback)
+    end
+
+    # Adds a new datasource
+    #
+    # @param [Hash] hash Arguments for the datasource
+    # @option hash [String]  :resourcePath canonical path of the WildFly server into which we add datasource
+    # @option hash [String]  :xaDatasource XA DS or normal
+    # @option hash [String]  :datasourceName name of the datasource
+    # @option hash [String]  :jndiName JNDI name
+    # @option hash [String]  :driverName this is internal name of the driver in Hawkular
+    # @option hash [String]  :driverClass class of driver
+    # @option hash [String]  :connectionUrl jdbc connection string
+    # @option hash [String]  :datasourceProperties optional properties
+    # @option hash [String]  :username username to DB
+    # @option hash [String]  :password password to DB
+    #
+    # @param callback [Block] callback that is run after the operation is done
+    def add_datasource(hash, &callback)
+      required = [:resourcePath, :xaDatasource, :datasourceName, :jndiName, :driverName, :driverClass, :connectionUrl]
+      check_pre_conditions hash, required, &callback
+
+      invoke_specific_operation(hash, 'AddDatasource', &callback)
+    end
+
+    # Adds a new datasource
+    #
+    # @param [Hash] hash Arguments for the datasource
+    # @option hash [String]  :resource_path canonical path of the WildFly server into which we add driver
+    # @option hash [String]  :driver_jar_name name of the jar file
+    # @option hash [String]  :driver_name name of the jdbc driver (when adding datasource, this is the driverName)
+    # @option hash [String]  :module_name name of the JBoss module into which the driver will be installed - 'foo.bar'
+    # @option hash [String]  :driver_class fully specified java class of the driver - e.q. 'com.mysql.jdbc.Driver'
+    # @option hash [String]  :binary_content driver jar file bits
+    #
+    # @param callback [Block] callback that is run after the operation is done
+    def add_jdbc_driver(hash, &callback)
+      required = [:resource_path, :driver_jar_name, :driver_name, :module_name, :driver_class, :binary_content]
+      check_pre_conditions hash, required, &callback
+
+      operation_payload = prepare_payload_hash([:binary_content], hash)
+      invoke_operation_helper(operation_payload, 'AddJdbcDriver', hash[:binary_content], &callback)
+    end
+
+    # Exports the JDR report
+    #
+    # @param [String] resource_path canonical path of the WildFly server
+    # @param callback [Block] callback that is run after the operation is done
+    def export_jdr(resource_path, &callback)
+      fail 'resource_path must be specified' if resource_path.nil?
+      check_pre_conditions(&callback)
+
+      invoke_specific_operation({ resourcePath: resource_path }, 'ExportJdr', &callback)
+    end
+
+    private
+
+    def invoke_operation_helper(operation_payload, operation_name = nil, binary_content = nil, &callback)
+      # fallback to generic 'ExecuteOperation' if nothing is specified
+      operation_name ||= 'ExecuteOperation'
+      add_credentials! operation_payload
+
+      handle_message(operation_name, operation_payload, &callback) unless callback.nil?
+
+      # sends a message that will actually run the operation
+      payload = "#{operation_name}Request=#{operation_payload.to_json}"
+      payload += binary_content unless binary_content.nil?
+      @ws.send payload, type: binary_content.nil? ? :text : :binary
+    end
+
+    def check_pre_conditions(hash = {}, params = [], &callback)
+      fail 'Handshake with server has not been done.' unless @ws.open?
+      fail 'Hash cannot be nil.' if hash.nil?
+      fail 'callback must have the perform method defined. include Hawkular::Operations' unless
+          callback.nil? || callback.respond_to?('perform')
+      params.each do |property|
+        fail "Hash property #{property} must be specified" if hash[property].nil?
+      end
+    end
+
+    def add_credentials!(hash)
+      hash[:authentication] = @credentials.delete_if { |_, v| v.nil? }
+    end
+
+    def handle_message(operation_name, operation_payload, &callback)
+      client = @ws
+      # register a callback handler
+      @ws.on :message do |msg|
+        parsed = msg.data.to_msg_hash
+        OperationsClient.log_message(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]
+          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'])
+            client.remove_listener :message
+          end
+        when 'GenericErrorResponse'
+          OperationsClient.handle_error parsed, &callback
+          client.remove_listener :message
+        end
+      end
+    end
+
+    def self.handle_error(parsed_message, &callback)
+      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] }]
+    end
+
+    def to_camel_case(str)
+      ret = str.split('_').collect(&:capitalize).join
+      ret[0, 1].downcase + ret[1..-1]
+    end
+  end
+end

data/lib/tokens/tokens_api.rb

@@ -0,0 +1,33 @@
+require 'hawkular'
+
+# 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
+    # 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
+    def initialize(entrypoint = 'http://localhost:8080', credentials = {})
+      super(entrypoint, credentials)
+    end
+
+    # Retrieve the tenant id for the passed credentials.
+    # If no credentials are passed, the ones from the constructor are used
+    # @param credentials [Hash{String=>String}] Hash of username, password, token(optional)
+    # @return [String] tenant id
+    def get_tokens(credentials = {})
+      creds = credentials.empty? ? @credentials : credentials
+      auth_header = { Authorization: base_64_credentials(creds) }
+      http_get('/secret-store/v1/tokens', auth_header)
+    end
+
+    def create_token(credentials = {}, persona = nil, name = 'Token created via Hawkular Ruby Client', expires_at = nil)
+      creds = credentials.empty? ? @credentials : credentials
+      auth_header = { Authorization: base_64_credentials(creds) }
+      auth_header['Hawkular-Persona'] = persona if persona
+
+      token_attributes = { expiresAt: expires_at, attributes: { name: name } }
+      http_post('/secret-store/v1/tokens/create', token_attributes, auth_header)
+    end
+  end
+end

data/lib/version.rb

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

data/spec/integration/alerts_spec.rb

@@ -5,57 +5,165 @@ module Hawkular::Alerts::RSpec
   ALERTS_BASE = 'http://localhost:8080/hawkular/alerts'
   creds = { username: 'jdoe', password: 'password' }
 
-  describe 'Alert/Triggers', :vcr do
-    it 'Should List Triggers' do
-      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds)
+  describe 'Alert/Triggers', vcr: { decode_compressed_response: true } do
+    before(:each) do
+      @client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds)
+    end
 
-      triggers = client.list_triggers
+    it 'Should List Triggers' do
+      triggers = @client.list_triggers
 
       expect(triggers.size).to be(3)
     end
 
     it 'Should List Triggers for Tag' do
-      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds)
-
-      triggers = client.list_triggers [], ['resourceId|75bfdd05-d03d-481e-bf32-c724c7719d8b~Local']
+      triggers = @client.list_triggers [],
+                                       ['resourceId|75bfdd05-d03d-481e-bf32-c724c7719d8b~Local']
 
       expect(triggers.size).to be(7)
     end
 
     it 'Should List Triggers for Tags' do
-      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds)
-
-      triggers = client.list_triggers [], ['resourceId|75bfdd05-d03d-481e-bf32-c724c7719d8b~Local',
-                                           'app|MyShop']
+      triggers = @client.list_triggers [],
+                                       ['resourceId|75bfdd05-d03d-481e-bf32-c724c7719d8b~Local',
+                                        'app|MyShop']
 
       expect(triggers.size).to be(7)
     end
 
     it 'Should List Triggers for ID' do
-      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds)
-
-      triggers = client.list_triggers ['75bfdd05-d03d-481e-bf32-c724c7719d8b~Local_jvm_pheap']
+      triggers = @client.list_triggers ['75bfdd05-d03d-481e-bf32-c724c7719d8b~Local_jvm_pheap']
 
       expect(triggers.size).to be(1)
     end
 
     it 'Should get a single metric Trigger' do
-      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds)
-
-      trigger = client.get_single_trigger('snert~Local_jvm_nheap')
+      trigger = @client.get_single_trigger('snert~Local_jvm_nheap')
 
       expect(trigger).not_to be_nil
     end
 
     it 'Should get a single Trigger with conditions' do
-      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds)
-
-      trigger = client.get_single_trigger 'snert~Local_jvm_nheap', true
+      trigger = @client.get_single_trigger 'snert~Local_jvm_nheap', true
 
       expect(trigger).not_to be_nil
       expect(trigger.conditions.size).to be(1)
       expect(trigger.dampenings.size).to be(1)
     end
+
+    it 'Should bulk load triggers' do
+      json = IO.read('spec/integration/hello-world-definitions.json')
+      trigger_hash = JSON.parse(json)
+
+      @client.bulk_import_triggers trigger_hash
+
+      trigger = @client.get_single_trigger 'hello-world-trigger', true
+      expect(trigger).not_to be_nil
+      expect(trigger.conditions.size).to be(2)
+      expect(trigger.dampenings.size).to be(0)
+
+      @client.delete_trigger(trigger.id)
+    end
+
+    it 'Should create a basic trigger with action' do
+      @client.create_action :email, 'send-via-email', 'notify-to-admins' => 'joe@acme.org'
+
+      # Create the trigger
+      t = Hawkular::Alerts::Trigger.new({})
+      t.enabled = true
+      t.id = 'my-cool-trigger'
+      t.name = 'Just a trigger'
+      t.severity = :HIGH
+      t.description = 'Just a test trigger'
+
+      # Create a condition
+      c = Hawkular::Alerts::Trigger::Condition.new({})
+      c.trigger_mode = :FIRING
+      c.type = :THRESHOLD
+      c.data_id = 'my-metric-id'
+      c.operator = :LT
+      c.threshold = 5
+
+      # Reference an action definition
+      a = Hawkular::Alerts::Trigger::Action.new({})
+      a.action_plugin = :email
+      a.action_id = 'send-via-email'
+      t.actions.push a
+
+      begin
+        ft = @client.create_trigger t, [c], nil
+
+        expect(ft).not_to be_nil
+
+        trigger = @client.get_single_trigger t.id, true
+        expect(trigger).not_to be_nil
+        expect(trigger.conditions.size).to be(1)
+        expect(trigger.dampenings.size).to be(0)
+      ensure
+        # rubocop:disable Lint/HandleExceptions
+        begin
+          @client.delete_trigger(t.id)
+        rescue
+          # I am not interested
+        end
+        begin
+          @client.delete_action(a.action_id, a.action_plugin)
+        rescue
+          # I am not interested
+        end
+        # rubocop:enable Lint/HandleExceptions
+      end
+    end
+
+    it 'Should get the action definitions' do
+      ret = @client.get_action_definition
+      expect(ret.size).to be(2)
+      expect(ret.key? 'email').to be_truthy
+
+      ret = @client.get_action_definition 'email'
+      expect(ret.size).to be(1)
+      expect(ret['email'].size).to be(7)
+
+      expect { @client.get_action_definition '-does-not-exist-' }
+        .to raise_error(Hawkular::BaseClient::HawkularException)
+    end
+
+    it 'Should create an action' do
+      @client.create_action 'email', 'my-id1', 'notify-to-admins' => 'joe@acme.org'
+      @client.delete_action 'email', 'my-id1'
+    end
+
+    it 'Should not create an action for unknown plugin' do
+      expect do
+        @client.create_action '-does-not-exist',
+                              'my-id2',
+                              'notify-to-admins' => 'joe@acme.org'
+      end.to raise_error(Hawkular::BaseClient::HawkularException)
+    end
+
+    it 'Should not create an action for unknown properties' do
+      begin
+        @client.create_action :email, 'my-id3', foo: 'bar'
+      ensure
+        @client.delete_action :email, 'my-id3'
+      end
+    end
+
+    it 'Should create an action for webhooks' do
+      begin
+        @client.get_action_definition 'webhook'
+
+        webhook_props = { 'url' => 'http://localhost:8080/bla', 'method' => 'POST' }
+        @client.create_action 'webhook', 'my-id1',
+                              webhook_props
+        ret = @client.get_action 'webhook', 'my-id1'
+        expect(ret.action_plugin).to eq('webhook')
+        expect(ret.action_id).to eq('my-id1')
+
+      ensure
+        @client.delete_action 'webhook', 'my-id1'
+      end
+    end
   end
 
   describe 'Alert/Alerts', :vcr do
@@ -140,4 +248,148 @@ module Hawkular::Alerts::RSpec
   #     expect(data).not_to be_nil
   #   end
   # end
+
+  describe 'Alert/Events', :vcr do
+    VCR.configure do |c|
+      c.default_cassette_options = {
+        match_requests_on: [:method, VCR.request_matchers.uri_without_params(:startTime, :endTime)]
+      }
+    end
+
+    it 'Should list events' do
+      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds)
+
+      events = client.list_events('thin' => true)
+
+      expect(events).to_not be_nil
+      expect(events.size).to be(12)
+    end
+
+    it 'Should list events using criteria' do
+      now = Time.new.to_i
+      start_time = (now - 7_200) * 1000
+      end_time = now * 1000
+
+      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds)
+
+      events = client.list_events('startTime' => start_time, 'endTime' => end_time)
+
+      expect(events).to_not be_nil
+      expect(events.size).to be(1)
+    end
+
+    it 'Should not list events using criteria' do
+      client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds)
+
+      events = client.list_events('startTime' => 0, 'endTime' => 1000)
+
+      expect(events).to_not be_nil
+      expect(events.size).to be(0)
+    end
+  end
+
+  describe 'Alert/EndToEnd', vcr: { decode_compressed_response: true } do
+    before(:each) do
+      @client = Hawkular::Alerts::AlertsClient.new(ALERTS_BASE, creds)
+    end
+
+    it 'Should create and fire a trigger' do
+      email_props = { to: 'joe@acme.org',
+                      from: 'admin@acme.org' }
+      begin
+        @client.create_action 'email', 'send-via-email',
+                              email_props
+      rescue
+        @client.delete_action 'email', 'send-via-email'
+        @client.create_action 'email', 'send-via-email',
+                              email_props
+      end
+
+      webhook_props = { url: 'http://172.31.7.177/',
+                        method: 'POST' }
+      begin
+        @client.create_action 'webhook', 'send-via-webhook',
+                              webhook_props
+      rescue
+        @client.delete_action 'webhook', 'send-via-webhook'
+        @client.create_action 'webhook', 'send-via-webhook',
+                              webhook_props
+      end
+
+      # Create the trigger
+      t = Hawkular::Alerts::Trigger.new({})
+      t.enabled = true
+      t.id = 'my-cool-email-trigger'
+      t.name = 'Just a trigger'
+      t.severity = :HIGH
+      t.description = 'Just a test trigger'
+
+      # Create a condition
+      c = Hawkular::Alerts::Trigger::Condition.new({})
+      c.trigger_mode = :FIRING
+      c.type = :THRESHOLD
+      c.data_id = 'my-metric-id1'
+      c.operator = :GT
+      c.threshold = 5
+
+      # Reference an action definition for email
+      a = Hawkular::Alerts::Trigger::Action.new({})
+      a.action_plugin = 'email'
+      a.action_id = 'send-via-email'
+      t.actions.push a
+
+      # Reference an action definition for webhook
+      a = Hawkular::Alerts::Trigger::Action.new({})
+      a.action_plugin = 'webhook'
+      a.action_id = 'send-via-webhook'
+      t.actions.push a
+
+      begin
+        ft = @client.create_trigger t, [c], nil
+
+        expect(ft).not_to be_nil
+
+        trigger = @client.get_single_trigger t.id, true
+        expect(trigger).not_to be_nil
+        expect(trigger.conditions.size).to be(1)
+        expect(trigger.dampenings.size).to be(0)
+
+        # Trigger is set up - send a metric value to trigger it.
+        metric_client = Hawkular::Metrics::Client.new('http://localhost:8080/hawkular/metrics',
+                                                      creds)
+
+        data_point = { timestamp: Time.now.to_i * 1000, value: 42 }
+        data = [{ id: 'my-metric-id1', data: [data_point] }]
+
+        metric_client.push_data(gauges: data)
+
+        # wait 2s for the alert engine to work if we are live
+        sleep 2 if VCR.current_cassette.recording?
+
+        # see if alert has fired
+        alerts = @client.get_alerts_for_trigger 'my-cool-email-trigger'
+        expect(alerts).to_not be(nil)
+        alerts.each { |al| @client.resolve_alert(al.id, 'Heiko', 'Hello Ruby World :-)') }
+
+      ensure
+        # rubocop:disable Lint/HandleExceptions
+        begin
+          @client.delete_trigger(t.id)
+        rescue
+          # I am not interested
+        end
+        begin
+          @client.delete_action('webhook', 'send-via-webhook')
+        rescue
+          # I am not interested
+        end
+        begin
+          @client.delete_action('email', 'send-via-email')
+        rescue
+          # I am not interested
+        end
+        # rubocop:enable Lint/HandleExceptions
+      end
+    end
+  end
 end