hawkular-client 2.6.0 → 2.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e9395092bd67a428a2b1bf8fffa763a653e80e74
-  data.tar.gz: 85e58ded92c9b97c33eb37b77746a485f22ab65d
+  metadata.gz: 9dff0c0c4a4cf26161263ef21f06e0962f94fbf0
+  data.tar.gz: 665dd8784d3495ec6da84849b702ef105498ae59
 SHA512:
-  metadata.gz: b17497312ea6c135e2e12fab9759235a993319980ed3f9e5e6cd3e1a1dfb2c19f9a54edc0bacf7a22f8f27ca9030f222132a061002e2ff19d1b8bbd379fcd8c8
-  data.tar.gz: bb4338e14b659d5ac1ee564e85e9c7dcaed201cf7e218c8e48e96f8774d59d40a0dd9919ce9a255a83fbd664a1fae979cad9add0d7628096d1a08ca566e01f0c
+  metadata.gz: caa40d7fc69a01af67584e1a1f2c821043a54955c647746d176ffba1c0bf3600690fb7667b11632c5a915ac6e3b761efa8e3c47ecf35538a62c5178e60a1b43a
+  data.tar.gz: 2a236c3bc8117a808aa91948378f33f6fc86afb10ce889eade4b9f11ac26ed89fe1d7dc46f3115fe12f4787045faf78fdd69cf58d56cc54740b16908aa1c874f

data/CHANGES.rdoc

@@ -3,6 +3,11 @@
 This document describes the relevant changes between releases of the
 _hawkular-client_ project.
 
+=== V 2.7.0
+
+* Support for SSL connections
+* Fix fetching stats to support rates
+
 === V 2.6.0
 
 * Fix fetching operation params in the recommended way
@@ -11,8 +16,6 @@ _hawkular-client_ project.
 
 Full list of items can be found at https://github.com/hawkular/hawkular-client-ruby/milestone/11?closed=1
 
-
-
 === V 2.5.0
 
 * Fix failure of list operations when no properties are passed - don't parse params

data/lib/hawkular/hawkular_client.rb

@@ -58,7 +58,7 @@ module Hawkular
 
     # this is in a dedicated method, because constructor opens the websocket connection to make the handshake
     def init_operations_client
-      Operations::OperationsClient.new(entrypoint: @state[:entrypoint].to_s.sub(/^https?/, 'ws'),
+      Operations::OperationsClient.new(entrypoint: @state[:entrypoint],
                                        credentials: @state[:credentials],
                                        options: @state[:options])
     end

data/lib/hawkular/inventory/inventory_api.rb

@@ -488,7 +488,8 @@ module Hawkular::Inventory
       }
       ws_options[:headers][:'Hawkular-Tenant'] = tenant_id
 
-      url = "#{entrypoint.gsub(/https?/, 'ws')}/ws/events?tenantId=#{tenant_id}&type=#{type}&action=#{action}"
+      url = normalize_entrypoint_url(@entrypoint, "ws/events?tenantId=#{tenant_id}&type=#{type}&action=#{action}")
+      url = url_with_websocket_scheme(url)
       @ws = WebSocket::Client::Simple.connect url, ws_options do |client|
         client.on :message do |msg|
           parsed_message = JSON.parse(msg.data)

data/lib/hawkular/metrics/metric_api.rb

@@ -44,6 +44,7 @@ module Hawkular::Metrics
     # @param gauge_ids [Array[String]] list of gauge ids
     # @param counter_ids [Array[String]] list of counter ids
     # @param avail_ids [Array[String]] list of availability ids
+    # @param rates [Boolean] flag to include rates for gauges and counters metrics
     # @param starts [Integer] optional timestamp (default now - 8h)
     # @param ends [Integer] optional timestamp (default now)
     # @param bucket_duration [String] optional interval (default 3600s)
@@ -58,10 +59,12 @@ module Hawkular::Metrics
     #     ends: 500,
     #     bucket_duration: '150ms'
     #   )
-    def query_stats(gauge_ids: [], counter_ids: [], avail_ids: [], starts: nil, ends: nil, bucket_duration: '3600s')
+    def query_stats(gauge_ids: [], counter_ids: [], avail_ids: [], rates: false, starts: nil, ends: nil,
+                    bucket_duration: '3600s')
       path = '/metrics/stats/query'
       metrics = { gauge: gauge_ids, counter: counter_ids, availability: avail_ids }
       data = { metrics: metrics, start: starts, end: ends, bucketDuration: bucket_duration }
+      data['types'] = %w(gauge gauge_rate counter counter_rate availability) if rates
       http_post(path, data)
     end
 

data/lib/hawkular/operations/operations_api.rb

@@ -53,6 +53,8 @@ module Hawkular::Operations
     #
     # @option args [String] :entrypoint Base URL of the hawkular server e.g. http://localhost:8080.
     # @option args [String] :host base host:port pair of Hawkular - e.g localhost:8080
+    # @option args [Boolean] :use_secure_connection if no entrypoint is provided, determines if use a secure connection
+    #                        defaults to false
     # @option args [Hash{String=>String}]  :credentials Hash of (username password) or token
     # @option args [Hash{String=>String}] :options Additional rest client options
     # @option args [Fixnum]  :wait_time Time in seconds describing how long the constructor should block - handshake
@@ -60,11 +62,13 @@ 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
-        args[:host] ||= "#{uri.host}:#{uri.port}"
+        uri = URI.parse ep.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?
@@ -72,8 +76,7 @@ module Hawkular::Operations
       args[:options] ||= {}
       args[:wait_time] ||= 0.5
       super(args[:host], args[:credentials], args[:options])
-      # note: if we start using the secured WS, change the protocol to wss://
-      url = "ws://#{args[:host]}/hawkular/command-gateway/ui/ws"
+      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")

data/lib/hawkular/version.rb

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

data/spec/integration/inventory_spec.rb

@@ -3,582 +3,632 @@ require "#{File.dirname(__FILE__)}/../spec_helper"
 require 'securerandom'
 
 module Hawkular::Inventory::RSpec
-  ENTRYPOINT = 'http://localhost:8080/hawkular/inventory'
   DEFAULT_VERSION = '0.17.2.Final'
   VERSION = ENV['INVENTORY_VERSION'] || DEFAULT_VERSION
 
-  include Hawkular::Inventory
-  describe 'Inventory/Tenants', vcr: { decode_compressed_response: true, record: :new_episodes } do
-    it 'Should Get Tenant For Explicit Credentials' do
-      # get the client for given endpoint for given credentials
-      creds = { username: 'jdoe', password: 'password' }
-      mock_inventory_client(VERSION) unless ENV['VCR_UPDATE'] == '1'
-      options = { tenant: 'hawkular' }
-      client = Hawkular::Inventory::InventoryClient.create(entrypoint: ENTRYPOINT,
-                                                           credentials: creds,
-                                                           options: options)
-      tenant = client.get_tenant(creds)
-      expect(tenant).to eq('hawkular')
-    end
+  SKIP_SECURE_CONTEXT = ENV['SKIP_SECURE_CONTEXT'] || '1'
 
-    it 'Should Get Tenant For Implicit Credentials' do
-      creds = { username: 'jdoe', password: 'password' }
-      mock_inventory_client(VERSION) unless ENV['VCR_UPDATE'] == '1'
-      options = { tenant: 'hawkular' }
-      client = Hawkular::Inventory::InventoryClient.create(entrypoint: ENTRYPOINT,
-                                                           credentials: creds,
-                                                           options: options)
-      tenant = client.get_tenant(creds)
-      expect(tenant).to eq('hawkular')
-    end
-  end
+  URL_RESOURCE = 'http://bsd.de'
 
-  describe 'Inventory Connection' do
-    it 'Should err on bad credentials' do
-      VCR.use_cassette('Inventory/Connection/Should err on bad credentials') do
-        @creds = {
-          username: '-XX-X-jdoe-X',
-          password: 'password'
-        }
-        expect do
-          Hawkular::Inventory::InventoryClient.create(entrypoint: ENTRYPOINT, credentials: @creds)
-        end.to raise_error(Hawkular::BaseClient::HawkularException, 'Unauthorized')
-      end
-    end
-  end
+  NON_SECURE_CONTEXT = :NonSecure
+  SECURE_CONTEXT = :Secure
 
-  describe 'Inventory' do
-    URL_RESOURCE = 'http://bsd.de'
-
-    before(:all) do
-      @creds = {
-        username: 'jdoe',
-        password: 'password'
-      }
-
-      options = { decode_compressed_response: true }
-      options[:record] = :all if ENV['VCR_UPDATE'] == '1'
-      client_options = { tenant: 'hawkular' }
-
-      if ENV['VCR_UPDATE'] == '1'
-        VCR.turn_off!(ignore_cassettes: true)
-        WebMock.allow_net_connect!
-        @client = Hawkular::Inventory::InventoryClient.create(entrypoint: ENTRYPOINT,
-                                                              credentials: @creds,
-                                                              options: client_options)
-        WebMock.disable_net_connect!
-        VCR.turn_on!
-      else
-        ::RSpec::Mocks.with_temporary_scope do
-          mock_inventory_client(VERSION) unless ENV['VCR_UPDATE'] == '1'
-          @client = Hawkular::Inventory::InventoryClient.create(entrypoint: ENTRYPOINT,
-                                                                credentials: @creds,
-                                                                options: client_options)
-        end
-      end
+  [NON_SECURE_CONTEXT, SECURE_CONTEXT].each do |security_context|
+    next if security_context == SECURE_CONTEXT && SKIP_SECURE_CONTEXT == '1'
 
-      x, y, = @client.version
-      VCR.use_cassette("Inventory/inventory_#{x}_#{y}/Helpers/get_feeds", options) do
-        feeds = @client.list_feeds
-        @state = {
-          feed_uuid: feeds[0]
-        }
-      end
+    context "#{security_context}" do
+      include Hawkular::Inventory
 
-      # create 1 URL resource and its metrics
-      VCR.use_cassette("Inventory/inventory_#{x}_#{y}/Helpers/create_url", options) do
-        headers = {}
-        headers[:'Hawkular-Tenant'] = 'hawkular'
-        rest_client = RestClient::Resource.new('http://localhost:8080/hawkular/api/urls',
-                                               user: @creds[:username],
-                                               password: @creds[:password],
-                                               headers: headers
-                                              )
-        url_json = {
-          url: URL_RESOURCE
-        }.to_json
-
-        begin
-          rest_client.post(url_json, content_type: 'application/json')
-        rescue
-          puts 'failed to create the url'
-          # no big deal, the url is probably already there
-        end
+      alias_method :helper_entrypoint, :entrypoint
+
+      let(:entrypoint) do
+        helper_entrypoint(security_context, 'inventory')
       end
 
-      sleep 2 if ENV['VCR_UPDATE'] == '1' || ENV['VCR_OFF'] == '1'
-    end
+      describe 'Inventory Tenants' do
+        let(:cassette_name) do |example|
+          description = example.description
+          description
+        end
 
-    after(:all) do
-      require 'fileutils'
-      x, y, = @client.version
-      FileUtils.rm_rf "#{VCR.configuration.cassette_library_dir}/Inventory/inventory#{x}_#{y}/tmp"
-    end
+        around(:each) do |example|
+          record("Inventory/#{security_context}/Tenants", credentials, cassette_name, example: example)
+        end
 
-    let(:cassette_name) do |example|
-      description = example.description
-      description
-    end
+        it 'Should Get Tenant For Explicit Credentials' do
+          # get the client for given endpoint for given credentials
+          creds = credentials
+          mock_inventory_client(VERSION) unless ENV['VCR_UPDATE'] == '1'
+          options = { tenant: 'hawkular' }
+          client = setup_inventory_client entrypoint, options
+          tenant = client.get_tenant(creds)
+          expect(tenant).to eq('hawkular')
+        end
 
-    let(:feed_id) do
-      @state[:feed_uuid]
-    end
+        it 'Should Get Tenant For Implicit Credentials' do
+          creds = credentials
+          mock_inventory_client(VERSION) unless ENV['VCR_UPDATE'] == '1'
+          options = { tenant: 'hawkular' }
+          client = setup_inventory_client entrypoint, options
+          tenant = client.get_tenant(creds)
+          expect(tenant).to eq('hawkular')
+        end
+      end
 
-    let(:wildfly_type) do
-      CanonicalPath.new(feed_id: feed_id, resource_type_id: hawk_escape_id('WildFly Server'))
-    end
+      describe 'Inventory Connection' do
+        let(:cassette_name) do |example|
+          description = example.description
+          description
+        end
 
-    around(:each) do |example|
-      major, minor, = @client.version
-      record("Inventory/inventory_#{major}_#{minor}", @state, cassette_name, example: example)
-    end
+        around(:each) do |example|
+          record("Inventory/#{security_context}/Connection", credentials, cassette_name, example: example)
+        end
 
-    it 'Should list feeds' do
-      feeds = @client.list_feeds
+        it 'Should err on bad credentials' do
+          @creds = credentials
+          @creds[:username] << @creds[:password]
+          VCR.eject_cassette
+          record("Inventory/#{security_context}/Connection", @creds, cassette_name) do
+            expect do
+              Hawkular::Inventory::InventoryClient.create(entrypoint: entrypoint, credentials: @creds)
+            end.to raise_error(Hawkular::BaseClient::HawkularException, 'Unauthorized')
+          end
+        end
+      end
 
-      expect(feeds.size).to be > 0
-    end
+      describe 'Inventory' do
+        created_feeds = Set.new
+
+        before(:all) do
+          @creds = credentials
+
+          @state = {
+            super_secret_username: @creds[:username],
+            super_secret_password: @creds[:password]
+          }
+
+          client_options = { tenant: 'hawkular' }
+
+          if ENV['VCR_UPDATE'] == '1'
+            VCR.turn_off!(ignore_cassettes: true)
+            WebMock.allow_net_connect!
+            @client = setup_inventory_client helper_entrypoint(security_context, 'inventory'), client_options
+            WebMock.disable_net_connect!
+            VCR.turn_on!
+          else
+            ::RSpec::Mocks.with_temporary_scope do
+              mock_inventory_client(VERSION) unless ENV['VCR_UPDATE'] == '1'
+              @client = setup_inventory_client helper_entrypoint(security_context, 'inventory'), client_options
+            end
+          end
+
+          x, y, = @client.version
+          record("Inventory/#{security_context}/inventory_#{x}_#{y}", @state.clone, 'Helpers/get_feeds') do
+            feeds = @client.list_feeds
+            @state[:feed_uuid] = feeds[0]
+          end
+
+          # create 1 URL resource and its metrics
+          record("Inventory/#{security_context}/inventory_#{x}_#{y}", @state.clone, 'Helpers/create_url') do
+            headers = {}
+            headers[:'Hawkular-Tenant'] = client_options[:tenant]
+            rest_client = RestClient::Resource.new(helper_entrypoint(security_context, 'urls'),
+                                                   user: credentials[:username],
+                                                   password: credentials[:password],
+                                                   headers: headers)
+            url_json = {
+              url: URL_RESOURCE
+            }.to_json
+
+            begin
+              rest_client.post(url_json, content_type: 'application/json')
+            rescue
+              puts 'failed to create the url, it might be already there'
+              # no big deal, the url is probably already there
+            end
+          end
+
+          sleep 2 if ENV['VCR_UPDATE'] == '1' || ENV['VCR_OFF'] == '1'
+        end
 
-    it 'Should list resources for feed' do
-      resources = @client.list_resources_for_feed feed_id
+        before(:each) do
+          inventory_create_feed_method = @client.method(:create_feed)
+          allow(@client).to receive(:create_feed) do |feed|
+            created_feeds << feed
+            inventory_create_feed_method.call(feed)
+          end
+        end
 
-      expect(resources.size).to be(2)
-    end
+        after(:all) do
+          require 'fileutils'
+          x, y, = @client.version
+          FileUtils.rm_rf "#{VCR.configuration.cassette_library_dir}"\
+          "/Inventory/#{security_context}/inventory#{x}_#{y}/tmp"
+
+          if ENV['VCR_UPDATE'] == '1' || ENV['VCR_OFF'] == '1'
+            VCR.turn_off!(ignore_cassettes: true)
+            WebMock.allow_net_connect!
+            created_feeds.each do |feed|
+              begin
+                @client.delete_feed feed
+                # rubocop:disable HandleExceptions
+              rescue
+                # rubocop:enable HandleExceptions
+              end
+            end
+            WebMock.disable_net_connect!
+            VCR.turn_on!
+          end
+        end
 
-    it 'Should list feeds when using SSL without certificate' do
-      # change this to the real credentials when updating the VCR
-      @state[:super_secret_username] = 'username'
-      @state[:super_secret_password] = 'password'
-      creds = { username: @state[:super_secret_username],
-                password: @state[:super_secret_password] }
-      tori_url = 'https://hawkular.torii.gva.redhat.com/hawkular/inventory'
-      mock_inventory_client(VERSION)
-      client = Hawkular::Inventory::InventoryClient.create(entrypoint: tori_url,
-                                                           credentials: creds,
-                                                           options: { tenant: 'hawkular',
-                                                                      verify_ssl: OpenSSL::SSL::VERIFY_NONE
-                                                           })
-      feeds = client.list_feeds
-
-      expect(feeds.size).to be(1)
-    end
+        let(:cassette_name) do |example|
+          description = example.description
+          description
+        end
 
-    it 'Should list all the resource types' do
-      types = @client.list_resource_types
-      # new API returns only the feedless types here, while the old one returned all the types
-      expect(types.size).to be > 0
-    end
+        let(:feed_id) do
+          @state[:feed_uuid]
+        end
 
-    it 'Should list types with feed' do
-      types = @client.list_resource_types(feed_id)
+        let(:wildfly_type) do
+          Hawkular::Inventory::CanonicalPath.new(feed_id: feed_id, resource_type_id: hawk_escape_id('WildFly Server'))
+        end
 
-      expect(types.size).to be >= 18
-    end
+        around(:each) do |example|
+          major, minor, = @client.version
+          record("Inventory/#{security_context}/inventory_#{major}_#{minor}", @state, cassette_name, example: example)
+        end
 
-    it 'Should list types with bad feed' do
-      type = 'does not exist'
-      types = @client.list_resource_types(type)
-      expect(type).to eq('does not exist')
+        it 'Should list feeds' do
+          feeds = @client.list_feeds
 
-      expect(types.size).to be(0)
-    end
+          expect(feeds.size).to be > 0
+        end
 
-    it 'Should list WildFlys' do
-      resources = @client.list_resources_for_type(wildfly_type.to_s)
+        it 'Should list resources for feed' do
+          resources = @client.list_resources_for_feed feed_id
 
-      expect(resources.size).to be(1)
-    end
+          expect(resources.size).to be(2)
+        end
 
-    it 'Should list WildFlys with props' do
-      resources = @client.list_resources_for_type(wildfly_type.to_s, fetch_properties: true)
+        it 'Should list all the resource types' do
+          types = @client.list_resource_types
+          # new API returns only the feedless types here, while the old one returned all the types
+          expect(types.size).to be > 0
+        end
 
-      expect(resources.size).to be(1)
-      wf = resources.first
-      expect(wf.properties['Hostname']).not_to be_empty
-    end
+        it 'Should list types with feed' do
+          types = @client.list_resource_types(feed_id)
 
-    it 'Should List datasources with no props' do
-      type_path = CanonicalPath.new(feed_id: feed_id, resource_type_id: hawk_escape_id('Datasource'))
-      resources = @client.list_resources_for_type(type_path.to_s, fetch_properties: true)
+          expect(types.size).to be >= 18
+        end
 
-      expect(resources.size).to be > 0
-    end
+        it 'Should list types with bad feed' do
+          type = 'does not exist'
+          types = @client.list_resource_types(type)
+          expect(type).to eq('does not exist')
 
-    it 'Should list URLs' do
-      type_path = CanonicalPath.new(resource_type_id: hawk_escape_id('URL'))
-      resources = @client.list_resources_for_type(type_path.to_s)
+          expect(types.size).to be(0)
+        end
 
-      expect(resources.size).to be(1)
-      resource = resources[0]
-      expect(resource.instance_of? Hawkular::Inventory::Resource).to be_truthy
-      # depends how pinger is fast
-      expect(2..6).to cover(resource.properties.size)
-      expect(resource.properties['url']).to eq(URL_RESOURCE)
-    end
+        it 'Should list WildFlys' do
+          resources = @client.list_resources_for_type(wildfly_type.to_s)
 
-    it 'Should list metrics for WildFlys' do
-      resources = @client.list_resources_for_type(wildfly_type.to_s)
-      wild_fly = resources[0]
+          expect(resources.size).to be(1)
+        end
 
-      metrics = @client.list_metrics_for_resource(wild_fly.path)
+        it 'Should list WildFlys with props' do
+          resources = @client.list_resources_for_type(wildfly_type.to_s, fetch_properties: true)
 
-      expect(metrics.size).to be(14)
-    end
+          expect(resources.size).to be(1)
+          wf = resources.first
+          expect(wf.properties['Hostname']).not_to be_empty
+        end
 
-    it 'Should list children of WildFly' do
-      resources = @client.list_resources_for_type(wildfly_type.to_s)
-      wild_fly = resources[0]
+        it 'Should List datasources with no props' do
+          type_path = Hawkular::Inventory::CanonicalPath.new(
+            feed_id: feed_id,
+            resource_type_id: hawk_escape_id('Datasource'))
+          resources = @client.list_resources_for_type(type_path.to_s, fetch_properties: true)
 
-      children = @client.list_child_resources(wild_fly.path)
+          expect(resources.size).to be > 0
+        end
 
-      expect(children.size).to be > 10
-    end
+        it 'Should list URLs' do
+          type_path = Hawkular::Inventory::CanonicalPath.new(resource_type_id: hawk_escape_id('URL'))
+          resources = @client.list_resources_for_type(type_path.to_s)
+          expect(resources.size).to be > 0
+          resource = resources[0]
+          expect(resource.instance_of? Hawkular::Inventory::Resource).to be_truthy
+          # depends how pinger is fast
+          expect(2..6).to cover(resource.properties.size)
+          expect(resource.properties['url']).to eq(URL_RESOURCE)
+        end
 
-    it 'Should list children of nested resource' do
-      wildfly_res_id = hawk_escape_id 'Local~~'
-      datasource_res_id = hawk_escape_id 'Local~/subsystem=datasources/data-source=ExampleDS'
-      resource_path = CanonicalPath.new(feed_id: feed_id, resource_ids: [wildfly_res_id, datasource_res_id])
-      datasource = @client.get_resource(resource_path.to_s)
+        it 'Should list metrics for WildFlys' do
+          resources = @client.list_resources_for_type(wildfly_type.to_s)
+          wild_fly = resources[0]
 
-      expect(datasource.name).to eq('Datasource [ExampleDS]')
-      children = @client.list_child_resources(datasource.path)
+          metrics = @client.list_metrics_for_resource(wild_fly.path)
 
-      expect(children.size).to be(0)
-    end
+          expect(metrics.size).to be(14)
+        end
 
-    it 'Should list recursive children of WildFly' do
-      resources = @client.list_resources_for_type(wildfly_type.to_s)
-      wild_fly = resources[0]
+        it 'Should list children of WildFly' do
+          resources = @client.list_resources_for_type(wildfly_type.to_s)
+          wild_fly = resources[0]
 
-      children = @client.list_child_resources(wild_fly.path, recursive: true)
+          children = @client.list_child_resources(wild_fly.path)
 
-      expect(children.size).to be > 40
-    end
+          expect(children.size).to be > 10
+        end
 
-    it 'Should list relationships of WildFly' do
-      resources = @client.list_resources_for_type(wildfly_type.to_s)
-      wild_fly = resources[0]
+        it 'Should list children of nested resource' do
+          wildfly_res_id = hawk_escape_id 'Local~~'
+          datasource_res_id = hawk_escape_id 'Local~/subsystem=datasources/data-source=ExampleDS'
+          resource_path = Hawkular::Inventory::CanonicalPath.new(
+            feed_id: feed_id,
+            resource_ids: [wildfly_res_id, datasource_res_id])
+          datasource = @client.get_resource(resource_path.to_s)
 
-      rels = @client.list_relationships(wild_fly.path)
+          expect(datasource.name).to eq('Datasource [ExampleDS]')
+          children = @client.list_child_resources(datasource.path)
 
-      expect(rels.size).to be > 40
-      expect(rels[0].to_h['source']).not_to be_empty
-    end
-
-    it 'Should list heap metrics for WildFlys' do
-      resources = @client.list_resources_for_type(wildfly_type.to_s)
-      wild_fly = resources[0]
+          expect(children.size).to be(0)
+        end
 
-      metrics = @client.list_metrics_for_resource(wild_fly.path, type: 'GAUGE', match: 'Metrics~Heap')
-      expect(metrics.size).to be(3)
+        it 'Should list recursive children of WildFly' do
+          resources = @client.list_resources_for_type(wildfly_type.to_s)
+          wild_fly = resources[0]
 
-      metrics = @client.list_metrics_for_resource(wild_fly.path, match: 'Metrics~Heap')
-      expect(metrics.size).to be(3)
+          children = @client.list_child_resources(wild_fly.path, recursive: true)
 
-      metrics = @client.list_metrics_for_resource(wild_fly.path, type: 'GAUGE')
-      expect(metrics.size).to be(8)
-    end
+          expect(children.size).to be > 40
+        end
 
-    it 'Should list metrics of given metric type' do
-      type_path = CanonicalPath.new(feed_id: feed_id, metric_type_id: hawk_escape_id('Total Space'))
-      metrics = @client.list_metrics_for_metric_type(type_path)
+        it 'Should list relationships of WildFly' do
+          resources = @client.list_resources_for_type(wildfly_type.to_s)
+          wild_fly = resources[0]
 
-      expect(metrics.size).to be >= 4
-    end
+          rels = @client.list_relationships(wild_fly.path)
 
-    it 'Should list metrics of given resource type' do
-      metrics = @client.list_metrics_for_resource_type(wildfly_type.to_s)
+          expect(rels.size).to be > 40
+          expect(rels[0].to_h['source']).not_to be_empty
+        end
 
-      expect(metrics.size).to be(14)
-    end
+        it 'Should list heap metrics for WildFlys' do
+          resources = @client.list_resources_for_type(wildfly_type.to_s)
+          wild_fly = resources[0]
 
-    it 'Should have the same requested metric type id' do
-      metric_type_id = 'Server Availability~Server Availability'
-      type_path = CanonicalPath.new(feed_id: feed_id, metric_type_id: hawk_escape_id(metric_type_id))
-      metrics = @client.list_metrics_for_metric_type(type_path)
+          metrics = @client.list_metrics_for_resource(wild_fly.path, type: 'GAUGE', match: 'Metrics~Heap')
+          expect(metrics.size).to be(3)
 
-      expect(metrics.size).to be > 0
-      expect(metrics).to all(have_attributes(type_id: metric_type_id))
-    end
+          metrics = @client.list_metrics_for_resource(wild_fly.path, match: 'Metrics~Heap')
+          expect(metrics.size).to be(3)
 
-    it 'Should return config data of given resource' do
-      resource_path = CanonicalPath.new(feed_id: feed_id, resource_ids: [hawk_escape_id('Local~~')])
-      config = @client.get_config_data_for_resource(resource_path)
+          metrics = @client.list_metrics_for_resource(wild_fly.path, type: 'GAUGE')
+          expect(metrics.size).to be(8)
+        end
 
-      expect(config['value']['Server State']).to eq('running')
-      # expect(config['value']['Product Name']).to eq('Hawkular')
-    end
+        it 'Should list metrics of given metric type' do
+          type_path = Hawkular::Inventory::CanonicalPath.new(
+            feed_id: feed_id,
+            metric_type_id: hawk_escape_id('Total Space'))
+          metrics = @client.list_metrics_for_metric_type(type_path)
 
-    it 'Should return config data of given nested resource' do
-      wildfly_res_id = hawk_escape_id 'Local~~'
-      datasource_res_id = hawk_escape_id 'Local~/subsystem=datasources/data-source=ExampleDS'
-      resource_path = CanonicalPath.new(feed_id: feed_id, resource_ids: [wildfly_res_id, datasource_res_id])
+          expect(metrics.size).to be >= 2
+        end
 
-      config = @client.get_config_data_for_resource(resource_path)
+        it 'Should list metrics of given resource type' do
+          metrics = @client.list_metrics_for_resource_type(wildfly_type.to_s)
 
-      expect(config['value']['Username']).to eq('sa')
-      expect(config['value']['Driver Name']).to eq('h2')
-    end
+          expect(metrics.size).to be(14)
+        end
 
-    it 'Should get resource with its configurations' do
-      wildfly_res_id = hawk_escape_id 'Local~~'
-      datasource_res_id = hawk_escape_id 'Local~/subsystem=datasources/data-source=ExampleDS'
-      resource_path = CanonicalPath.new(feed_id: feed_id, resource_ids: [wildfly_res_id, datasource_res_id])
+        it 'Should have the same requested metric type id' do
+          metric_type_id = 'Server Availability~Server Availability'
+          type_path = Hawkular::Inventory::CanonicalPath.new(
+            feed_id: feed_id,
+            metric_type_id: hawk_escape_id(metric_type_id))
+          metrics = @client.list_metrics_for_metric_type(type_path)
 
-      resource = @client.get_resource resource_path, true
+          expect(metrics.size).to be > 0
+          expect(metrics).to all(have_attributes(type_id: metric_type_id))
+        end
 
-      expect(resource.properties['Username']).to eq('sa')
-      expect(resource.properties['Driver Name']).to eq('h2')
-    end
+        it 'Should return config data of given resource' do
+          resource_path = Hawkular::Inventory::CanonicalPath.new(
+            feed_id: feed_id,
+            resource_ids: [hawk_escape_id('Local~~')])
+          config = @client.get_config_data_for_resource(resource_path)
 
-    it 'Should list operation definitions of given resource type' do
-      operation_definitions = @client.list_operation_definitions(wildfly_type.to_s)
-
-      expect(operation_definitions).not_to be_empty
-      expect(operation_definitions).to include('JDR')
-      expect(operation_definitions).to include('Reload')
-      expect(operation_definitions).to include('Shutdown')
-      expect(operation_definitions).to include('Deploy')
-      shutdown_def = operation_definitions.fetch 'Shutdown'
-      expect(shutdown_def.params).to include('timeout')
-      expect(shutdown_def.params).to include('restart')
-      restart_param = shutdown_def.params.fetch 'restart'
-      expect(restart_param['type']).to eq('bool')
-      resume_def = operation_definitions.fetch 'Resume'
-      expect(resume_def.params).to be {}
-    end
+          expect(config['value']['Server State']).to eq('running')
+          # expect(config['value']['Product Name']).to eq('Hawkular')
+        end
 
-    it 'Should list operation definitions of given resource' do
-      resources = @client.list_resources_for_type(wildfly_type.to_s)
-      wild_fly = resources[0]
-      operation_definitions = @client.list_operation_definitions_for_resource(wild_fly.path.to_s)
+        it 'Should return config data of given nested resource' do
+          wildfly_res_id = hawk_escape_id 'Local~~'
+          datasource_res_id = hawk_escape_id 'Local~/subsystem=datasources/data-source=ExampleDS'
+          resource_path = Hawkular::Inventory::CanonicalPath.new(
+            feed_id: feed_id,
+            resource_ids: [wildfly_res_id, datasource_res_id])
 
-      expect(operation_definitions).not_to be_empty
-      expect(operation_definitions).to include('JDR')
-    end
+          config = @client.get_config_data_for_resource(resource_path)
 
-    it 'Should create a feed' do
-      new_feed_id = 'feed_1123sdncisud6237ui23hjbdscuzsad'
-      ret = @client.create_feed new_feed_id
-      expect(ret).to_not be_nil
-      expect(ret['id']).to eq(new_feed_id)
-    end
+          expect(config['value']['Username']).to eq('sa')
+          expect(config['value']['Driver Name']).to eq('h2')
+        end
 
-    it 'Should create and delete feed' do
-      new_feed_id = 'feed_1123sdn'
-      ret = @client.create_feed new_feed_id
-      expect(ret).to_not be_nil
-      expect(ret['id']).to eq(new_feed_id)
+        it 'Should get resource with its configurations' do
+          wildfly_res_id = hawk_escape_id 'Local~~'
+          datasource_res_id = hawk_escape_id 'Local~/subsystem=datasources/data-source=ExampleDS'
+          resource_path = Hawkular::Inventory::CanonicalPath.new(
+            feed_id: feed_id,
+            resource_ids: [wildfly_res_id, datasource_res_id])
 
-      @client.delete_feed new_feed_id
+          resource = @client.get_resource resource_path, true
 
-      feed_list = @client.list_feeds
-      expect(feed_list).not_to include(new_feed_id)
-    end
+          expect(resource.properties['Username']).to eq('sa')
+          expect(resource.properties['Driver Name']).to eq('h2')
+        end
 
-    it 'Should create a feed again' do
-      new_feed_id = 'feed_1123sdncisud6237ui2378789vvgX'
-      @client.create_feed new_feed_id
-      @client.create_feed new_feed_id
-    end
+        it 'Should list operation definitions of given resource type' do
+          operation_definitions = @client.list_operation_definitions(wildfly_type.to_s)
+
+          expect(operation_definitions).not_to be_empty
+          expect(operation_definitions).to include('JDR')
+          expect(operation_definitions).to include('Reload')
+          expect(operation_definitions).to include('Shutdown')
+          expect(operation_definitions).to include('Deploy')
+          shutdown_def = operation_definitions.fetch 'Shutdown'
+          expect(shutdown_def.params).to include('timeout')
+          expect(shutdown_def.params).to include('restart')
+          restart_param = shutdown_def.params.fetch 'restart'
+          expect(restart_param['type']).to eq('bool')
+          resume_def = operation_definitions.fetch 'Resume'
+          expect(resume_def.params).to be {}
+        end
 
-    it 'Should create a resourcetype' do
-      new_feed_id = 'feed_may_exist'
-      @client.create_feed new_feed_id
+        it 'Should list operation definitions of given resource' do
+          resources = @client.list_resources_for_type(wildfly_type.to_s)
+          wild_fly = resources[0]
+          operation_definitions = @client.list_operation_definitions_for_resource(wild_fly.path.to_s)
 
-      ret = @client.create_resource_type new_feed_id, 'rt-123', 'ResourceType'
-      expect(ret.id).to eq('rt-123')
-      expect(ret.name).to eq('ResourceType')
-      expect(ret.path).to include('/rt;rt-123')
-      expect(ret.path).to include('/f;feed_may_exist')
-    end
+          expect(operation_definitions).not_to be_empty
+          expect(operation_definitions).to include('JDR')
+        end
 
-    it 'Should create a resource' do
-      new_feed_id = 'feed_may_exist'
-      @client.create_feed new_feed_id
-      ret = @client.create_resource_type new_feed_id, 'rt-123', 'ResourceType'
-      type_path = ret.path
+        it 'Should create a feed' do
+          new_feed_id = 'feed_1123sdncisud6237ui23hjbdscuzsad'
+          ret = @client.create_feed new_feed_id
+          expect(ret).to_not be_nil
+          expect(ret['id']).to eq(new_feed_id)
+        end
 
-      @client.create_resource type_path, 'r123', 'My Resource', 'version' => 1.0
+        it 'Should create and delete feed' do
+          new_feed_id = 'feed_1123sdn'
+          ret = @client.create_feed new_feed_id
+          expect(ret).to_not be_nil
+          expect(ret['id']).to eq(new_feed_id)
 
-      resource_path = CanonicalPath.new(feed_id: new_feed_id, resource_ids: ['r123'])
+          @client.delete_feed new_feed_id
 
-      r = @client.get_resource(resource_path, false)
-      expect(r.id).to eq('r123')
-      expect(r.properties).not_to be_empty
-    end
+          feed_list = @client.list_feeds
+          expect(feed_list).not_to include(new_feed_id)
+        end
 
-    it 'Should create a resource with metric' do
-      new_feed_id = 'feed_may_exist'
-      @client.create_feed new_feed_id
-      ret = @client.create_resource_type new_feed_id, 'rt-123', 'ResourceType'
-      type_path = ret.path
+        it 'Should create a feed again' do
+          new_feed_id = 'feed_1123sdncisud6237ui2378789vvgX'
+          @client.create_feed new_feed_id
+          @client.create_feed new_feed_id
+        end
 
-      @client.create_resource type_path, 'r124', 'My Resource', 'version' => 1.0
-      resource_path = CanonicalPath.new(feed_id: new_feed_id, resource_ids: ['r124'])
+        it 'Should create a resourcetype' do
+          new_feed_id = 'feed_may_exist'
+          @client.create_feed new_feed_id
 
-      r = @client.get_resource(resource_path, false)
-      expect(r.id).to eq('r124')
-      expect(r.properties).not_to be_empty
+          ret = @client.create_resource_type new_feed_id, 'rt-123', 'ResourceType'
+          expect(ret.id).to eq('rt-123')
+          expect(ret.name).to eq('ResourceType')
+          expect(ret.path).to include('/rt;rt-123')
+          expect(ret.path).to include('/f;feed_may_exist')
+        end
 
-      mt = @client.create_metric_type new_feed_id, 'mt-124'
-      expect(mt).not_to be_nil
-      expect(mt.id).to eq('mt-124')
+        it 'Should create a resource' do
+          new_feed_id = 'feed_may_exist'
+          @client.create_feed new_feed_id
+          ret = @client.create_resource_type new_feed_id, 'rt-123', 'ResourceType'
+          type_path = ret.path
 
-      m = @client.create_metric_for_resource mt.path, r.path, 'm-124'
-      expect(m).not_to be_nil
-      expect(m.id).to eq('m-124')
-      expect(m.name).to eq('m-124')
+          @client.create_resource type_path, 'r123', 'My Resource', 'version' => 1.0
 
-      m = @client.create_metric_for_resource mt.path, r.path, 'm-124-1', 'Metric1'
-      expect(m).not_to be_nil
-      expect(m.id).to eq('m-124-1')
-      expect(m.name).to eq('Metric1')
-    end
+          resource_path = Hawkular::Inventory::CanonicalPath.new(feed_id: new_feed_id, resource_ids: ['r123'])
 
-    it 'Should create a nested resource and metric on it' do
-      new_feed_id = 'feed_may_exist'
-      @client.create_feed new_feed_id
-      ret = @client.create_resource_type new_feed_id, 'rt-123-1', 'ResourceType'
-      type_path = ret.path
+          r = @client.get_resource(resource_path, false)
+          expect(r.id).to eq('r123')
+          expect(r.properties).not_to be_empty
+        end
 
-      parent = @client.create_resource type_path, 'r124-a', 'Res-a'
-      nested_resource = @client.create_resource_under_resource type_path, parent.path, 'r124-b', 'Res-a'
-      expect(nested_resource.path).to include('r;r124-a/r;r124-b')
+        it 'Should create a resource with metric' do
+          new_feed_id = 'feed_may_exist'
+          @client.create_feed new_feed_id
+          ret = @client.create_resource_type new_feed_id, 'rt-123', 'ResourceType'
+          type_path = ret.path
 
-      mt = @client.create_metric_type new_feed_id, 'mt-124-a'
-      expect(mt).not_to be_nil
-      expect(mt.id).to eq('mt-124-a')
+          @client.create_resource type_path, 'r124', 'My Resource', 'version' => 1.0
+          resource_path = Hawkular::Inventory::CanonicalPath.new(feed_id: new_feed_id, resource_ids: ['r124'])
 
-      m_name = 'MetricUnderNestedResource'
-      m = @client.create_metric_for_resource mt.path, nested_resource.path, 'm-124-a', m_name
-      expect(m.id).to eq('m-124-a')
-      expect(m.name).to eq(m_name)
+          r = @client.get_resource(resource_path, false)
+          expect(r.id).to eq('r124')
+          expect(r.properties).not_to be_empty
 
-      metrics = @client.list_metrics_for_resource nested_resource.path
-      expect(metrics.size).to eq(1)
-      expect(metrics[0].id).to eq(m.id)
-    end
+          mt = @client.create_metric_type new_feed_id, 'mt-124'
+          expect(mt).not_to be_nil
+          expect(mt.id).to eq('mt-124')
 
-    it 'Should create and get a resource' do
-      new_feed_id = 'feed_may_exist'
-      @client.create_feed new_feed_id
-      ret = @client.create_resource_type new_feed_id, 'rt-123', 'ResourceType'
-      type_path = ret.path
+          m = @client.create_metric_for_resource mt.path, r.path, 'm-124'
+          expect(m).not_to be_nil
+          expect(m.id).to eq('m-124')
+          expect(m.name).to eq('m-124')
 
-      r1 = @client.create_resource type_path, 'r125', 'My Resource', 'version' => 1.0
+          m = @client.create_metric_for_resource mt.path, r.path, 'm-124-1', 'Metric1'
+          expect(m).not_to be_nil
+          expect(m.id).to eq('m-124-1')
+          expect(m.name).to eq('Metric1')
+        end
 
-      r2 = @client.get_resource(r1.path, true)
-      expect(r2.id).to eq('r125')
-      expect(r1.id).to eq(r2.id)
-      expect(r2.properties).not_to be_empty
-    end
+        it 'Should create a nested resource and metric on it' 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-1', 'ResourceType'
+          type_path = ret.path
 
-    it 'Should not find an unknown resource' do
-      new_feed_id = 'feed_may_exist'
-      path = CanonicalPath.new(feed_id: new_feed_id, resource_ids: [hawk_escape_id('*bla does not exist*')])
-      expect { @client.get_resource(path) }
-        .to raise_error(Hawkular::BaseClient::HawkularException, /No Resource found/)
-    end
+          parent = @client.create_resource type_path, 'r124-a', 'Res-a'
+          nested_resource = @client.create_resource_under_resource type_path, parent.path, 'r124-b', 'Res-a'
+          expect(nested_resource.path).to include('r;r124-a/r;r124-b')
 
-    it 'Should reject unknown metric type' do
-      new_feed_id = 'feed_may_exist'
+          mt = @client.create_metric_type new_feed_id, 'mt-124-a'
+          expect(mt).not_to be_nil
+          expect(mt.id).to eq('mt-124-a')
 
-      expect { @client.create_metric_type new_feed_id, 'abc', 'FOOBaR' }.to raise_error(RuntimeError,
-                                                                                        /Unknown type FOOBAR/)
-    end
+          m_name = 'MetricUnderNestedResource'
+          m = @client.create_metric_for_resource mt.path, nested_resource.path, 'm-124-a', m_name
+          expect(m.id).to eq('m-124-a')
+          expect(m.name).to eq(m_name)
 
-    let(:example) do |e|
-      e
-    end
+          metrics = @client.list_metrics_for_resource nested_resource.path
+          expect(metrics.size).to eq(1)
+          expect(metrics[0].id).to eq(m.id)
+        end
 
-    it 'Client should listen on various inventory events', :websocket do
-      WebSocketVCR.configure do |c|
-        c.hook_uris = ['localhost:8080']
-      end
-      uuid_prefix = SecureRandom.uuid
-      vcr_options = {
-        decode_compressed_response: true,
-        erb: {
-          uuid_prefix: uuid_prefix
-        },
-        reverse_substitution: true
-      }
-      vcr_options[:record] = :all if ENV['VCR_UPDATE'] == '1'
-      x, y, = @client.version
-      cassette_name = "Inventory/inventory_#{x}_#{y}/Templates/Client_should_listen_on_various_inventory_events"
-      WebSocketVCR.use_cassette(cassette_name, vcr_options) do
-        id_1 = uuid_prefix + '-r126'
-        id_2 = uuid_prefix + '-r127'
-        id_3 = uuid_prefix + '-r128'
-
-        new_resource_events = {}
-        resources_closable = @client.events do |resource|
-          new_resource_events[resource.id] = resource
-        end
-
-        deleted_feed_events = {}
-        feed_deleted_closable = @client.events('feed', 'deleted') do |feed|
-          deleted_feed_events[feed.id] = feed
-        end
-
-        new_resource_types_events = {}
-        # another breaking change in the new inventory api
-        interest = 'resourceType'
-        resource_type_closable = @client.events(interest) do |resource_type|
-          new_resource_types_events[resource_type.id] = resource_type
-        end
-
-        registered_feed_events = {}
-        feeds_closable = @client.events('feed', 'created') do |feed|
-          registered_feed_events[feed.id] = feed
-        end
-
-        new_feed_id = uuid_prefix + '-feed'
-        resource_type_id = uuid_prefix + '-rt-123'
-        resource_type_name = 'ResourceType'
-
-        record("Inventory/inventory_#{x}_#{y}",
-               { uuid_prefix: uuid_prefix },
-               'Helpers/generate_some_events_for_websocket') do
+        it 'Should create and get a resource' do
+          new_feed_id = "#{security_context}_feed_may_exist"
           @client.create_feed new_feed_id
-          ret = @client.create_resource_type new_feed_id, resource_type_id, resource_type_name
+          ret = @client.create_resource_type new_feed_id, 'rt-123', 'ResourceType'
           type_path = ret.path
 
-          # 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
-          resources_closable.close
-          @client.create_resource type_path, id_3, 'My Resource 3', 'version' => 1.2
+          r1 = @client.create_resource type_path, 'r125', 'My Resource', 'version' => 1.0
 
-          @client.delete_feed new_feed_id
+          r2 = @client.get_resource(r1.path, true)
+          expect(r2.id).to eq('r125')
+          expect(r1.id).to eq(r2.id)
+          expect(r2.properties).not_to be_empty
         end
 
-        # wait for the data
-        sleep 2 if !WebSocketVCR.cassette || WebSocketVCR.cassette.recording?
-        [feed_deleted_closable, resource_type_closable, feeds_closable].each(&:close)
-        expect(new_resource_events[id_1]).not_to be_nil
-        expect(new_resource_events[id_1].properties['version']).to eq(1.0)
-        expect(new_resource_events[id_2]).not_to be_nil
-        expect(new_resource_events[id_2].properties['version']).to eq(1.1)
-        # resource with id_3 should not be among events, because we stopped listening before creating the 3rd one
-        expect(new_resource_events[id_3]).to be_nil
+        it 'Should not find an unknown resource' do
+          new_feed_id = 'feed_may_exist'
+          path = Hawkular::Inventory::CanonicalPath.new(
+            feed_id: new_feed_id,
+            resource_ids: [hawk_escape_id('*bla does not exist*')])
+          expect { @client.get_resource(path) }
+            .to raise_error(Hawkular::BaseClient::HawkularException, /No Resource found/)
+        end
+
+        it 'Should reject unknown metric type' do
+          new_feed_id = 'feed_may_exist'
 
-        expect(registered_feed_events[new_feed_id]).not_to be_nil
-        expect(registered_feed_events[new_feed_id].id).to eq(new_feed_id)
+          expect { @client.create_metric_type new_feed_id, 'abc', 'FOOBaR' }.to raise_error(RuntimeError,
+                                                                                            /Unknown type FOOBAR/)
+        end
 
-        expect(deleted_feed_events[new_feed_id]).not_to be_nil
-        expect(deleted_feed_events[new_feed_id].id).to eq(new_feed_id)
+        let(:example) do |e|
+          e
+        end
 
-        expect(new_resource_types_events[resource_type_id]).not_to be_nil
-        expect(new_resource_types_events[resource_type_id].id).to eq(resource_type_id)
-        expect(new_resource_types_events[resource_type_id].name).to eq(resource_type_name)
+        it 'Client should listen on various inventory events' do
+          WebSocketVCR.configure do |c|
+            c.hook_uris = [host(security_context)]
+          end
+          uuid_prefix = SecureRandom.uuid
+          x, y, = @client.version
+          record_websocket("Inventory/#{security_context}/inventory_#{x}_#{y}",
+                           { uuid_prefix: uuid_prefix },
+                           'Client_should_listen_on_various_inventory_events') do
+            id_1 = uuid_prefix + '-r126'
+            id_2 = uuid_prefix + '-r127'
+            id_3 = uuid_prefix + '-r128'
+
+            new_resource_events = {}
+            resources_closable = @client.events do |resource|
+              new_resource_events[resource.id] = resource
+            end
+
+            deleted_feed_events = {}
+            feed_deleted_closable = @client.events('feed', 'deleted') do |feed|
+              deleted_feed_events[feed.id] = feed
+            end
+
+            new_resource_types_events = {}
+            # another breaking change in the new inventory api
+            interest = 'resourceType'
+            resource_type_closable = @client.events(interest) do |resource_type|
+              new_resource_types_events[resource_type.id] = resource_type
+            end
+
+            registered_feed_events = {}
+            feeds_closable = @client.events('feed', 'created') do |feed|
+              registered_feed_events[feed.id] = feed
+            end
+
+            new_feed_id = uuid_prefix + '-feed'
+            resource_type_id = uuid_prefix + '-rt-123'
+            resource_type_name = 'ResourceType'
+
+            record("Inventory/#{security_context}/inventory_#{x}_#{y}",
+                   { uuid_prefix: uuid_prefix }.merge(credentials),
+                   'Helpers/generate_some_events_for_websocket') do
+              @client.create_feed new_feed_id
+              ret = @client.create_resource_type new_feed_id, resource_type_id, resource_type_name
+              type_path = ret.path
+
+              # 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
+              resources_closable.close
+              @client.create_resource type_path, id_3, 'My Resource 3', 'version' => 1.2
+
+              @client.delete_feed new_feed_id
+            end
+
+            # wait for the data
+            sleep 5 if !WebSocketVCR.cassette || WebSocketVCR.cassette.recording?
+            [feed_deleted_closable, resource_type_closable, feeds_closable].each(&:close)
+            expect(new_resource_events[id_1]).not_to be_nil
+            expect(new_resource_events[id_1].properties['version']).to eq(1.0)
+            expect(new_resource_events[id_2]).not_to be_nil
+            expect(new_resource_events[id_2].properties['version']).to eq(1.1)
+            # resource with id_3 should not be among events, because we stopped listening before creating the 3rd one
+            expect(new_resource_events[id_3]).to be_nil
+
+            expect(registered_feed_events[new_feed_id]).not_to be_nil
+            expect(registered_feed_events[new_feed_id].id).to eq(new_feed_id)
+
+            expect(deleted_feed_events[new_feed_id]).not_to be_nil
+            expect(deleted_feed_events[new_feed_id].id).to eq(new_feed_id)
+
+            expect(new_resource_types_events[resource_type_id]).not_to be_nil
+            expect(new_resource_types_events[resource_type_id].id).to eq(resource_type_id)
+            expect(new_resource_types_events[resource_type_id].name).to eq(resource_type_name)
+          end
+        end
+
+        it 'Should return the version' do
+          data = @client.fetch_version_and_status
+          expect(data).not_to be_nil
+        end
       end
     end
+  end
 
-    it 'Should return the version' do
-      data = @client.fetch_version_and_status
-      expect(data).not_to be_nil
+  describe 'Inventory' do
+    it 'Should list feeds when using SSL without certificate, disabling the verify' do
+      tori_url = 'https://hawkular.torii.gva.redhat.com/hawkular/inventory'
+      record 'Inventory', credentials, 'Should list feeds when using SSL without certificate' do
+        client = setup_inventory_client tori_url, tenant: 'hawkular', verify_ssl: OpenSSL::SSL::VERIFY_NONE
+        feeds = client.list_feeds
+        expect(feeds.size).to be(1)
+      end
     end
   end
 end