hawkular-client 0.1.0 → 0.1.1

data/lib/metrics/tenant_api.rb

@@ -2,24 +2,23 @@ module Hawkular::Metrics
   class Client
     # Provides access to tenants API
     class Tenants
-
       # @param client [Client]
       def initialize(client)
         @client = client
-        @resource = "tenants"
+        @resource = 'tenants'
       end
 
       # Create new tenant
       # @param id [String] tenant ID/Name
       def create(id)
-        @client.http_post("/#{@resource}", {:id => id})
+        @client.http_post("/#{@resource}", id: id)
       end
 
       # Query existing tenants
       # @return [Array[Tenant]]
       def query
         @client.http_get("/#{@resource}").map do |t|
-          Hawkular::Metrics::Tenant::new(t)
+          Hawkular::Metrics::Tenant.new(t)
         end
       end
     end

data/lib/metrics/types.rb

@@ -6,9 +6,7 @@ module Hawkular
 
       def initialize(json)
         @json = json
-        if !json.nil?
-          @id = @json['id']
-        end
+        @id = @json['id'] unless json.nil?
       end
     end
 
@@ -16,23 +14,23 @@ module Hawkular
     end
 
     class MetricDefinition < BaseObject
-      attr_accessor :tenantId, :dataRetention, :tags
+      attr_accessor :tenant_id, :data_retention, :tags
 
-      def initialize(json=nil)
+      def initialize(json = nil)
         super(json)
-        if !json.nil?
-          @tenantId = @json['tenantId']
-          @dataRetention = @json['dataRetention']
+        unless json.nil? # rubocop:disable Style/GuardClause
+          @tenant_id = @json['tenantId']
+          @data_retention = @json['dataRetention']
           @tags = @json['tags']
         end
       end
 
       def hash
-        h = {:id => @id, :tenantId => @tenantId, :dataRetention => @dataRetention, :tags => @tags}
-        h.delete_if { |k, v| v.nil? }
+        h = { id: @id, tenantId: @tenant_id,
+              dataRetention: @data_retention, tags: @tags }
+        h.delete_if { |_k, v| v.nil? }
         h
       end
-
     end
   end
 end

data/lib/metrics/version.rb

@@ -1,5 +1,5 @@
 module Hawkular
   module Metrics
-    VERSION = "0.1.0"
+    VERSION = '0.1.1'
   end
 end

data/spec/integration/metric_spec.rb

@@ -1,243 +1,335 @@
+require "#{File.dirname(__FILE__)}/../vcr/vcr_setup"
 require "#{File.dirname(__FILE__)}/../spec_helper"
-require "securerandom"
+require 'securerandom'
 
 # examples related to Hawkular Metrics
 
-
 # time constants
 t4h = 4 * 60 * 60 * 1000
 
-# more or less generic methodc common for all metric types (counters, gauges, availabilities)
-def create_metric_using_hash(endpoint)
-  id = SecureRandom.uuid
-  endpoint.create({:id => id, :dataRetention => 123, :tags => {:some => "value"}, :tenantId => @tenant})
+# 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.dataRetention).to eql(123)
-  expect(metric.tenantId).to eql(@tenant)
+  expect(metric.data_retention).to eql(123)
+  expect(metric.tenant_id).to eql(@tenant)
 end
 
-def create_metric_using_md(endpoint)
-  metric = Hawkular::Metrics::MetricDefinition::new
-  metric.id = SecureRandom.uuid
-  metric.dataRetention = 90
-  metric.tags = {:tag => "value"}
+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.dataRetention).to eql(metric.dataRetention)
+  expect(created.data_retention).to eql(metric.data_retention)
 end
 
-def push_data_to_non_existing_metric(endpoint, data)
-  id = SecureRandom.uuid
+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
+  # 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 = SecureRandom.uuid
-  endpoint.create({:id => id, :tags => {:myTag => id}})
+def update_metric_by_tags(endpoint, id)
+  endpoint.create(id: id, tags: { myTag: id })
   metric = endpoint.get(id)
-  metric.tags = {:newTag => "newValue"}
+  metric.tags = { newTag: 'newValue' }
   endpoint.update_tags(metric)
 
   metric = endpoint.get(id)
-  expect(metric.tags).to include({"newTag" => "newValue","myTag" => id})
+  expect(metric.tags).to include('newTag' => 'newValue', 'myTag' => id)
 
   # query API for a metric with given tag
-  data = endpoint.query({:myTag => id})
+  data = endpoint.query(myTag: id)
   expect(data.size).to be 1
 end
 
-describe "Tenants" do
+describe 'Simple', :vcr do
+  it 'Should be Cool' do
+    Net::HTTP.get_response(URI('http://localhost:8080/'))
+  end
+end
 
+describe 'Tenants', vcr: { match_requests_on: [:uri, :method], record: :none } do
   before(:all) do
     setup_client
   end
 
-  it "Should create and return tenant" do
+  it 'Should create and return tenant' do
     tenant = SecureRandom.uuid
     @client.tenants.create(tenant)
-    created = @client.tenants.query.select { |t|
-      t.id == tenant
-    }
+    created = @client.tenants.query.select { |t| t.id == tenant }
     expect(created).not_to be nil
   end
 end
 
-describe "Mixed metrics" do
-
+describe 'Mixed metrics' do
   before(:all) do
     setup_client_new_tenant
   end
 
-  it "Should send mixed metric request of a single type" do
+  it 'Should send mixed metric request of a single type' do
     id = SecureRandom.uuid
-    @client.push_data(counters:[{:id => id, :data => [{:value => 1}]} ] )
-    data = @client.counters.get_data(id)
-    expect(data.size).to be 1
-
-    @client.push_data(availabilities:[{:id => id, :data => [{:value => "down"}]} ] )
-    data = @client.avail.get_data(id)
-    expect(data.size).to be 1
 
-    @client.push_data(gauges:[{:id => id, :data => [{:value => 1.1}]} ] )
-    data = @client.gauges.get_data(id)
-    expect(data.size).to be 1
+    VCR.use_cassette('Mixed_metrics/Should send mixed metric request of a single type',
+                     erb: { id: id }, record: :none
+                    ) do
+      @client.push_data(counters: [{ id: id, data: [{ value: 1 }] }])
+      data = @client.counters.get_data(id)
+      expect(data.size).to be 1
+
+      @client.push_data(availabilities: [{ id: id, data: [{ value: 'down' }] }])
+      data = @client.avail.get_data(id)
+      expect(data.size).to be 1
+
+      @client.push_data(gauges: [{ id: id, data: [{ value: 1.1 }] }])
+      data = @client.gauges.get_data(id)
+      expect(data.size).to be 1
+    end
   end
+  #  end
 
-  it "Should send mixed metric request" do
+  it 'Should send mixed metric request' do
     id = SecureRandom.uuid
-
-    expect(@client.counters.get_data(id).size).to be 0
-    expect(@client.gauges.get_data(id).size).to be 0
-    expect(@client.avail.get_data(id).size).to be 0
-
-    @client.push_data(
-      counters:[{:id => id, :data => [{:value => 1}]}],
-      availabilities:[{:id => id, :data => [{:value => "down"}]}],
-      gauges:[{:id => id, :data => [{:value => 1.1}]}]
-    )
-
-    expect(@client.counters.get_data(id).size).to be 1
-    expect(@client.gauges.get_data(id).size).to be 1
-    expect(@client.avail.get_data(id).size).to be 1
+    VCR.use_cassette('Mixed_metrics/Should send mixed metric request',
+                     erb: { id: id }, record: :none
+                    ) do
+      expect(@client.counters.get_data(id).size).to be 0
+      expect(@client.gauges.get_data(id).size).to be 0
+      expect(@client.avail.get_data(id).size).to be 0
+
+      @client.push_data(
+        counters: [{ id: id, data: [{ value: 1 }] }],
+        availabilities: [{ id: id, data: [{ value: 'down' }] }],
+        gauges: [{ id: id, data: [{ value: 1.1 }] }]
+      )
+
+      expect(@client.counters.get_data(id).size).to be 1
+      expect(@client.gauges.get_data(id).size).to be 1
+      expect(@client.avail.get_data(id).size).to be 1
+    end
   end
 end
 
-describe "Counter metrics" do
-
+describe 'Counter metrics' do
   before(:all) do
     setup_client_new_tenant
   end
 
-  it "Should create and return counter using Hash parameter" do
-    create_metric_using_hash @client.counters
+  it 'Should create and return counter using Hash parameter' do
+    id = SecureRandom.uuid
+    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
+    end
   end
 
-  it "Should create counter definition using MetricDefinition parameter" do
-    create_metric_using_md @client.counters
+  it 'Should create counter definition using MetricDefinition parameter' do
+    id = SecureRandom.uuid
+    VCR.use_cassette(
+      'Counter_metrics/Should create counter definition using MetricDefinition parameter',
+      erb: { id: id }, record: :none
+    ) do
+      create_metric_using_md @client.counters, id
+    end
   end
 
-  it "Should push metric data to existing counter" do
+  it 'Should push metric data to existing counter' do
     id = SecureRandom.uuid
-    #create counter
-    @client.counters.create({:id => id})
     now = @client.now
 
-    # 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 }])
-
-    data = @client.counters.get_data(id)
-    expect(data.size).to be 3
-
-    # push one value without timestamp (which means now)
-    @client.counters.push_data(id, {:value => 4})
-    data = @client.counters.get_data(id)
-    expect(data.size).to be 4
-
-    # retrieve values from past
-    data = @client.counters.get_data(id, starts: @client.now - (2 * t4h), ends: @client.now - t4h)
-    expect(data.empty?).to be true
+    VCR.use_cassette('Counter_metrics/Should push metric data to existing counter',
+                     erb: { id: id, ends: now - t4h, starts: now - (2 * t4h),
+                            minus20: now - 20, minus30: now - 30, minus10: now - 10,
+                            now: now }, record: :none
+                    ) do
+      # create counter
+      @client.counters.create(id: id)
+
+      # 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 }])
+
+      data = @client.counters.get_data(id)
+      expect(data.size).to be 3
+
+      # push one value without timestamp (which means now)
+      @client.counters.push_data(id, value: 4)
+      data = @client.counters.get_data(id)
+      expect(data.size).to be 4
+
+      # retrieve values from past
+      data = @client.counters.get_data(id, starts: now - (2 * t4h), ends: now - t4h)
+      expect(data.empty?).to be true
+    end
   end
 
-  it "Should push metric data to non-existing counter" do
-    push_data_to_non_existing_metric @client.counters, {:value => 4}
-  end
+  it 'Should push metric data to non-existing counter' do
+    id = SecureRandom.uuid
 
+    VCR.use_cassette('Counter_metrics/Should push metric data to non-existing counter',
+                     erb: { id: id }, record: :none
+                    ) do
+      push_data_to_non_existing_metric @client.counters, { value: 4 }, id
+    end
+  end
 end
 
-describe "Availability metrics" do
-
+describe 'Availability metrics' do
   before(:all) do
     setup_client_new_tenant
   end
 
-  it "Should create and return Availability using Hash parameter" do
-    create_metric_using_hash @client.avail
+  it 'Should create and return Availability using Hash parameter' do
+    id = SecureRandom.uuid
+    VCR.use_cassette(
+      'Availability_metrics/Should create and return Availability using Hash parameter',
+      erb: { id: id }, record: :none
+    ) do
+      create_metric_using_hash @client.avail, id
+    end
   end
 
-  it "Should create Availability definition using MetricDefinition parameter" do
-    create_metric_using_md @client.avail
+  it 'Should create Availability definition using MetricDefinition parameter' do
+    id = SecureRandom.uuid
+    VCR.use_cassette(
+      'Availability_metrics/Should create Availability definition using MetricDefinition parameter',
+      erb: { id: id }, record: :none
+    ) do
+      create_metric_using_md @client.avail, id
+    end
   end
 
-  it "Should push metric data to non-existing Availability" do
-    push_data_to_non_existing_metric @client.avail, {:value =>"UP"}
+  it 'Should push metric data to non-existing Availability' do
+    id = SecureRandom.uuid
+
+    VCR.use_cassette('Availability_metrics/Should push metric data to non-existing Availability',
+                     erb: { id: id }, record: :none
+                    ) do
+      push_data_to_non_existing_metric @client.avail, { value: 'UP' }, id
+    end
   end
-  it "Should update tags for Availability definition" do
-    update_metric_by_tags @client.avail
+
+  it 'Should update tags for Availability definition' do
+    id = SecureRandom.uuid
+
+    VCR.use_cassette('Availability_metrics/Should update tags for Availability definition',
+                     erb: { id: id }, record: :none
+                    ) do
+      update_metric_by_tags @client.avail, id
+    end
   end
 end
 
-describe "Gauge metrics" do
-
+describe 'Gauge metrics' do
   before(:all) do
     setup_client_new_tenant
   end
 
-  it "Should create gauge definition using MetricDefinition" do
-    create_metric_using_md @client.gauges
-  end
+  it 'Should create gauge definition using MetricDefinition' do
+    id = SecureRandom.uuid
 
-  it "Should create gauge definition using Hash" do
-    create_metric_using_hash @client.gauges
+    VCR.use_cassette('Gauge_metrics/Should create gauge definition using MetricDefinition',
+                     erb: { id: id }, record: :none
+                    ) do
+      create_metric_using_md @client.gauges, id
+    end
   end
 
-  it "Should push metric data to non-existing gauge" do
-    push_data_to_non_existing_metric @client.gauges, {:value =>3.1415926}
+  it 'Should create gauge definition using Hash' do
+    id = SecureRandom.uuid
+
+    VCR.use_cassette('Gauge_metrics/Should create gauge definition using Hash',
+                     erb: { id: id }, record: :none
+                    ) do
+      create_metric_using_hash @client.gauges, id
+    end
   end
 
-  it "Should push metric data to existing gauge" do
+  it 'Should push metric data to non-existing gauge' do
     id = SecureRandom.uuid
-    #create gauge
-    @client.gauges.create({:id => id})
-    now = @client.now
 
-    # push 3  values with timestamps
-    @client.gauges.push_data(id, [{:value => 1, :timestamp => now - 30}, {:value => 2, :timestamp => now - 20}, {:value => 3, :timestamp => now -10 }])
-
-    data = @client.gauges.get_data(id)
-    expect(data.size).to be 3
+    VCR.use_cassette('Gauge_metrics/Should push metric data to non-existing gauge',
+                     erb: { id: id }, record: :none
+                    ) do
+      push_data_to_non_existing_metric @client.gauges, { value: 3.1415926 }, id
+    end
+  end
 
-    # push one value without timestamp (which means now)
-    @client.gauges.push_data(id, {:value => 4})
-    data = @client.gauges.get_data(id)
-    expect(data.size).to be 4
+  it 'Should push metric data to existing gauge' do
+    id = SecureRandom.uuid
+    now = @client.now
 
-    # retrieve values from past
-    data = @client.counters.get_data(id, starts: @client.now - (2 * t4h), ends: @client.now - t4h)
-    expect(data.empty?).to be true
+    VCR.use_cassette('Gauge_metrics/Should push metric data to existing gauge',
+                     erb: { id: id, ends: now - t4h, starts: now - (2 * t4h) }, record: :none
+                    ) do
+      # create gauge
+      @client.gauges.create(id: id)
+
+      # push 3  values with timestamps
+      @client.gauges.push_data(id,
+                               [{ value: 1, timestamp: now - 30 },
+                                { value: 2, timestamp: now - 20 },
+                                { value: 3, timestamp: now - 10 }])
+
+      data = @client.gauges.get_data(id)
+      expect(data.size).to be 3
+
+      # push one value without timestamp (which means now)
+      @client.gauges.push_data(id, value: 4)
+      data = @client.gauges.get_data(id)
+      expect(data.size).to be 4
+
+      # retrieve values from past
+      data = @client.counters.get_data(id, starts: now - (2 * t4h), ends: now - t4h)
+      expect(data.empty?).to be true
+    end
   end
 
-  it "Should update tags for gauge definition" do
-    update_metric_by_tags @client.gauges
+  it 'Should update tags for gauge definition' do
+    id = SecureRandom.uuid
+
+    VCR.use_cassette('Gauge_metrics/Should update tags for gauge definition',
+                     erb: { id: id }, record: :none
+                    ) do
+      update_metric_by_tags @client.gauges, id
+    end
   end
 
-  it "Should return periods" do
+  it 'Should return periods' do
     id = SecureRandom.uuid
     now = @client.now
-    # push 3  values with timestamps
-    @client.gauges.push_data(id, [{:value => 1, :timestamp => now - 30}, {:value => 2, :timestamp => now - 20}, {:value => 3, :timestamp => now}])
-
-    before4h = @client.now - t4h
-    data = @client.gauges.get_periods(id, operation: "lte", threshold: 4, starts: before4h)
-    expect(data.size).to be 1
-    expect(data[0][0]).to eql(now - 30)
-    expect(data[0][1]).to eql(now)
+    before4h = now - t4h
+
+    VCR.use_cassette('Gauge_metrics/Should return periods',
+                     erb: {  id: id, start: now, before4h: before4h,
+                             minus20: now - 20, minus30: now - 30 },
+                     record: :none) do
+      # push 3  values with timestamps
+      @client.gauges.push_data(id, [{ value: 1, timestamp: now - 30 },
+                                    { value: 2, timestamp: now - 20 },
+                                    { value: 3, timestamp: now }])
+
+      data = @client.gauges.get_periods(id, operation: 'lte', threshold: 4, starts: before4h)
+      expect(data.size).to be 1
+      expect(data[0][0]).to eql(now - 30)
+      expect(data[0][1]).to eql(now)
+    end
   end
-
 end
-
-