dogapi 1.22.0 → 1.23.0

data/spec/integration/service_check_spec.rb

@@ -0,0 +1,12 @@
+require_relative '../spec_helper'
+
+describe Dogapi::Client do
+  SC_BODY = { check: 'app.is_ok', host_name: 'app1', status: 0 }.freeze
+  SC_ARGS = SC_BODY.values
+
+  describe '#service_check' do
+    it_behaves_like 'an api method with options',
+                    :service_check, SC_ARGS,
+                    :post, '/check_run', SC_BODY
+  end
+end

data/spec/integration/snapshot_spec.rb

@@ -0,0 +1,24 @@
+require_relative '../spec_helper'
+
+describe Dogapi::Client do
+  SNAP_QUERY = 'system.load.1{*}'.freeze
+  START_TS = Time.now.to_i
+  END_TS = START_TS + 10
+  EVENT_QUERY = 'hotfixes'.freeze
+
+  PARAMS = { metric_query: SNAP_QUERY, start: START_TS, end: END_TS }.freeze
+  EXTENDED_PARAMS = PARAMS.merge(event_query: EVENT_QUERY)
+
+  describe '#snapshot' do
+    context 'when creating a simple graph' do
+      it_behaves_like 'an api method with params',
+                      :graph_snapshot, [],
+                      :get, '/graph/snapshot', PARAMS
+    end
+    context 'when adding an event overlay' do
+      it_behaves_like 'an api method with params',
+                      :graph_snapshot, [],
+                      :get, '/graph/snapshot', EXTENDED_PARAMS
+    end
+  end
+end

data/spec/integration/tag_spec.rb

@@ -0,0 +1,66 @@
+require_relative '../spec_helper'
+
+describe Dogapi::Client do
+  HOST_NAME = 'test.example.com'.freeze
+  SOURCE = 'chef_custom'.freeze
+  TAGS = ['role:web', 'environment:test'].freeze
+
+  describe '#add_tags' do
+    context 'whithout precising the source' do
+      it_behaves_like 'an api method',
+                      :add_tags, [HOST_NAME, TAGS],
+                      :post, "/tags/hosts/#{HOST_NAME}", tags: TAGS
+    end
+    context 'while precising the source' do
+      it_behaves_like 'an api method with params',
+                      :add_tags, [HOST_NAME, TAGS],
+                      :post, "/tags/hosts/#{HOST_NAME}", source: SOURCE
+    end
+  end
+
+  describe '#update_tags' do
+    context 'whithout precising the source' do
+      it_behaves_like 'an api method',
+                      :update_tags, [HOST_NAME, TAGS],
+                      :put, "/tags/hosts/#{HOST_NAME}", tags: TAGS
+    end
+    context 'while precising the source' do
+      it_behaves_like 'an api method with params',
+                      :update_tags, [HOST_NAME, TAGS],
+                      :put, "/tags/hosts/#{HOST_NAME}", source: SOURCE
+    end
+  end
+
+  describe '#host_tags' do
+    context 'whithout precising the source' do
+      it_behaves_like 'an api method',
+                      :host_tags, [HOST_NAME],
+                      :get, "/tags/hosts/#{HOST_NAME}"
+    end
+    context 'while precising the source' do
+      it_behaves_like 'an api method with params',
+                      :host_tags, [HOST_NAME],
+                      :get, "/tags/hosts/#{HOST_NAME}", source: SOURCE, by_source: true
+    end
+  end
+
+  describe '#detach_tags' do
+    context 'whithout precising the source' do
+      it_behaves_like 'an api method',
+                      :detach_tags, [HOST_NAME],
+                      :delete, "/tags/hosts/#{HOST_NAME}"
+    end
+
+    context 'while precising the source' do
+      it_behaves_like 'an api method with params',
+                      :detach_tags, [HOST_NAME],
+                      :delete, "/tags/hosts/#{HOST_NAME}", source: SOURCE
+    end
+  end
+
+  describe '#all_tags' do
+    it_behaves_like 'an api method',
+                    :all_tags, [],
+                    :get, '/tags/hosts'
+  end
+end

data/spec/integration/user_spec.rb

@@ -0,0 +1,46 @@
+require_relative '../spec_helper'
+
+describe Dogapi::Client do
+  USER_HANDLE = 'test@example.com'.freeze
+  USER_DESCRIPTION = {
+    handle: USER_HANDLE,
+    name: 'TEST'
+  }.freeze
+  USER_EMAILS = (1..4).map { |i| "test#{i}@example.com" }
+
+  describe '#invite' do
+    it_behaves_like 'an api method with options',
+                    :invite, [USER_EMAILS],
+                    :post, '/invite_users', 'emails' => USER_EMAILS
+  end
+
+  describe '#create_user' do
+    it_behaves_like 'an api method',
+                    :create_user, [USER_DESCRIPTION],
+                    :post, '/user', USER_DESCRIPTION
+  end
+
+  describe '#get_user' do
+    it_behaves_like 'an api method',
+                    :get_user, [USER_HANDLE],
+                    :get, "/user/#{USER_HANDLE}"
+  end
+
+  describe '#get_all_users' do
+    it_behaves_like 'an api method',
+                    :get_all_users, [],
+                    :get, '/user'
+  end
+
+  describe '#update_user' do
+    it_behaves_like 'an api method',
+                    :update_user, [USER_HANDLE, USER_DESCRIPTION],
+                    :put, "/user/#{USER_HANDLE}", USER_DESCRIPTION
+  end
+
+  describe '#disable_user' do
+    it_behaves_like 'an api method',
+                    :disable_user, [USER_HANDLE],
+                    :delete, "/user/#{USER_HANDLE}"
+  end
+end

data/spec/spec_helper.rb

@@ -1,30 +1,99 @@
 require 'rspec'
-require 'vcr'
+require 'simplecov'
+require 'webmock/rspec'
+
+SimpleCov.start do
+  add_filter 'spec'
+end
+
+WebMock.disable_net_connect!(allow_localhost: false)
 
 # include our code and methods
 require 'dogapi'
 
-# Load any custom matchers
-Dir[File.join(File.dirname(__FILE__), "/support/**/*.rb")].each { |f| require f }
+DATADOG_HOST = 'app.datadoghq.com'.freeze
+ENV['DATADOG_HOST'] = 'http://' + DATADOG_HOST
+
+module SpecDog
+  extend RSpec::SharedContext
+
+  let(:api_key) { 'API_KEY' }
+  let(:app_key) { 'APP_KEY' }
+  let(:dog) { Dogapi::Client.new(api_key, app_key, 'data.dog', nil, false) }
+  let(:api_url) { "#{DATADOG_HOST}/api/v1" }
+  let(:default_query) { { api_key: api_key, application_key: app_key } }
+
+  shared_examples 'an api method' do |command, args, request, endpoint, body|
+    it 'queries the api' do
+      url = api_url + endpoint
+      stub_request(request, /#{url}/).to_return(body: '{}').then.to_raise(StandardError)
+      expect(dog.send(command, *args)).to eq ['200', {}]
+
+      body = MultiJson.dump(body) if body
+
+      expect(WebMock).to have_requested(request, url).with(
+        query: default_query,
+        body: body
+      )
+    end
+  end
+
+  shared_examples 'an api method with options' do |command, args, request, endpoint, body|
+    include_examples 'an api method', command, args, request, endpoint, body
+    it 'queries the api with options' do
+      url = api_url + endpoint
+      options = { 'zzz' => 'aaa' }
+      stub_request(request, /#{url}/).to_return(body: '{}').then.to_raise(StandardError)
+      expect(dog.send(command, *args, options)).to eq ['200', {}]
+
+      body = MultiJson.dump(body ? (body.merge options) : options)
+
+      expect(WebMock).to have_requested(request, url).with(
+        query: default_query,
+        body: body
+      )
+    end
+  end
+
+  shared_examples 'an api method with params' do |command, args, request, endpoint, params|
+    it 'queries the api with params' do
+      url = api_url + endpoint
+      stub_request(request, /#{url}/).to_return(body: '{}').then.to_raise(StandardError)
+      expect(dog.send(command, *args, *params.values)).to eq ['200', {}]
+
+      params.each { |k, v| params[k] = v.join(',') if v.is_a? Array }
+      params = params.merge default_query
+
+      expect(WebMock).to have_requested(request, url).with(
+        query: params
+      )
+    end
+  end
+
+  shared_examples 'an api method with optional params' do |command, args, request, endpoint, opt_params|
+    include_examples 'an api method', command, args, request, endpoint
+    it 'queries the api with optional params' do
+      url = api_url + endpoint
+      stub_request(request, /#{url}/).to_return(body: '{}').then.to_raise(StandardError)
+      expect(dog.send(command, *args, opt_params)).to eq ['200', {}]
+
+      opt_params.each { |k, v| opt_params[k] = v.join(',') if v.is_a? Array }
+      params = opt_params.merge default_query
+
+      expect(WebMock).to have_requested(request, url).with(
+        query: params
+      )
+    end
+  end
+end
 
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
-  config.run_all_when_everything_filtered = true
-  config.filter_run :focus
-
+  # Global let
+  config.include SpecDog
   # Run specs in random order to surface order dependencies. If you find an
   # order dependency and want to debug it, you can fix the order by providing
   # the seed, which is printed after each run.
   #     --seed 1234
   config.order = 'random'
 end
-
-VCR.configure do |c|
-  c.cassette_library_dir = 'spec/support/cassettes'
-  c.configure_rspec_metadata!
-  c.default_cassette_options = { :record => :new_episodes, :re_record_interval => 7776000 } # 90 days, in seconds
-  c.hook_into :webmock
-  c.filter_sensitive_data('<DATADOG_API_KEY>') { ENV["DATADOG_API_KEY"] }
-  c.filter_sensitive_data('<DATADOG_APP_KEY>') { ENV["DATADOG_APP_KEY"] }
-end

data/spec/unit/common_spec.rb

@@ -0,0 +1,101 @@
+require_relative '../spec_helper'
+
+describe 'Common' do
+  context 'Scope' do
+    it 'validates the Scope class' do
+      obj = Dogapi::Scope.new('somehost', 'somedevice')
+
+      expect(obj.host).to eq 'somehost'
+      expect(obj.device).to eq 'somedevice'
+    end
+  end # end Scope
+
+  context 'HttpConnection' do
+    it 'respects the proxy configuration' do
+      service = Dogapi::APIService.new('api_key', 'app_key')
+
+      service.connect do |conn|
+        expect(conn.proxy_address).to be(nil)
+        expect(conn.proxy_port).to be(nil)
+      end
+
+      ENV['http_proxy'] = 'https://www.proxy.com:443'
+
+      service.connect do |conn|
+        expect(conn.proxy_address).to eq 'www.proxy.com'
+        expect(conn.proxy_port).to eq 443
+      end
+
+      ENV['http_proxy'] = nil
+    end
+
+    it 'respects the endpoint configuration' do
+      service = Dogapi::APIService.new('api_key', 'app_key', true, nil, 'https://app.example.com')
+
+      service.connect do |conn|
+        expect(conn.address).to eq 'app.example.com'
+        expect(conn.port).to eq 443
+      end
+    end
+  end
+end
+
+class FakeResponse
+  attr_accessor :code, :body
+  def initialize(code, body)
+    # Instance variables
+    @code = code
+    @body = body
+  end
+end
+
+describe Dogapi::APIService do
+  let(:dogapi_service_silent) { Dogapi::APIService.new 'API_KEY', 'APP_KEY' }
+  let(:dogapi_service) { Dogapi::APIService.new 'API_KEY', 'APP_KEY', false }
+  let(:std_error) { StandardError.new('test3') }
+
+  describe '#suppress_error_if_silent' do
+    context 'when silent' do
+      it "doesn't raise an error" do
+        dog = dogapi_service_silent
+        expect { dog.suppress_error_if_silent(std_error) }.not_to raise_error
+        expect { dog.suppress_error_if_silent(std_error) }.to output("test3\n").to_stderr
+        expect(dog.suppress_error_if_silent(std_error)).to eq([-1, {}])
+      end
+    end
+    context 'when not silent' do
+      it 'raises an error' do
+        dog = dogapi_service
+        expect { dog.suppress_error_if_silent(std_error) }.to raise_error(std_error)
+      end
+    end
+  end
+
+  describe '#handle_response' do
+    context 'when receiving a correct reponse with valid json' do
+      it 'parses it and return code and parsed body' do
+        dog = dogapi_service
+        resp = FakeResponse.new 202, '{"test2": "test3"}'
+        expect(dog.handle_response(resp)).to eq([202, { 'test2' => 'test3' }])
+      end
+    end
+    context 'when receiving a response with invalid json' do
+      it 'raises an error' do
+        dog = dogapi_service
+        resp = FakeResponse.new 202, "{'test2': }"
+        expect { dog.handle_response(resp) }.to raise_error(RuntimeError, "Invalid JSON Response: {'test2': }")
+      end
+    end
+    context 'when receiving a bad response' do
+      it 'returns the error code and an empty body' do
+        dog = dogapi_service
+        resp = FakeResponse.new 204, ''
+        expect(dog.handle_response(resp)).to eq([204, {}])
+        resp = FakeResponse.new 202, nil
+        expect(dog.handle_response(resp)).to eq([202, {}])
+        resp = FakeResponse.new 202, 'null'
+        expect(dog.handle_response(resp)).to eq([202, {}])
+      end
+    end
+  end
+end

data/spec/unit/facade_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe Dogapi::Client do
+  before(:each) do
+    @dogmock = Dogapi::Client.new(api_key, app_key)
+    @service = @dogmock.instance_variable_get(:@metric_svc)
+    @service.instance_variable_set(:@uploaded, [])
+    def @service.upload(payload)
+      @uploaded << payload
+      [200, {}]
+    end
+  end
+
+  describe '#emit_point' do
+    it 'passes data' do
+      @dogmock.emit_point('metric.name', 0, host: 'myhost')
+
+      uploaded = @service.instance_variable_get(:@uploaded)
+      expect(uploaded.length).to eq 1
+      series = uploaded.first
+      expect(series.class).to eq Array
+      expect(series[0][:metric]).to eq 'metric.name'
+      expect(series[0][:points][0][1]).to eq 0
+      expect(series[0][:host]).to eq 'myhost'
+    end
+
+    it 'uses localhost default' do
+      @dogmock.emit_point('metric.name', 0)
+
+      uploaded = @service.instance_variable_get(:@uploaded)
+      series = uploaded.first
+      expect(series[0][:host]).to eq Dogapi.find_localhost
+    end
+
+    it 'can pass nil host' do
+      @dogmock.emit_point('metric.name', 0, host: nil)
+
+      uploaded = @service.instance_variable_get(:@uploaded)
+      series = uploaded.first
+      expect(series[0][:host]).to be_nil
+    end
+
+    it 'can be batched' do
+      code, = @dogmock.batch_metrics do
+        @dogmock.emit_point('metric.name', 1, type: 'counter')
+        @dogmock.emit_point('othermetric.name', 2, type: 'counter')
+      end
+      expect(code).to eq 200
+      # Verify that we uploaded what we expected
+      uploaded = @service.instance_variable_get(:@uploaded)
+      expect(uploaded.length).to eq 1
+      series = uploaded.first
+      expect(series.class).to eq Array
+      expect(series[0][:metric]).to eq 'metric.name'
+      expect(series[0][:points][0][1]).to eq 1
+      expect(series[0][:type]).to eq 'counter'
+      expect(series[1][:metric]).to eq 'othermetric.name'
+      expect(series[1][:points][0][1]).to eq 2
+      expect(series[1][:type]).to eq 'counter'
+
+      # Verify that the buffer was correclty emptied
+      buffer = @service.instance_variable_get(:@buffer)
+      expect(buffer).to be nil
+    end
+
+    it 'flushes the buffer even if an exception is raised' do
+      buffer = []
+      begin
+        @dogmock.batch_metrics do
+          @dogmock.emit_point('metric.name', 1, type: 'counter')
+          raise 'Oh no, something went wrong'
+        end
+      rescue
+        buffer = @service.instance_variable_get(:@buffer)
+      end
+      expect(buffer).to be nil
+    end
+  end
+end