hawkular-client 2.9.0 → 3.0.0

data/spec/integration/tokens_spec.rb

@@ -1,49 +0,0 @@
-require_relative '../vcr/vcr_setup'
-require_relative '../spec_helper'
-
-module Hawkular::Token::RSpec
-  HAWKULAR_BASE = 'http://localhost:8080'.freeze
-  describe 'Tokens', :vcr do
-    it 'Should be able to list the available tokens' do
-      creds = { username: 'jdoe', password: 'password' }
-      options = { tenant: 'hawkular' }
-      client = Hawkular::Token::Client.new(HAWKULAR_BASE, creds, options)
-      tokens = client.get_tokens(creds)
-      expect(tokens).to be_empty
-    end
-
-    it 'Should be able to create a new token for an actual user' do
-      creds = { username: 'jdoe', password: 'password' }
-      options = { tenant: 'hawkular' }
-      client = Hawkular::Token::Client.new(HAWKULAR_BASE, creds, options)
-      token = client.create_token(creds)
-      expect(token['key']).not_to be_nil
-      expect(token['secret']).not_to be_nil
-      expect(token['attributes']['name']).to eq('Token created via Hawkular Ruby Client')
-    end
-
-    it 'Should get a 401 when attempting to create a token with a wrong password' do
-      creds = { username: 'jdoe', password: 'mywrongpassword' }
-      options = { tenant: 'hawkular' }
-      client = Hawkular::Token::Client.new(HAWKULAR_BASE, creds, options)
-      begin
-        client.create_token(creds)
-        fail 'Should have failed with 401'
-      rescue Hawkular::BaseClient::HawkularException => exception
-        expect(exception.status_code).to be(401)
-      end
-    end
-
-    it 'Should get a 401 when attempting to create a token without a password' do
-      creds = { username: 'jdoe', password: '' }
-      options = { tenant: 'hawkular' }
-      client = Hawkular::Token::Client.new(HAWKULAR_BASE, creds, options)
-      begin
-        client.create_token(creds)
-        fail 'Should have failed with 401'
-      rescue Hawkular::BaseClient::HawkularException => exception
-        expect(exception.status_code).to be(401)
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,336 +0,0 @@
-# This needs to go before all requires to be able to record full coverage
-require 'coveralls'
-Coveralls.wear!
-
-# Now the application requires.
-require 'hawkular/hawkular_client'
-require 'hawkular/client_utils'
-require 'rspec/core'
-require 'rspec/mocks'
-require 'socket'
-require 'uri'
-require 'yaml'
-require 'json'
-
-module Hawkular::Inventory::RSpec
-  def setup_inventory_client(entrypoint, options = {})
-    credentials = {
-      username: options[:username].nil? ? config['user'] : options[:username],
-      password: options[:password].nil? ? config['password'] : options[:password]
-    }
-    @client = Hawkular::Inventory::Client.new(entrypoint, credentials, options)
-  end
-
-  def mock_inventory_client(for_version = '0.16.1.Final')
-    allow_any_instance_of(Hawkular::Inventory::Client).to receive(:fetch_version_and_status).and_return(
-      'Implementation-Version' => for_version
-    )
-  end
-end
-
-module Hawkular::Metrics::RSpec
-  def setup_client_without_tenant(options = {})
-    options = options.dup
-    options[:tenant] = nil
-    mocked_version = options[:mocked_version]
-    ::RSpec::Mocks.with_temporary_scope do
-      mock_metrics_version(mocked_version) unless mocked_version.nil?
-      @client = Hawkular::Metrics::Client.new(entrypoint(options[:type], 'metrics'),
-                                              credentials(options), options)
-      return @client
-    end
-  end
-
-  def setup_client(options = {})
-    options = options.dup
-    options[:tenant] ||= 'hawkular'
-    mocked_version = options[:mocked_version]
-    ::RSpec::Mocks.with_temporary_scope do
-      mock_metrics_version(mocked_version) unless mocked_version.nil?
-      @client = Hawkular::Metrics::Client.new(entrypoint(options[:type], 'metrics'),
-                                              credentials(options), options)
-    end
-    @client
-  end
-
-  def setup_v8_client(options = {})
-    options = options.dup
-    options[:tenant] ||= 'hawkular'
-    options[:verify_ssl] ||= OpenSSL::SSL::VERIFY_NONE
-    ::RSpec::Mocks.with_temporary_scope do
-      mock_metrics_version '0.8.0'
-      @client = Hawkular::Metrics::Client.new(entrypoint('v8', 'metrics'),
-                                              credentials_v8(options), options)
-    end
-    @client
-  end
-
-  def credentials_v8(options = {})
-    {
-      token: options[:token].nil? ? config['token_v8'] : options[:token]
-    }
-  end
-
-  def credentials(options = {})
-    {
-      username: options[:username].nil? ? config['user'] : options[:username],
-      password: options[:password].nil? ? config['password'] : options[:password]
-    }
-  end
-
-  def mock_metrics_version(version = '0.9.0.Final')
-    allow_any_instance_of(Hawkular::Metrics::Client).to receive(:fetch_version_and_status).and_return(
-      'Implementation-Version' => version
-    )
-  end
-
-  # more or less generic method common for all metric types (counters, gauges, availabilities)
-  def create_metric_using_hash(endpoint, id, tenant_id)
-    endpoint.create(id: id, dataRetention: 123, tags: { some: 'value' })
-    metric = endpoint.get(id)
-
-    expect(metric).to be_a(Hawkular::Metrics::MetricDefinition)
-    expect(metric.id).to eql(id)
-    expect(metric.data_retention).to eql(123)
-    expect(metric.tenant_id).to eql(tenant_id)
-  end
-
-  def create_metric_using_md(endpoint, id, tags = nil)
-    metric = Hawkular::Metrics::MetricDefinition.new
-    metric.id = id
-    metric.data_retention = 90
-    metric.tags = tags.nil? ? { tag: 'value' } : tags
-    endpoint.create(metric)
-
-    created = endpoint.get(metric.id)
-    expect(created).to be_a(Hawkular::Metrics::MetricDefinition)
-    expect(created.id).to eql(metric.id)
-    expect(created.data_retention).to eql(metric.data_retention)
-  end
-
-  def push_data_to_non_existing_metric(endpoint, data, id)
-    # push one value without timestamp (which means now)
-    endpoint.push_data(id, data)
-
-    data = endpoint.get_data(id)
-    expect(data.size).to be 1
-
-    # verify metric was auto-created
-    counter = endpoint.get(id)
-    expect(counter).to be_a(Hawkular::Metrics::MetricDefinition)
-    expect(counter.id).to eql(id)
-  end
-
-  def update_metric_by_tags(endpoint, id)
-    endpoint.create(id: id, tags: { myTag: id })
-    metric = endpoint.get(id)
-    metric.tags = { newTag: 'newValue' }
-    endpoint.update_tags(metric)
-
-    metric = endpoint.get(id)
-    expect(metric.tags).to include('newTag' => 'newValue', 'myTag' => id)
-
-    # query API for a metric with given tag
-    data = endpoint.query(myTag: id)
-    expect(data.size).to be 1
-  end
-end
-
-module Hawkular::Operations::RSpec
-  SLEEP_SECONDS = 0.1
-  MAX_ATTEMPTS = 200
-
-  def wait_for(object)
-    fast = WebSocketVCR.cassette && !WebSocketVCR.cassette.recording?
-    sleep_interval = SLEEP_SECONDS * (fast ? 1 : 10)
-    attempt = 0
-    sleep sleep_interval while object[:data].nil? && (attempt += 1) < MAX_ATTEMPTS
-    if attempt == MAX_ATTEMPTS
-      puts 'timeout hit'
-      {}
-    else
-      object[:data]
-    end
-  end
-
-  def wait_while
-    fast = WebSocketVCR.cassette && !WebSocketVCR.cassette.recording?
-    sleep_interval = SLEEP_SECONDS * (fast ? 1 : 10)
-    sleep_interval *= 3 if ENV['TRAVIS']
-    attempt = 0
-    sleep sleep_interval while yield && (attempt += 1) < MAX_ATTEMPTS
-    if attempt == MAX_ATTEMPTS
-      puts 'timeout hit'
-    else
-      return
-    end
-  end
-
-  def hash_include_all(hash, keys)
-    keys.all? do |key|
-      hash.key? key
-    end
-  end
-
-  def host_with_scheme(host, use_secure_connection)
-    "#{use_secure_connection ? 'https' : 'http'}://#{host}"
-  end
-end
-
-# globally used helper functions
-module Helpers
-  def config
-    @config ||= YAML.load(
-      File.read(File.expand_path('endpoint.yml', __dir__))
-    )
-  end
-
-  def entrypoint(type, component = nil)
-    base = config[type.to_s.downcase]
-    entrypoint = "#{base['is_secure'] ? 'https' : 'http'}://#{base['host']}:#{base['port']}/"
-    entrypoint << config[component] unless component.nil?
-  end
-
-  def host(type)
-    base = config[type.to_s.downcase]
-    "#{base['host']}:#{base['port']}"
-  end
-
-  def path_for_installed_agent(wf_server_path)
-    wf_server_path.to_resource('Local~%2Fsubsystem%3Dhawkular-wildfly-agent')
-  end
-
-  def in_container(inventory, resource_path)
-    properties = inventory.get_resource(resource_path, true).properties
-    properties.key?('In Container') ? (properties['In Container'] == 'true') : false
-  end
-
-  def immutable(inventory, resource_path)
-    properties = inventory.get_resource(resource_path, true).properties
-    properties.key?('Immutable') ? (properties['Immutable'] == 'true') : false
-  end
-
-  def make_template(base_directory, cassette_name, bindings)
-    cassette = cassette_name.gsub(/\s+/, '_')
-    input_file_path = "#{VCR.configuration.cassette_library_dir}/#{base_directory}/tmp/#{cassette}.yml"
-    return unless File.exist? input_file_path
-    output_file_path = "#{VCR.configuration.cassette_library_dir}/#{base_directory}/Templates/#{cassette}.yml"
-
-    dirname = File.dirname(output_file_path)
-    # make sure the directory structure is there
-    FileUtils.mkdir_p(dirname) unless File.directory?(dirname)
-
-    text = File.read(input_file_path)
-    bindings.select { |_, v| v.size >= 3 }.each do |k, v|
-      text.gsub! v.to_s, "<%= #{k} %>"
-    end
-
-    File.open(output_file_path, 'w') { |file| file.write text }
-    File.delete(input_file_path)
-  end
-
-  def record(prefix, bindings, explicit_cassette_name, example: nil)
-    run = lambda do
-      unless example.nil?
-        if example.respond_to?(:run)
-          example.run
-        elsif example.respond_to?(:call)
-          example.call
-        end
-      end
-      yield if block_given?
-    end
-    record_cassette(prefix, bindings, explicit_cassette_name, run)
-  end
-
-  def record_cleanup(prefix)
-    FileUtils.rm_rf "#{VCR.configuration.cassette_library_dir}/#{prefix}/tmp"
-  end
-
-  def record_websocket(prefix, bindings, explicit_cassette_name, example = nil)
-    prefix.gsub!(/\s/, '_')
-    explicit_cassette_name.gsub!(/\s/, '_')
-    run = lambda do
-      unless example.nil?
-        if example.respond_to?(:run)
-          example.run
-        elsif example.respond_to?(:call)
-          example.call
-        end
-      end
-      yield if block_given?
-    end
-
-    record_websocket_cassette(prefix, bindings, explicit_cassette_name, run)
-  end
-
-  private
-
-  def record_cassette(prefix, bindings, explicit_cassette_name, run_lambda)
-    if ENV['VCR_UPDATE'] == '1' && bindings
-      VCR.use_cassette(prefix + '/tmp/' + explicit_cassette_name,
-                       decode_compressed_response: true,
-                       record: :all) do
-        run_lambda.call
-      end
-      make_template prefix, explicit_cassette_name, bindings
-    else
-      VCR.use_cassette(prefix + '/Templates/' + explicit_cassette_name,
-                       decode_compressed_response: true,
-                       erb: bindings,
-                       record: ENV['VCR_UPDATE'] == '1' ? :all : :none) do
-        run_lambda.call
-      end
-    end
-  end
-
-  def record_websocket_cassette(prefix, bindings, explicit_cassette_name, run_lambda)
-    options = {
-      record: :none,
-      decode_compressed_response: true
-    }
-    options[:erb] = bindings if bindings
-    if ENV['VCR_UPDATE'] == '1'
-      options[:record] = :all
-      options[:reverse_substitution] = true if bindings
-    end
-    WebSocketVCR.use_cassette(prefix + '/' + explicit_cassette_name, options) do
-      run_lambda.call
-    end
-  end
-end
-
-RSpec.configure do |config|
-  config.include Helpers
-  config.include Hawkular::Inventory::RSpec
-  config.include Hawkular::Metrics::RSpec
-  config.include Hawkular::Operations::RSpec
-  config.include Hawkular::ClientUtils
-  config.include Hawkular::Inventory
-
-  # skip the tests that have the :skip metadata on them
-  config.filter_run_excluding :skip
-
-  # Sometimes one wants to check if the real api has
-  # changed, so turn off VCR and use live connections
-  # instead of recorded cassettes
-  if ENV['VCR_OFF'] == '1'
-    VCR.eject_cassette
-    VCR.turn_off!(ignore_cassettes: true)
-    WebSocketVCR.turn_off! # TODO: this does not work as the impl is empty
-    WebMock.allow_net_connect!
-    puts 'VCR is turned off!'
-  end
-
-  module RestClient
-    class Request
-      def default_headers
-        {
-          accept: '*/*',
-          accept_encoding: 'identity',
-          user_agent: 'hawkular-client-ruby'
-        }
-      end
-    end
-  end
-end

data/spec/unit/base_spec.rb

@@ -1,256 +0,0 @@
-require_relative '../vcr/vcr_setup'
-require_relative '../spec_helper'
-
-describe 'Base Spec' do
-  it 'should know encode' do
-    creds = { username: 'jdoe', password: 'password' }
-
-    c = Hawkular::BaseClient.new('not-needed-for-this-test')
-    val = c.base_64_credentials(creds)
-
-    expect(val).to eql('amRvZTpwYXNzd29yZA==')
-  end
-
-  it 'should be empty' do
-    c = Hawkular::BaseClient.new('not-needed-for-this-test')
-    ret = c.generate_query_params
-    expect(ret).to eql('')
-  end
-
-  it 'should have one param' do
-    params = { name: nil, value: 'hello' }
-
-    c = Hawkular::BaseClient.new('not-needed-for-this-test')
-    ret = c.generate_query_params params
-
-    expect(ret).to eql('?value=hello')
-  end
-
-  it 'should have two params' do
-    params = { name: 'world', value: 'hello' }
-
-    c = Hawkular::BaseClient.new('not-needed-for-this-test')
-    ret = c.generate_query_params params
-
-    expect(ret).to include('value=hello')
-    expect(ret).to include('name=world')
-    expect(ret).to start_with('?')
-    expect(ret).to include('&')
-  end
-
-  it 'should flatten arrays' do
-    params = { value: %w(hello world) }
-
-    c = Hawkular::BaseClient.new('not-needed-for-this-test')
-    ret = c.generate_query_params params
-
-    expect(ret).to eql('?value=hello,world')
-  end
-
-  it 'should flatten arrays2' do
-    params = { value: [] }
-
-    c = Hawkular::BaseClient.new('not-needed-for-this-test')
-    ret = c.generate_query_params params
-
-    expect(ret).to eq('')
-  end
-
-  it 'should escape numbers' do
-    c = Hawkular::BaseClient.new('not-needed-for-this-test')
-    ret = c.hawk_escape 12_345
-
-    expect(ret).to eq('12345')
-  end
-
-  it 'should escape alpha' do
-    c = Hawkular::BaseClient.new('not-needed-for-this-test')
-    ret = c.hawk_escape 'a12345'
-
-    expect(ret).to eq('a12345')
-  end
-
-  it 'should escape strange stuff' do
-    c = Hawkular::BaseClient.new('not-needed-for-this-test')
-    ret = c.hawk_escape 'a1%2 3|45/'
-
-    expect(ret).to eq('a1%252%203%7c45%2f')
-  end
-
-  it 'should pass through options to rest_client' do
-    proxy_uri = 'http://myproxy.com'
-    c = Hawkular::BaseClient.new('not-needed-for-this-test', {},
-                                 { proxy: proxy_uri, timeout: 10 })
-    rc = c.rest_client('myurl')
-
-    expect(rc.options).to include(proxy: proxy_uri, timeout: 10)
-  end
-
-  # backward compatibility
-  it 'should pass :http_proxy_uri to rest_client :proxy' do
-    proxy_uri = 'http://myproxy.com'
-    c = Hawkular::BaseClient.new('not-needed-for-this-test', {},
-                                 { http_proxy_uri: proxy_uri })
-    rc = c.rest_client('myurl')
-
-    expect(rc.options[:proxy]).to eq(proxy_uri)
-    expect(rc.options).to include(proxy: proxy_uri)
-    expect(rc.options).not_to have_key(:http_proxy_uri)
-  end
-
-  it 'should merge constructor, hawkular, and call headers' do
-    c = Hawkular::BaseClient.new('not-needed-for-this-test', {},
-                                 { tenant: 'Me', headers: { 'X-Foo' => 'bar' } })
-    headers = c.http_headers('Referer' => 'them.example.com')
-
-    expect(headers).to include('Hawkular-Tenant': 'Me',
-                               'Referer' => 'them.example.com',
-                               'X-Foo' => 'bar')
-  end
-
-  it 'Should normalize different types of url and suffix combinations with or without slash' do
-    c = Hawkular::BaseClient.new('not-needed-for-this-test')
-
-    ret = c.normalize_entrypoint_url 'http://localhost:8080', '/hawkular/alerts/'
-    expect(ret).to eq('http://localhost:8080/hawkular/alerts')
-
-    ret = c.normalize_entrypoint_url 'http://localhost:8080', '/hawkular/alerts'
-    expect(ret).to eq('http://localhost:8080/hawkular/alerts')
-
-    ret = c.normalize_entrypoint_url 'http://localhost:8080', 'hawkular/alerts/'
-    expect(ret).to eq('http://localhost:8080/hawkular/alerts')
-
-    ret = c.normalize_entrypoint_url 'http://localhost:8080', 'hawkular/alerts'
-    expect(ret).to eq('http://localhost:8080/hawkular/alerts')
-
-    ret = c.normalize_entrypoint_url 'http://localhost:8080/', '/hawkular/alerts/'
-    expect(ret).to eq('http://localhost:8080/hawkular/alerts')
-
-    ret = c.normalize_entrypoint_url 'http://localhost:8080/', '/hawkular/alerts'
-    expect(ret).to eq('http://localhost:8080/hawkular/alerts')
-
-    ret = c.normalize_entrypoint_url 'http://localhost:8080/', 'hawkular/alerts/'
-    expect(ret).to eq('http://localhost:8080/hawkular/alerts')
-
-    ret = c.normalize_entrypoint_url 'http://localhost:8080/', 'hawkular/alerts'
-    expect(ret).to eq('http://localhost:8080/hawkular/alerts')
-
-    ret = c.normalize_entrypoint_url 'http://localhost:8080/hawkular/alerts', '/hawkular/alerts/'
-    expect(ret).to eq('http://localhost:8080/hawkular/alerts')
-
-    ret = c.normalize_entrypoint_url 'http://localhost:8080/hawkular/alerts', '/hawkular/alerts'
-    expect(ret).to eq('http://localhost:8080/hawkular/alerts')
-
-    ret = c.normalize_entrypoint_url 'http://localhost:8080/hawkular/alerts', 'hawkular/alerts/'
-    expect(ret).to eq('http://localhost:8080/hawkular/alerts')
-
-    ret = c.normalize_entrypoint_url 'http://localhost:8080/hawkular/alerts', 'hawkular/alerts'
-    expect(ret).to eq('http://localhost:8080/hawkular/alerts')
-
-    ret = c.normalize_entrypoint_url 'http://localhost:8080/hawkular/alerts/', '/hawkular/alerts/'
-    expect(ret).to eq('http://localhost:8080/hawkular/alerts')
-
-    ret = c.normalize_entrypoint_url 'http://localhost:8080/hawkular/alerts/', '/hawkular/alerts'
-    expect(ret).to eq('http://localhost:8080/hawkular/alerts')
-
-    ret = c.normalize_entrypoint_url 'http://localhost:8080/hawkular/alerts/', 'hawkular/alerts/'
-    expect(ret).to eq('http://localhost:8080/hawkular/alerts')
-
-    ret = c.normalize_entrypoint_url 'http://localhost:8080/hawkular/alerts/', 'hawkular/alerts'
-    expect(ret).to eq('http://localhost:8080/hawkular/alerts')
-
-    ret = c.normalize_entrypoint_url 'http://127.0.0.1/hawkular/alerts/', 'hawkular/alerts'
-    expect(ret).to eq('http://127.0.0.1/hawkular/alerts')
-
-    ret = c.normalize_entrypoint_url 'https://127.0.0.1/hawkular/alerts/', 'hawkular/alerts'
-    expect(ret).to eq('https://127.0.0.1/hawkular/alerts')
-
-    ret = c.normalize_entrypoint_url 'https://localhost:8080/', 'hawkular/alerts'
-    expect(ret).to eq('https://localhost:8080/hawkular/alerts')
-
-    expect { c.normalize_entrypoint_url 'https://localhost:8080/hawkular/alerts', '' }.to raise_error(ArgumentError)
-
-    uri = URI.parse 'https://localhost:8080/'
-    ret = c.normalize_entrypoint_url uri, 'hawkular/alerts'
-    expect(ret).to eq('https://localhost:8080/hawkular/alerts')
-
-    uri = URI.parse 'http://localhost:8080/hawkular/alerts/'
-    ret = c.normalize_entrypoint_url uri, '/hawkular/alerts/'
-    expect(ret).to eq('http://localhost:8080/hawkular/alerts')
-  end
-
-  it 'Should change http to ws and https to wss on different types of urls' do
-    c = Hawkular::BaseClient.new('not-needed-for-this-test')
-    ret = c.url_with_websocket_scheme 'http://localhost:8080'
-    expect(ret).to eq('ws://localhost:8080')
-
-    ret = c.url_with_websocket_scheme 'https://localhost:8443'
-    expect(ret).to eq('wss://localhost:8443')
-
-    ret = c.url_with_websocket_scheme 'http://localhost'
-    expect(ret).to eq('ws://localhost')
-
-    ret = c.url_with_websocket_scheme 'https://localhost'
-    expect(ret).to eq('wss://localhost')
-
-    ret = c.url_with_websocket_scheme 'http://localhost:8080/hawkular/inventory/'
-    expect(ret).to eq('ws://localhost:8080/hawkular/inventory/')
-
-    ret = c.url_with_websocket_scheme 'https://localhost:8443/hawkular/inventory/'
-    expect(ret).to eq('wss://localhost:8443/hawkular/inventory/')
-
-    ret = c.url_with_websocket_scheme 'http://localhost/hawkular/inventory/'
-    expect(ret).to eq('ws://localhost/hawkular/inventory/')
-
-    ret = c.url_with_websocket_scheme 'https://localhost/hawkular/inventory/'
-    expect(ret).to eq('wss://localhost/hawkular/inventory/')
-
-    ret = c.url_with_websocket_scheme 'http://localhost:8080/http'
-    expect(ret).to eq('ws://localhost:8080/http')
-
-    ret = c.url_with_websocket_scheme 'https://localhost:8443/http/https'
-    expect(ret).to eq('wss://localhost:8443/http/https')
-
-    ret = c.url_with_websocket_scheme 'ftp://http:8080'
-    expect(ret).to eq('ftp://http:8080')
-
-    ret = c.url_with_websocket_scheme 'ftp://https'
-    expect(ret).to eq('ftp://https')
-
-    uri = URI.parse 'http://localhost:8080/hawkular/inventory'
-    ret = c.url_with_websocket_scheme uri
-    expect(ret).to eq('ws://localhost:8080/hawkular/inventory')
-
-    uri = URI.parse 'https://localhost:8443/hawkular/inventory'
-    ret = c.url_with_websocket_scheme uri
-    expect(ret).to eq('wss://localhost:8443/hawkular/inventory')
-  end
-
-  it 'Should throw a HawkularConnectionException when host not listening to port' do
-    begin
-      WebMock.disable!
-      VCR.turned_off do
-        c = Hawkular::BaseClient.new('127.0.0.1:0')
-        expect do
-          c.http_get('not-needed-for-this-test')
-        end.to raise_error(Hawkular::BaseClient::HawkularConnectionException)
-      end
-    ensure
-      WebMock.enable!
-    end
-  end
-
-  it 'Should throw a HawkularConnectionException when unknown host' do
-    begin
-      WebMock.disable!
-      VCR.turned_off do
-        c = Hawkular::BaseClient.new('some-unknown-and-random-host-that-wont-exist')
-        expect do
-          c.http_get('not-needed-for-this-test')
-        end.to raise_error(Hawkular::BaseClient::HawkularConnectionException)
-      end
-    ensure
-      WebMock.enable!
-    end
-  end
-end