hawkular-client 0.2.2 → 1.0.0

data/spec/integration/metric_spec.rb

@@ -7,57 +7,6 @@ require 'securerandom'
 # time constants
 t4h = 4 * 60 * 60 * 1000
 
-# more or less generic method common for all metric types (counters, gauges, availabilities)
-def create_metric_using_hash(endpoint, id)
-  endpoint.create(id: id, dataRetention: 123, tags: { some: 'value' }, tenantId: @tenant)
-  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)
-end
-
-def create_metric_using_md(endpoint, id)
-  metric = Hawkular::Metrics::MetricDefinition.new
-  metric.id = id
-  metric.data_retention = 90
-  metric.tags = { tag: 'value' }
-  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
-
 describe 'Simple', :vcr do
   it 'Should be Cool' do
     Net::HTTP.get_response(URI('http://localhost:8080/'))
@@ -153,7 +102,7 @@ describe 'Counter metrics' do
     VCR.use_cassette('Counter_metrics/Should create and return counter using Hash parameter',
                      erb: { id: id }, record: :none
                     ) do
-      create_metric_using_hash @client.counters, id
+      create_metric_using_hash @client.counters, id, @tenant
     end
   end
 
@@ -200,18 +149,19 @@ describe 'Counter metrics' do
 
   it 'Should get metrics with limit and order' do
     @client = setup_client(username: 'jdoe', password: 'password')
-    id = '33c6a285-495a-4442-a818-974b03408a6f'
-    now = 1_458_666_669_263
+    id = SecureRandom.uuid
+    now = 1_462_872_284_000
 
     VCR.use_cassette('Counter_metrics/Should get metrics with limit and order',
+                     decode_compressed_response: true,
                      erb: { id: id, ends: now - t4h, starts: now - (2 * t4h),
-                            minus20: now - 20, minus30: now - 30, minus10: now - 10,
+                            minus10: now - 10, minus20: now - 20, minus30: now - 30,
                             now: now }, record: :none
                     ) do
       # create counter
       @client.counters.create(id: id)
 
-      # push 3  values with timestamps
+      # push 3 values with timestamps
       @client.counters.push_data(id, [{ value: 1, timestamp: now - 30 },
                                       { value: 2, timestamp: now - 20 },
                                       { value: 3, timestamp: now - 10 }])
@@ -225,8 +175,9 @@ describe 'Counter metrics' do
       expect(data.size).to be 4
 
       # retrieve values with limit
-      data = @client.counters.get_data(id, limit: 1)
+      data = @client.counters.get_data(id, limit: 1, order: 'DESC')
       expect(data.size).to be 1
+      expect(data.first['value']).to be 4
 
       # retrieve values from past
       data = @client.counters.get_data(id, starts: now - (2 * t4h), ends: now - t4h)
@@ -234,6 +185,48 @@ describe 'Counter metrics' do
     end
   end
 
+  it 'Should get metrics as bucketed results' do
+    @client = setup_client(username: 'jdoe', password: 'password')
+    id = SecureRandom.uuid
+    now = @client.now
+
+    VCR.use_cassette('Counter_metrics/Should get metrics as bucketed results',
+                     decode_compressed_response: true,
+                     erb: { id: id, now: now }, record: :none
+                    ) do
+      # create counter
+      @client.counters.create(id: id)
+
+      # push 10 values with timestamps
+      @client.counters.push_data(id, [{ value: 110, timestamp: now - 110 },
+                                      { value: 100, timestamp: now - 100 },
+                                      { value: 90, timestamp: now - 90 },
+                                      { value: 80, timestamp: now - 80 },
+                                      { value: 70, timestamp: now - 70 },
+                                      { value: 60, timestamp: now - 60 },
+                                      { value: 50, timestamp: now - 50 },
+                                      { value: 40, timestamp: now - 40 },
+                                      { value: 30, timestamp: now - 30 },
+                                      { value: 20, timestamp: now - 20 },
+                                      { value: 10, timestamp: now - 10 }])
+      ERR = 0.001
+      data = @client.counters.get_data(id, starts: now - 105, ends: now - 5, buckets: 5)
+      expect(data.size).to be 5
+      expect(data.first['avg']).to be_within(ERR).of(95.0)
+      expect(data.first['max']).to be_within(ERR).of(100.0)
+      expect(data.first['samples']).to be 2
+
+      data = @client.counters.get_data(id, starts: now - 105, ends: now - 5, buckets: 2)
+      expect(data.size).to be 2
+      expect(data.first['avg']).to be_within(ERR).of(80.0)
+      expect(data.first['samples']).to be 5
+
+      data = @client.counters.get_data(id, starts: now - 105, ends: now - 5, bucketDuration: '50ms')
+      expect(data.size).to be 2
+      expect(data.first['avg']).to be_within(ERR).of(80.0)
+    end
+  end
+
   it 'Should push metric data to non-existing counter' do
     id = SecureRandom.uuid
 
@@ -256,7 +249,7 @@ describe 'Availability metrics' do
       'Availability_metrics/Should create and return Availability using Hash parameter',
       erb: { id: id }, record: :none
     ) do
-      create_metric_using_hash @client.avail, id
+      create_metric_using_hash @client.avail, id, @tenant
     end
   end
 
@@ -312,7 +305,7 @@ describe 'Gauge metrics' do
     VCR.use_cassette('Gauge_metrics/Should create gauge definition using Hash',
                      erb: { id: id }, record: :none
                     ) do
-      create_metric_using_hash @client.gauges, id
+      create_metric_using_hash @client.gauges, id, @tenant
     end
   end
 

data/spec/integration/operations_spec.rb

@@ -5,40 +5,71 @@ require 'securerandom'
 include Hawkular::Inventory
 include Hawkular::Operations
 
-# WebSocket communication cannot be faked via VCR cassettes
+# examples for operations, it uses the websocket communication
 module Hawkular::Operations::RSpec
   HOST = 'localhost:8080'
-  describe 'Websocket connection' do
-    it 'should be established', :websocket do
-      client = OperationsClient.new(host: HOST,
-                                    credentials: {
-                                      username: 'jdoe',
-                                      password: 'password'
-                                    })
-      ws = client.ws
-      expect(ws).not_to be nil
-      expect(ws.open?).to be true
+  describe 'Operation/Websocket connection', vcr: { decode_compressed_response: true } do
+    let(:example) do |e|
+      e
+    end
+
+    it 'should be established' do
+      WebSocketVCR.configure do |c|
+        c.hook_uris = [HOST]
+      end
+
+      WebSocketVCR.record(example, self) do
+        client = OperationsClient.new(host: HOST,
+                                      wait_time: WebSocketVCR.live? ? 1.5 : 0,
+                                      credentials: {
+                                        username: 'jdoe',
+                                        password: 'password'
+                                      })
+        ws = client.ws
+        expect(ws).not_to be nil
+        expect(ws.open?).to be true
+      end
     end
   end
 
-  describe 'Operation', :websocket do
+  describe 'Operation/Operation', :websocket, vcr: { decode_compressed_response: true } do
+    let(:example) do |e|
+      e
+    end
+
     before(:all) do
-      VCR.turn_off!(ignore_cassettes: true)
-      WebMock.allow_net_connect!
-      @creds = { username: 'jdoe', password: 'password' }
-      inventory_client = InventoryClient.new(credentials: @creds)
-      @tenant_id = inventory_client.get_tenant
-      @feed_id = inventory_client.list_feeds[0]
-      @random_uuid = SecureRandom.uuid
+      VCR.use_cassette('Operation/Helpers/get_tenant', decode_compressed_response: true) do
+        @creds = { username: 'jdoe', password: 'password' }
+        inventory_client = InventoryClient.create(credentials: @creds)
+        @tenant_id = inventory_client.get_tenant
+        VCR.use_cassette('Operation/Helpers/get_feed', decode_compressed_response: true) do
+          @feed_id = inventory_client.list_feeds[0]
+        end
+        @random_uuid = 'random'
+      end
     end
 
     before(:each) do |ex|
       unless ex.metadata[:skip_open]
-        @client = OperationsClient.new(credentials: @creds)
+        @client = OperationsClient.new(credentials: @creds,
+                                       wait_time: WebSocketVCR.live? ? 1.5 : 0)
         @ws = @client.ws
       end
     end
 
+    around(:each) do |ex|
+      if ex.metadata[:websocket]
+        WebSocketVCR.configure do |c|
+          c.hook_uris = [HOST]
+        end
+        WebSocketVCR.record(ex, self) do
+          ex.run
+        end
+      else
+        ex.run
+      end
+    end
+
     after(:each) do |ex|
       unless ex.metadata[:skip_close]
         @client.close_connection!
@@ -47,13 +78,6 @@ module Hawkular::Operations::RSpec
       end
     end
 
-    after(:all) do
-      if ENV['VCR_OFF'] != '1'
-        VCR.turn_on!
-        WebMock.disable_net_connect!
-      end
-    end
-
     it 'Add JDBC driver should add the driver' do
       wf_server_resource_id = 'Local~~'
       driver_name = 'CreatedByRubyDriver' + @random_uuid
@@ -137,7 +161,7 @@ module Hawkular::Operations::RSpec
       expect(actual_data[:error]).to start_with('Could not perform [Redeploy] on')
     end
 
-    it 'Disable/Undeploy should be performed and eventually respond with success' do
+    it 'Undeploy should be performed and eventually respond with success' do
       wf_server_resource_id = 'Local~~'
       alerts_war_resource_id = 'Local~%2Fdeployment%3Dhawkular-alerts-actions-email.war'
       path = CanonicalPath.new(tenant_id: @tenant_id,
@@ -267,7 +291,7 @@ module Hawkular::Operations::RSpec
       expect(actual_data['message']).to start_with('Performed [Redeploy] on')
     end
 
-    it 'add deployment should be doable' do
+    it 'Add deployment should be doable' do
       wf_server_resource_id = 'Local~~'
       app_name = 'sample.war'
       war_file = IO.binread("#{File.dirname(__FILE__)}/../resources/#{app_name}")

data/spec/spec_helper.rb

@@ -2,12 +2,14 @@
 require 'coveralls'
 Coveralls.wear!
 # Now the application requires.
-require 'hawkular_all'
+require 'hawkular/hawkular_client'
+require 'hawkular/hawkular_client_utils'
 require 'rspec/core'
 require 'rspec/mocks'
 require 'socket'
 require 'uri'
 require 'yaml'
+require 'json'
 
 module Hawkular::Metrics::RSpec
   def setup_client(options = {})
@@ -31,14 +33,66 @@ module Hawkular::Metrics::RSpec
       File.read(File.expand_path('endpoint.yml', File.dirname(__FILE__)))
     )
   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' }, tenantId: tenant_id)
+    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)
+    metric = Hawkular::Metrics::MetricDefinition.new
+    metric.id = id
+    metric.data_retention = 90
+    metric.tags = { tag: 'value' }
+    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.05
-  MAX_ATTEMPTS = 50
+  SLEEP_SECONDS = 0.04
+  MAX_ATTEMPTS = 60
 
   def wait_for(object)
-    sleep_interval = SLEEP_SECONDS * (ENV['VCR_OFF'] == '1' ? 1 : 10)
+    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
@@ -50,14 +104,60 @@ module Hawkular::Operations::RSpec
   end
 end
 
+# globally used helper functions
+module Helpers
+  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, "<%= #{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
+      example.run unless example.nil?
+      yield if block_given?
+    end
+
+    if (!example.nil? && example.metadata[:update_template]) || ENV['VCR_UPDATE'] == '1'
+      VCR.use_cassette(prefix + '/tmp/' + explicit_cassette_name,
+                       decode_compressed_response: true,
+                       record: :all) do
+        run.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: :none) do
+        run.call
+      end
+    end
+  end
+end
+
 RSpec.configure do |config|
+  config.include Helpers
   config.include Hawkular::Metrics::RSpec
   config.include Hawkular::Operations::RSpec
+  config.include HawkularUtilsMixin
+  config.include Hawkular::Inventory
 
-  # skip the tests that require websocket communication (cannot be recorded by VCR)
-  if ENV['WEBSOCKET_ON'].nil? || ENV['WEBSOCKET_ON'] != '1'
-    config.filter_run_excluding :websocket
-  end
+  # 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
@@ -65,6 +165,7 @@ RSpec.configure do |config|
   if ENV['VCR_OFF'] == '1'
     VCR.eject_cassette
     VCR.turn_off!(ignore_cassettes: true)
+    WebSocketVCR.turn_off!
     WebMock.allow_net_connect!
     puts 'VCR is turned off!'
   end

data/spec/unit/base_spec.rb

@@ -75,4 +75,13 @@ describe 'Base Spec' do
 
     expect(ret).to eq('a1%252%203%7c45%2f')
   end
+
+  it 'should pass http_proxy_uri to rest_client' 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)
+  end
 end