hawkular-client 2.2.1 → 2.3.0

data/spec/integration/inventory_spec.rb

@@ -4,28 +4,46 @@ 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 } do
+  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
+      mock_inventory_client(VERSION) unless ENV['VCR_UPDATE'] == '1'
+      options = { tenant: 'hawkular' }
       client = Hawkular::Inventory::InventoryClient.create(entrypoint: ENTRYPOINT,
-                                                           credentials: creds)
-
+                                                           credentials: creds,
+                                                           options: options)
       tenant = client.get_tenant(creds)
-
-      expect(tenant).to eq('28026b36-8fe4-4332-84c8-524e173a68bf')
+      expect(tenant).to eq('hawkular')
     end
 
     it 'Should Get Tenant For Implicit Credentials' do
       creds = { username: 'jdoe', password: 'password' }
-      mock_inventory_client
-      client = Hawkular::Inventory::InventoryClient.create(entrypoint: ENTRYPOINT, credentials: creds)
-
-      tenant = client.get_tenant
+      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
 
-      expect(tenant).to eq('28026b36-8fe4-4332-84c8-524e173a68bf')
+  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
 
@@ -37,13 +55,30 @@ module Hawkular::Inventory::RSpec
         username: 'jdoe',
         password: 'password'
       }
-      ::RSpec::Mocks.with_temporary_scope do
-        mock_inventory_client
-        @client = Hawkular::Inventory::InventoryClient.create(entrypoint: ENTRYPOINT, credentials: @creds)
-      end
+
       options = { decode_compressed_response: true }
       options[:record] = :all if ENV['VCR_UPDATE'] == '1'
-      VCR.use_cassette('Inventory/Helpers/get_feeds', options) do
+      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
+
+      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]
@@ -51,10 +86,13 @@ module Hawkular::Inventory::RSpec
       end
 
       # create 1 URL resource and its metrics
-      VCR.use_cassette('Inventory/Helpers/create_url', options) do
+      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]
+                                               password: @creds[:password],
+                                               headers: headers
                                               )
         url_json = {
           url: URL_RESOURCE
@@ -73,7 +111,8 @@ module Hawkular::Inventory::RSpec
 
     after(:all) do
       require 'fileutils'
-      FileUtils.rm_rf "#{VCR.configuration.cassette_library_dir}/Inventory/tmp"
+      x, y, = @client.version
+      FileUtils.rm_rf "#{VCR.configuration.cassette_library_dir}/Inventory/inventory#{x}_#{y}/tmp"
     end
 
     let(:cassette_name) do |example|
@@ -90,13 +129,14 @@ module Hawkular::Inventory::RSpec
     end
 
     around(:each) do |example|
-      record('Inventory', @state, cassette_name, example: example)
+      major, minor, = @client.version
+      record("Inventory/inventory_#{major}_#{minor}", @state, cassette_name, example: example)
     end
 
     it 'Should list feeds' do
       feeds = @client.list_feeds
 
-      expect(feeds.size).to be(1)
+      expect(feeds.size).to be > 0
     end
 
     it 'Should list resources for feed' do
@@ -112,10 +152,12 @@ module Hawkular::Inventory::RSpec
       creds = { username: @state[:super_secret_username],
                 password: @state[:super_secret_password] }
       tori_url = 'https://hawkular.torii.gva.redhat.com/hawkular/inventory'
-      mock_inventory_client
+      mock_inventory_client(VERSION)
       client = Hawkular::Inventory::InventoryClient.create(entrypoint: tori_url,
                                                            credentials: creds,
-                                                           options: { verify_ssl: OpenSSL::SSL::VERIFY_NONE })
+                                                           options: { tenant: 'hawkular',
+                                                                      verify_ssl: OpenSSL::SSL::VERIFY_NONE
+                                                           })
       feeds = client.list_feeds
 
       expect(feeds.size).to be(1)
@@ -123,13 +165,14 @@ module Hawkular::Inventory::RSpec
 
     it 'Should list all the resource types' do
       types = @client.list_resource_types
-      expect(types.size).to be(19)
+      # new API returns only the feedless types here, while the old one returned all the types
+      expect(types.size).to be > 0
     end
 
     it 'Should list types with feed' do
       types = @client.list_resource_types(feed_id)
 
-      expect(types.size).to be(18)
+      expect(types.size).to be >= 18
     end
 
     it 'Should list types with bad feed' do
@@ -144,8 +187,6 @@ module Hawkular::Inventory::RSpec
       resources = @client.list_resources_for_type(wildfly_type.to_s)
 
       expect(resources.size).to be(1)
-      wf = resources.first
-      expect(wf.properties.size).to be(0)
     end
 
     it 'Should list WildFlys with props' do
@@ -160,9 +201,7 @@ module Hawkular::Inventory::RSpec
       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(resources.size).to be(2)
-      wf = resources.first
-      expect(wf.properties.size).to be(0) # They have no props
+      expect(resources.size).to be > 0
     end
 
     it 'Should list URLs' do
@@ -192,7 +231,7 @@ module Hawkular::Inventory::RSpec
 
       children = @client.list_child_resources(wild_fly.path)
 
-      expect(children.size).to be(22)
+      expect(children.size).to be > 10
     end
 
     it 'Should list children of nested resource' do
@@ -200,8 +239,8 @@ module Hawkular::Inventory::RSpec
       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)
-      expect(datasource.name).to eq('ExampleDS')
 
+      expect(datasource.name).to eq('Datasource [ExampleDS]')
       children = @client.list_child_resources(datasource.path)
 
       expect(children.size).to be(0)
@@ -213,7 +252,7 @@ module Hawkular::Inventory::RSpec
 
       children = @client.list_child_resources(wild_fly.path, recursive: true)
 
-      expect(children.size).to be(251)
+      expect(children.size).to be > 40
     end
 
     it 'Should list relationships of WildFly' do
@@ -222,7 +261,8 @@ module Hawkular::Inventory::RSpec
 
       rels = @client.list_relationships(wild_fly.path)
 
-      expect(rels.size).to be(61)
+      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
@@ -243,7 +283,7 @@ module Hawkular::Inventory::RSpec
       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)
 
-      expect(metrics.size).to be(7)
+      expect(metrics.size).to be >= 4
     end
 
     it 'Should list metrics of given resource type' do
@@ -257,7 +297,7 @@ module Hawkular::Inventory::RSpec
       config = @client.get_config_data_for_resource(resource_path)
 
       expect(config['value']['Server State']).to eq('running')
-      expect(config['value']['Product Name']).to eq('Hawkular')
+      # expect(config['value']['Product Name']).to eq('Hawkular')
     end
 
     it 'Should return config data of given nested resource' do
@@ -279,6 +319,11 @@ module Hawkular::Inventory::RSpec
       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')
     end
 
     it 'Should list operation definitions of given resource' do
@@ -438,7 +483,8 @@ module Hawkular::Inventory::RSpec
         reverse_substitution: true
       }
       vcr_options[:record] = :all if ENV['VCR_UPDATE'] == '1'
-      cassette_name = 'Inventory/Templates/Client_should_listen_on_various_inventory_events'
+      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'
@@ -455,7 +501,9 @@ module Hawkular::Inventory::RSpec
         end
 
         new_resource_types_events = {}
-        resource_type_closable = @client.events('resourcetype') do |resource_type|
+        # 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
 
@@ -468,7 +516,7 @@ module Hawkular::Inventory::RSpec
         resource_type_id = uuid_prefix + '-rt-123'
         resource_type_name = 'ResourceType'
 
-        record('Inventory',
+        record("Inventory/inventory_#{x}_#{y}",
                { uuid_prefix: uuid_prefix },
                'Helpers/generate_some_events_for_websocket') do
           @client.create_feed new_feed_id
@@ -506,10 +554,9 @@ module Hawkular::Inventory::RSpec
       end
     end
 
-    # TODO: enable when inventory supports it
-    # it 'Should return the version' do
-    #   data = @client.get_version_and_status
-    #   expect(data).not_to be_nil
-    # end
+    it 'Should return the version' do
+      data = @client.fetch_version_and_status
+      expect(data).not_to be_nil
+    end
   end
 end

data/spec/integration/metric_spec.rb

@@ -6,492 +6,646 @@ require 'securerandom'
 
 # time constants
 t4h = 4 * 60 * 60 * 1000
+v16_version_string = '0.16.0.Final'
 
-describe 'Simple', :vcr do
-  it 'Should be Cool' do
-    Net::HTTP.get_response(URI('http://localhost:8080/'))
-  end
-end
+# test contexts
+v8_context = :metrics_0_8_0
+services_context = :metrics_services
+v16_context = :metrics_0_16_0
 
-describe 'Tenants', vcr: { match_requests_on: [:uri, :method], record: :none } do
-  before(:all) do
-    setup_client
+[v8_context, services_context, v16_context].each do |metrics_context|
+  if ENV['SKIP_V8_METRICS'] == '1' && metrics_context == v8_context
+    puts 'skipping v8 metrics'
+    next
   end
-
-  it 'Should create and return tenant' do
-    tenant = SecureRandom.uuid
-    @client.tenants.create(tenant)
-    created = @client.tenants.query.select { |t| t.id == tenant }
-    expect(created).not_to be nil
+  if ENV['SKIP_SERVICES_METRICS'] == '1' && metrics_context == services_context
+    puts 'skipping services metrics'
+    next
   end
-end
-
-describe 'No_Tenant' do
-  it 'Should fail' do
-    id = SecureRandom.uuid
 
-    VCR.use_cassette('No_Tenant/Should fail', erb: { id: id }, record: :none) do
-      setup_client
-
-      begin
-        @client.counters.push_data(id, value: 4)
-      rescue # rubocop:disable Lint/HandleExceptions
-        # This is good
+  describe "#{metrics_context}" do
+    let(:cassette_name) do |example|
+      if example.respond_to?(:example_group) && !example.example_group.description.start_with?(metrics_context.to_s)
+        example.example_group.description + '/'
       else
-        fail 'The call should have failed due to missing tenant'
-      end
+        ''
+      end + example.description
     end
-  end
-end
 
-describe 'Mixed metrics' do
-  before(:all) do
-    setup_client_new_tenant
-  end
+    around(:each) do |example|
+      run_for = example.metadata[:run_for]
+      if run_for.nil? || run_for.empty? || run_for.include?(metrics_context)
+        @random_id = SecureRandom.uuid
+        if example.metadata[:skip_auto_vcr]
+          example.run
+        else
+          record("Metrics/#{metrics_context}", { id: @random_id }, cassette_name, example: example)
+        end
+      end
+    end
 
-  it 'Should send mixed metric request of a single type' do
-    id = SecureRandom.uuid
+    after(:all) do
+      require 'fileutils'
+      FileUtils.rm_rf "#{VCR.configuration.cassette_library_dir}/Metrics/#{metrics_context}/tmp"
+    end
 
-    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
+    describe 'Simple' do
+      it 'Should be Cool' do
+        url = metrics_context == v8_context ? config['url_v8'] : config['url']
+        Net::HTTP.get_response(URI(url))
+      end
+    end
 
-      @client.push_data(availabilities: [{ id: id, data: [{ value: 'down' }] }])
-      data = @client.avail.get_data(id)
-      expect(data.size).to be 1
+    describe 'Tenants', run_for: [v8_context, services_context, v16_context] do
+      before(:all) do
+        if metrics_context == v8_context
+          setup_v8_client
+        else
+          metrics_context == v16_context ? setup_client(mocked_version: v16_version_string) : setup_client
+        end
+      end
 
-      @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 requests raw data for multiple metrics' do
-    @client = setup_client(username: 'jdoe', password: 'password', tenant: 'vcr-test')
-    ids = [SecureRandom.uuid, SecureRandom.uuid, SecureRandom.uuid]
-    VCR.use_cassette('Mixed_metrics/Should requests raw data for multiple metrics',
-                     erb: { ids: ids }, record: :none
-                    ) do
-      expect(@client.counters.raw_data(ids).size).to be 0
-      expect(@client.gauges.raw_data(ids).size).to be 0
-      expect(@client.avail.raw_data(ids).size).to be 0
-
-      @client.push_data(
-        counters: [
-          { id: ids[0], data: [{ value: 1 }] },
-          { id: ids[1], data: [{ value: 2 }] },
-          { id: ids[2], data: [{ value: 3 }] }
-        ],
-        availabilities: [
-          { id: ids[0], data: [{ value: 'up' }] },
-          { id: ids[1], data: [{ value: 'down' }] },
-          { id: ids[2], data: [{ value: 'up' }] }
-        ],
-        gauges: [
-          { id: ids[0], data: [{ value: 1.1 }] },
-          { id: ids[1], data: [{ value: 2.2 }] },
-          { id: ids[2], data: [{ value: 3.3 }] }
-        ]
-      )
-
-      counter_metrics = @client.counters.raw_data(ids)
-      gauges_metrics = @client.gauges.raw_data(ids)
-      availability_metrics = @client.avail.raw_data(ids)
-
-      expect(counter_metrics.size).to be 3
-      expect(counter_metrics).to include(
-        { 'id' => ids[0], 'data' => [{ 'timestamp' => a_kind_of(Integer), 'value' => 1 }] },
-        { 'id' => ids[1], 'data' => [{ 'timestamp' => a_kind_of(Integer), 'value' => 2 }] },
-        { 'id' => ids[2], 'data' => [{ 'timestamp' => a_kind_of(Integer), 'value' => 3 }] }
-      )
-
-      expect(gauges_metrics.size).to be 3
-      expect(gauges_metrics).to include(
-        { 'id' => ids[0], 'data' => [{ 'timestamp' => a_kind_of(Integer), 'value' => 1.1 }] },
-        { 'id' => ids[1], 'data' => [{ 'timestamp' => a_kind_of(Integer), 'value' => 2.2 }] },
-        { 'id' => ids[2], 'data' => [{ 'timestamp' => a_kind_of(Integer), 'value' => 3.3 }] }
-      )
-
-      expect(availability_metrics.size).to be 3
-      expect(availability_metrics).to include(
-        { 'id' => ids[0], 'data' => [{ 'timestamp' => a_kind_of(Integer), 'value' => 'up' }] },
-        { 'id' => ids[1], 'data' => [{ 'timestamp' => a_kind_of(Integer), 'value' => 'down' }] },
-        { 'id' => ids[2], 'data' => [{ 'timestamp' => a_kind_of(Integer), 'value' => 'up' }] }
-      )
+      it 'Should create and return tenant' do
+        tenant = @random_id
+        @client.tenants.create(tenant)
+        created = @client.tenants.query.select { |t| t.id == tenant }
+        expect(created).not_to be nil
+      end
     end
-  end
 
-  it 'Should send mixed metric request' do
-    id = SecureRandom.uuid
-    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
+    describe 'No Tenant', run_for: [services_context, v16_context] do
+      it 'Should fail' do
+        setup_client_without_tenant
+        begin
+          @client.counters.push_data(@random_id, value: 4)
+        rescue # rubocop:disable Lint/HandleExceptions
+          # This is good
+        else
+          fail 'The call should have failed due to missing tenant'
+        end
+      end
     end
-  end
-end
 
-describe 'Counter metrics' do
-  before(:all) do
-    setup_client_new_tenant
-  end
+    describe 'Mixed metrics', run_for: [v8_context, services_context, v16_context] do
+      before(:all) do
+        if metrics_context == v8_context
+          setup_v8_client tenant: 'vcr-test-tenant-123'
+        else
+          if metrics_context == v16_context
+            setup_client_new_tenant(mocked_version: v16_version_string)
+          else
+            setup_client_new_tenant
+          end
+        end
+      end
 
-  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, @tenant
-    end
-  end
+      it 'Should requests raw data for multiple metrics', :skip_auto_vcr, run_for: [services_context, v16_context] do
+        id1 = SecureRandom.uuid
+        id2 = SecureRandom.uuid
+        id3 = SecureRandom.uuid
+
+        ids = [id1, id2, id3]
+        bindings = { id1: id1, id2: id2, id3: id3 }
+        example = proc do
+          if (metrics_context == v16_context)
+            @client = setup_client(username: 'jdoe', password: 'password', tenant: 'vcr-test',
+                                   mocked_version: v16_version_string)
+          else
+            @client = setup_client(username: 'jdoe', password: 'password', tenant: 'vcr-test')
+          end
+
+          expect(@client.counters.raw_data(ids).size).to be 0
+          expect(@client.gauges.raw_data(ids).size).to be 0
+          expect(@client.avail.raw_data(ids).size).to be 0
+
+          @client.push_data(
+            counters: [
+              { id: id1, data: [{ value: 1 }] },
+              { id: id2, data: [{ value: 2 }] },
+              { id: id3, data: [{ value: 3 }] }
+            ],
+            availabilities: [
+              { id: id1, data: [{ value: 'up' }] },
+              { id: id2, data: [{ value: 'down' }] },
+              { id: id3, data: [{ value: 'up' }] }
+            ],
+            gauges: [
+              { id: id1, data: [{ value: 1.1 }] },
+              { id: id2, data: [{ value: 2.2 }] },
+              { id: id3, data: [{ value: 3.3 }] }
+            ]
+          )
+
+          c_metrics = @client.counters.raw_data(ids)
+          g_metrics = @client.gauges.raw_data(ids)
+          a_metrics = @client.avail.raw_data(ids)
+
+          expect(c_metrics.size).to be 3
+          expect(c_metrics).to include(
+            { 'id' => id1, 'data' => [{ 'timestamp' => a_kind_of(Integer), 'value' => 1 }] },
+            { 'id' => id2, 'data' => [{ 'timestamp' => a_kind_of(Integer), 'value' => 2 }] },
+            { 'id' => id3, 'data' => [{ 'timestamp' => a_kind_of(Integer), 'value' => 3 }] }
+          )
+
+          expect(g_metrics.size).to be 3
+          expect(g_metrics).to include(
+            { 'id' => id1, 'data' => [{ 'timestamp' => a_kind_of(Integer), 'value' => 1.1 }] },
+            { 'id' => id2, 'data' => [{ 'timestamp' => a_kind_of(Integer), 'value' => 2.2 }] },
+            { 'id' => id3, 'data' => [{ 'timestamp' => a_kind_of(Integer), 'value' => 3.3 }] }
+          )
+
+          expect(a_metrics.size).to be 3
+          expect(a_metrics).to include(
+            { 'id' => id1, 'data' => [{ 'timestamp' => a_kind_of(Integer), 'value' => 'up' }] },
+            { 'id' => id2, 'data' => [{ 'timestamp' => a_kind_of(Integer), 'value' => 'down' }] },
+            { 'id' => id3, 'data' => [{ 'timestamp' => a_kind_of(Integer), 'value' => 'up' }] }
+          )
+        end
+
+        record("Metrics/#{metrics_context}", bindings, cassette_name, example: example)
+      end
 
-  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 send mixed metric request of a single type' do
+        @client.push_data(counters: [{ id: @random_id, data: [{ value: 1 }] }])
+        data = @client.counters.get_data(@random_id)
+        expect(data.size).to be 1
 
-  it 'Should push metric data to existing counter' do
-    id = SecureRandom.uuid
-    now = @client.now
-
-    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
+        @client.push_data(availabilities: [{ id: @random_id, data: [{ value: 'down' }] }])
+        data = @client.avail.get_data(@random_id)
+        expect(data.size).to be 1
 
-  it 'Should get metrics with limit and order' do
-    @client = setup_client(username: 'jdoe', password: 'password')
-    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),
-                            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
-      @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 with limit
-      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)
-      expect(data.empty?).to be true
-    end
-  end
+        @client.push_data(gauges: [{ id: @random_id, data: [{ value: 1.1 }] }])
+        data = @client.gauges.get_data(@random_id)
+        expect(data.size).to be 1
+      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 send mixed metric request' do
+        expect(@client.counters.get_data(@random_id).size).to be 0
+        expect(@client.gauges.get_data(@random_id).size).to be 0
+        expect(@client.avail.get_data(@random_id).size).to be 0
 
-  it 'Should push metric data to non-existing counter' do
-    id = SecureRandom.uuid
+        @client.push_data(
+          counters: [{ id: @random_id, data: [{ value: 1 }] }],
+          availabilities: [{ id: @random_id, data: [{ value: 'down' }] }],
+          gauges: [{ id: @random_id, data: [{ value: 1.1 }] }]
+        )
 
-    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
+        expect(@client.counters.get_data(@random_id).size).to be 1
+        expect(@client.gauges.get_data(@random_id).size).to be 1
+        expect(@client.avail.get_data(@random_id).size).to be 1
+      end
     end
-  end
-end
 
-describe 'Availability metrics' do
-  before(:all) do
-    setup_client_new_tenant
-  end
+    describe 'Counter metrics' do
+      before(:all) do
+        @tenant = 'vcr-test-tenant-123'
+        if metrics_context == v8_context
+          setup_v8_client tenant: @tenant
+        else
+          if metrics_context == v16_context
+            setup_client_new_tenant(mocked_version: v16_version_string)
+          else
+            setup_client_new_tenant
+          end
+        end
+      end
 
-  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, @tenant
-    end
-  end
+      it 'Should create and return counter using Hash parameter' do
+        create_metric_using_hash @client.counters, @random_id, @tenant
+      end
 
-  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 create counter definition using MetricDefinition parameter' do
+        create_metric_using_md @client.counters, @random_id
+      end
+
+      it 'Should push metric data to existing counter', :skip_auto_vcr do
+        now = @client.now
+        minus10 = now - 10
+        minus20 = now - 20
+        minus30 = now - 30
+        minus8h = now - (2 * t4h)
+        minus4h = now - t4h
+
+        bindings = { id: @random_id, minus10: minus10, minus20: minus20, minus30: minus30,
+                     minus8h: minus8h, minus4h: minus4h }
+        example = proc do
+          # create counter
+          @client.counters.create(id: @random_id)
+
+          # push 3  values with timestamps
+          @client.counters.push_data(@random_id, [{ value: 1, timestamp: minus30 },
+                                                  { value: 2, timestamp: minus20 },
+                                                  { value: 3, timestamp: minus10 }])
+
+          data = @client.counters.get_data(@random_id)
+          expect(data.size).to be 3
+
+          # push one value without timestamp (which means now)
+          @client.counters.push_data(@random_id, value: 4)
+          data = @client.counters.get_data(@random_id)
+          expect(data.size).to be 4
+
+          # retrieve values from past
+          data = @client.counters.get_data(@random_id, starts: minus8h, ends: minus4h)
+          expect(data.empty?).to be true
+        end
+        record("Metrics/#{metrics_context}", bindings, cassette_name, example: example)
+      end
 
-  it 'Should push metric data to non-existing Availability' do
-    id = SecureRandom.uuid
+      # limit and order were introduced in 0.11.0 => skipping for 0.8.0
+      it 'Should get metrics with limit and order', run_for: [services_context, v16_context], skip_auto_vcr: true do
+        now = @client.now
+        minus10 = now - 10
+        minus20 = now - 20
+        minus30 = now - 30
+        minus8h = now - (2 * t4h)
+        minus4h = now - t4h
+        bindings = { id: @random_id, minus10: minus10, minus20: minus20, minus30: minus30,
+                     minus8h: minus8h, minus4h: minus4h }
+
+        example = proc do
+          # create counter
+          @client.counters.create(id: @random_id)
+
+          # push 3 values with timestamps
+          @client.counters.push_data(@random_id, [{ value: 1, timestamp: minus30 },
+                                                  { value: 2, timestamp: minus20 },
+                                                  { value: 3, timestamp: minus10 }])
+
+          data = @client.counters.get_data(@random_id)
+          expect(data.size).to be 3
+
+          # push one value without timestamp (which means now)
+          @client.counters.push_data(@random_id, value: 4)
+          data = @client.counters.get_data(@random_id)
+          expect(data.size).to be 4
+
+          # retrieve values with limit
+          data = @client.counters.get_data(@random_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(@random_id, starts: minus8h, ends: minus4h)
+          expect(data.empty?).to be true
+        end
+        record("Metrics/#{metrics_context}", bindings, cassette_name, example: example)
+      end
+
+      it 'Should get metrics as bucketed results', :skip_auto_vcr do
+        now = @client.now
+        minus5 = now - 5
+        minus10 = now - 10
+        minus20 = now - 20
+        minus30 = now - 30
+        minus40 = now - 40
+        minus50 = now - 50
+        minus60 = now - 60
+        minus70 = now - 70
+        minus80 = now - 80
+        minus90 = now - 90
+        minus100 = now - 100
+        minus105 = now - 105
+        minus110 = now - 110
+        bindings = { id: @random_id, minus5: minus5, minus10: minus10, minus20: minus20, minus30: minus30,
+                     minus40: minus40, minus50: minus50, minus60: minus60, minus70: minus70, minus80: minus80,
+                     minus90: minus90, minus100: minus100, minus105: minus105, minus110: minus110 }
+        example = proc do
+          # create counter
+          @client.counters.create(id: @random_id)
+
+          # push 10 values with timestamps
+          @client.counters.push_data(@random_id, [{ value: 110, timestamp: minus110 },
+                                                  { value: 100, timestamp: minus100 },
+                                                  { value: 90, timestamp: minus90 },
+                                                  { value: 80, timestamp: minus80 },
+                                                  { value: 70, timestamp: minus70 },
+                                                  { value: 60, timestamp: minus60 },
+                                                  { value: 50, timestamp: minus50 },
+                                                  { value: 40, timestamp: minus40 },
+                                                  { value: 30, timestamp: minus30 },
+                                                  { value: 20, timestamp: minus20 },
+                                                  { value: 10, timestamp: minus10 }])
+          err = 0.001
+          data = @client.counters.get_data(@random_id, starts: minus105, ends: minus5, 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(@random_id, starts: minus105, ends: minus5, 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(@random_id, starts: minus105, ends: minus5, bucketDuration: '50ms')
+          expect(data.size).to be 2
+          expect(data.first['avg']).to be_within(err).of(80.0)
+        end
+        record("Metrics/#{metrics_context}", bindings, cassette_name, example: example)
+      end
 
-    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
+      it 'Should push metric data to non-existing counter' do
+        push_data_to_non_existing_metric @client.counters, { value: 4 }, @random_id
+      end
     end
-  end
 
-  it 'Should update tags for Availability definition' do
-    id = SecureRandom.uuid
+    describe 'Availability metrics' do
+      before(:all) do
+        @tenant = 'vcr-test-tenant-123'
+        if metrics_context == v8_context
+          setup_v8_client tenant: @tenant
+        else
+          if metrics_context == v16_context
+            setup_client_new_tenant(mocked_version: v16_version_string)
+          else
+            setup_client_new_tenant
+          end
+        end
+      end
+
+      it 'Should create and return Availability using Hash parameter' do
+        create_metric_using_hash @client.avail, @random_id, @tenant
+      end
+
+      it 'Should create Availability definition using MetricDefinition parameter' do
+        create_metric_using_md @client.avail, @random_id
+      end
 
-    VCR.use_cassette('Availability_metrics/Should update tags for Availability definition',
-                     erb: { id: id }, record: :none
-                    ) do
-      update_metric_by_tags @client.avail, id
+      it 'Should push metric data to non-existing Availability' do
+        push_data_to_non_existing_metric @client.avail, { value: 'UP' }, @random_id
+      end
+
+      it 'Should update tags for Availability definition' do
+        update_metric_by_tags @client.avail, @random_id
+      end
+
+      it 'Should raise ArgumentError, availability does not accept percentiles param' do
+        expect { @client.avail.get_data(@random_id, percentiles: 50) }.to raise_error(ArgumentError)
+      end
+
+      it 'Should group contiguous values', :skip_auto_vcr, run_for: [services_context, v16_context] do
+        now = @client.now
+        minus10 = now - 10
+        minus20 = now - 20
+        minus30 = now - 30
+        minus40 = now - 40
+        minus50 = now - 50
+        bindings = { id: @random_id, minus10: minus10, minus20: minus20, minus30: minus30, minus40: minus40,
+                     minus50: minus50, now: now }
+        example = proc do
+          if (metrics_context == v16_context)
+            @client = setup_client(username: 'jdoe', password: 'password', tenant: 'vcr-test',
+                                   mocked_version: v16_version_string)
+          else
+            @client = setup_client(username: 'jdoe', password: 'password', tenant: 'vcr-test')
+          end
+          @client.avail.push_data(@random_id, [
+            { timestamp: minus50, value: 'up' },
+            { timestamp: minus40, value: 'up' },
+            { timestamp: minus30, value: 'down' },
+            { timestamp: minus20, value: 'down' },
+            { timestamp: minus10, value: 'down' },
+            { timestamp: now, value: 'up' }
+          ])
+          result = @client.avail.get_data(@random_id, distinct: true, order: 'ASC')
+          expect(result).to eq([
+            { 'timestamp' => minus50, 'value' => 'up' },
+            { 'timestamp' => minus30, 'value' => 'down' },
+            { 'timestamp' => now, 'value' => 'up' }
+          ])
+        end
+
+        record("Metrics/#{metrics_context}", bindings, cassette_name, example: example)
+      end
     end
-  end
 
-  it 'Should raise ArgumentError, availability does not accept percentiles param' do
-    expect { @client.avail.get_data(SecureRandom.uuid, percentiles: 50) }.to raise_error(ArgumentError)
-  end
+    describe 'Gauge metrics' do
+      before(:all) do
+        @tenant = 'vcr-test-tenant-123'
+        if metrics_context == v8_context
+          setup_v8_client tenant: @tenant
+        else
+          if metrics_context == v16_context
+            setup_client_new_tenant(mocked_version: v16_version_string)
+          else
+            setup_client_new_tenant
+          end
+        end
+      end
 
-  it 'Should group contiguous values' do
-    id = SecureRandom.uuid
-    now = @client.now
-    setup_client(username: 'jdoe', password: 'password', tenant: 'vcr-test')
-    VCR.use_cassette('Availability_metrics/Should group contiguous values',
-                     erb: { id: id, now: now }, record: :none
-                    ) do
-      @client.avail.push_data(id, [
-        { timestamp: now - 50, value: 'up' },
-        { timestamp: now - 40, value: 'up' },
-        { timestamp: now - 30, value: 'down' },
-        { timestamp: now - 20, value: 'down' },
-        { timestamp: now - 10, value: 'down' },
-        { timestamp: now, value: 'up' }
-      ])
-      expect(@client.avail.get_data(id, distinct: true, order: 'ASC')).to eq([
-        { 'timestamp' => now - 50, 'value' => 'up' },
-        { 'timestamp' => now - 30, 'value' => 'down' },
-        { 'timestamp' => now, 'value' => 'up' }
-      ])
+      it 'Should create gauge definition using MetricDefinition' do
+        create_metric_using_md @client.gauges, @random_id
+      end
+
+      it 'Should create gauge definition using Hash' do
+        create_metric_using_hash @client.gauges, @random_id, @tenant
+      end
+
+      it 'Should push metric data to non-existing gauge' do
+        push_data_to_non_existing_metric @client.gauges, { value: 3.1415926 }, @random_id
+      end
+
+      # let's do the recording manually
+      it 'Should push metric data to existing gauge', :skip_auto_vcr do
+        now = @client.now
+        ends = now - t4h
+        starts = now - (2 * t4h)
+        now10 = now - 10
+        now20 = now - 20
+        now30 = now - 30
+        bindings = { id: @random_id, ends: ends, starts: starts, now10: now10, now20: now20, now30: now30 }
+        example = proc do
+          # create gauge
+          @client.gauges.create(id: @random_id)
+
+          # push 3  values with timestamps
+          @client.gauges.push_data(@random_id,
+                                   [{ value: 1, timestamp: now30 },
+                                    { value: 2, timestamp: now20 },
+                                    { value: 3, timestamp: now10 }])
+
+          data = @client.gauges.get_data(@random_id)
+          expect(data.size).to be 3
+
+          # push one value without timestamp (which means now)
+          @client.gauges.push_data(@random_id, value: 4)
+          data = @client.gauges.get_data(@random_id)
+          expect(data.size).to be 4
+
+          # retrieve values from past
+          data = @client.counters.get_data(@random_id, starts: starts, ends: ends)
+          expect(data.empty?).to be true
+        end
+        record("Metrics/#{metrics_context}", bindings, cassette_name, example: example)
+      end
+
+      it 'Should update tags for gauge definition' do
+        update_metric_by_tags @client.gauges, @random_id
+      end
+
+      it 'Should return periods', :skip_auto_vcr do
+        now = @client.now
+        before4h = now - t4h
+        minus20 = now - 20
+        minus30 = now - 30
+        bindings = { id: @random_id, start: now, before4h: before4h, minus20: minus20, minus30: minus30 }
+        example = proc do
+          # push 3  values with timestamps
+          @client.gauges.push_data(@random_id, [{ value: 1, timestamp: minus30 },
+                                                { value: 2, timestamp: minus20 },
+                                                { value: 3, timestamp: now }])
+
+          data = @client.gauges.get_periods(@random_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
+        record("Metrics/#{metrics_context}", bindings, cassette_name, example: example)
+      end
+
+      it 'Should return platform memory def', :skip_auto_vcr, run_for: [services_context] do
+        # this id depends on OS and the feed id
+        feed = 'b37ba088-6bfa-4877-83af-b3747696bfb1'
+        mem_id = "MI~R~[#{feed}/platform~/OPERATING_SYSTEM=#{feed}_OperatingSystem/MEMORY=Memory]~MT~Total Memory"
+
+        bindings = { id: @random_id, mem_id: mem_id }
+        example = proc do
+          tenant_id = 'hawkular'
+          if metrics_context == v8_context
+            setup_v8_client tenant: tenant_id
+          else
+            setup_client tenant: tenant_id
+          end
+
+          data = @client.gauges.get(mem_id)
+
+          expect(data).not_to be_nil
+          expect(data.id).not_to be_nil
+          expect(data.tenant_id).to eq(tenant_id)
+        end
+        record("Metrics/#{metrics_context}", bindings, cassette_name, example: example)
+      end
+
+      it 'Should return platform memory', :skip_auto_vcr, run_for: [services_context] do
+        # this id depends on OS and the feed id
+        feed = 'b37ba088-6bfa-4877-83af-b3747696bfb1'
+        mem_id = "MI~R~[#{feed}/platform~/OPERATING_SYSTEM=#{feed}_OperatingSystem/MEMORY=Memory]~MT~Total Memory"
+
+        bindings = { id: @random_id, mem_id: mem_id }
+        example = proc do
+          tenant_id = 'hawkular'
+          if metrics_context == v8_context
+            setup_v8_client tenant: tenant_id
+          else
+            setup_client tenant: tenant_id
+          end
+
+          data = @client.gauges.get_data(mem_id)
+          expect(data.size).to be > 2 # needs the services to be running for more than 2 minutes
+        end
+        record("Metrics/#{metrics_context}", bindings, cassette_name, example: example)
+      end
+    end
+
+    it 'Status/Should return the version' do
+      if metrics_context == v8_context
+        setup_v8_client
+      else
+        setup_client
+      end
+      data = @client.fetch_version_and_status
+      expect(data).not_to be_nil
     end
   end
 end
 
-describe 'Gauge metrics' do
+describe 'Metric ID with special characters' do
   before(:all) do
-    setup_client_new_tenant
+    setup_client(username: 'jdoe', password: 'password', tenant: 'vcr-test')
   end
 
-  it 'Should create gauge definition using MetricDefinition' do
-    id = SecureRandom.uuid
+  id_gauge = 'MI~R~[8b*}{\'\\14#?/5-7%92e[-c9_.r1//;/74eddf/L=c~~]~MT~    *  / Met@ics~Aggre&? ated s  Active" Ses;ns'
+  id_avail = 'AA~R~[8b*}{\'\\14#?/5-7%92[d-c9_.r1///7;:4eddf/L=c~~]~MT~ A  *  %-Met@ics~Aggre&?ated " Sess{ons'
+  id_counter = 'AA~R~[8b*}{\'\\14#?/5-7%92[d-c9_.r1///7;:4eddf/L=c~~]~MT~  %-Met@ics~Aggre&?ated " Sess{ons'
 
-    VCR.use_cassette('Gauge_metrics/Should create gauge definition using MetricDefinition',
-                     erb: { id: id }, record: :none
-                    ) do
-      create_metric_using_md @client.gauges, id
+  it 'Should create gauge definition' do
+    VCR.use_cassette('Metric ID with special characters/Should create gauge definition') do
+      create_metric_using_md @client.gauges, id_gauge
     end
   end
 
-  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, @tenant
+  it 'Should create Availability definition' do
+    VCR.use_cassette('Metric ID with special characters/Should create Availability definition') do
+      create_metric_using_md @client.avail, id_avail
     end
   end
 
-  it 'Should push metric data to non-existing gauge' do
-    id = SecureRandom.uuid
-
-    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
+  it 'Should create Counter definition' do
+    VCR.use_cassette('Metric ID with special characters/Should create Counter definition') do
+      create_metric_using_md @client.counters, id_counter
     end
   end
 
   it 'Should push metric data to existing gauge' do
-    id = SecureRandom.uuid
-    now = @client.now
-
-    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
+    VCR.use_cassette('Metric ID with special characters/Should push metric data to existing gauge') do
+      @client.gauges.push_data(id_gauge, [
+        { value: 0.1,  tags: { tagName: 'myMin' } },
+        { value: 99.9, tags: { tagName: 'myMax' } }
+      ])
     end
   end
 
   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
-    id = SecureRandom.uuid
-    now = @client.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)
+    VCR.use_cassette('Metric ID with special characters/Should update tags for gauge definition') do
+      deff = @client.gauges.get(id_gauge)
+      deff.tags = {
+        name1: 'value1',
+        name2: 'value2',
+        name3: 'value3'
+      }
+      @client.gauges.update_tags(deff)
+      deff_updated = @client.gauges.get(id_gauge)
+      expected_result = {
+        'name1' => 'value1',
+        'name2' => 'value2',
+        'name3' => 'value3',
+        'tag'   => 'value'
+      }
+      expect(deff_updated.tags).to eq(expected_result)
     end
   end
 
-  it 'Should return platform memory def' do
-    tenant_id = '28026b36-8fe4-4332-84c8-524e173a68bf'
-    setup_client tenant: tenant_id
-
-    VCR.use_cassette('Gauge_metrics/Platform mem def') do
-      # The next id is not a real one, but shortened for rubocpo
-      mem_id = 'MI~R~[snert~platform~/OP_SYSTEM=Apple (Capitan) 42/MEMORY=Mem]~MT~Total Memory'
-      data = @client.gauges.get(mem_id)
-
-      expect(data).not_to be_nil
-      expect(data.id).not_to be_nil
-      expect(data.tenant_id).to eq(tenant_id)
+  it 'Should update tags for Availability definition' do
+    VCR.use_cassette('Metric ID with special characters/Should update tags for Availability definition') do
+      deff_avail = @client.avail.get(id_avail)
+      deff_avail.tags = {
+        name1: 'value1',
+        name2: 'value2',
+        name3: 'value3'
+      }
+      @client.avail.update_tags(deff_avail)
+      deff_avail_updated = @client.avail.get(id_avail)
+      expected_result = {
+        'name1' => 'value1',
+        'name2' => 'value2',
+        'name3' => 'value3',
+        'tag'   => 'value'
+      }
+      expect(deff_avail_updated.tags).to eq(expected_result)
     end
   end
 
-  it 'Should return platform memory' do
-    setup_client tenant: '28026b36-8fe4-4332-84c8-524e173a68bf'
-
-    VCR.use_cassette('Gauge_metrics/Platform mem') do
-      # The next id is not a real one, but shortened for rubocpo
-      mem_id = 'MI~R~[snert~platform~/OP_SYSTEM=Apple (Capitan) 42/MEMORY=Mem]~MT~Total Memory'
-      data = @client.gauges.get_data(mem_id)
-      expect(data.size).to be 71
+  it 'Get metric definition by id' do
+    VCR.use_cassette('Metric ID with special characters/Get metric definition by id') do
+      @client.gauges.get(id_gauge)
     end
   end
 
-  it 'Should return the version' do
-    VCR.use_cassette('Metrics/Status') do
-      data = @client.fetch_version_and_status
-      expect(data).not_to be_nil
+  it 'Retrieve metric rate points' do
+    VCR.use_cassette('Metric ID with special characters/Retrieve metric rate points') do
+      @client.gauges.get(id_gauge)
+      @client.counters.get_rate id_counter
     end
   end
 end