dhc 1.0.0

data/spec/interceptors/throttle/reset_track_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Throttle do
+  let(:provider) { 'depay.fi' }
+  let(:limit) { 10_000 }
+  let(:remaining) { 1900 }
+  let(:options) do
+    {
+      throttle: {
+        provider: provider,
+        track: true,
+        limit: limit_options,
+        remaining: { header: 'Rate-Limit-Remaining' },
+        expires: { header: 'Rate-Limit-Reset' },
+        break: '80%'
+      }
+    }
+  end
+  let(:limit_options) { { header: 'Rate-Limit-Limit' } }
+  let(:break_option) { false }
+  let(:expires_in) { (Time.zone.now + 1.hour).to_i }
+
+  before(:each) do
+    DHC::Throttle.track = nil
+    DHC.config.interceptors = [DHC::Throttle]
+
+    stub_request(:get, 'http://depay.fi')
+      .to_return(
+        headers: {
+          'Rate-Limit-Limit' => limit,
+          'Rate-Limit-Remaining' => remaining,
+          'Rate-Limit-Reset' => expires_in
+        }
+      )
+  end
+
+  # If DHC::Trottle.track would be kept accross multiple tests,
+  # at least 2/3 of the following would fail
+
+  it 'resets track accross multiple tests 1/3' do
+    DHC.get('http://depay.fi', options)
+  end
+
+  it 'resets track accross multiple tests 2/3' do
+    DHC.get('http://depay.fi', options)
+  end
+
+  it 'resets track accross multiple tests 3/3' do
+    DHC.get('http://depay.fi', options)
+  end
+end

data/spec/interceptors/zipkin/distributed_tracing_spec.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Zipkin do
+  before(:each) do
+    DHC.config.interceptors = [described_class]
+    DHC.config.endpoint(:local, 'http://depay.fi')
+    stub_request(:get, 'http://depay.fi').to_return(status: 200, body: 'The Website')
+  end
+
+  context 'with zipkin tracer integration' do
+    before(:all) do
+      ::ZipkinTracer::TraceContainer.setup_mock(
+        trace_id: 'trace_id',
+        parent_id: 'parent_id',
+        span_id: 'span_id',
+        sampled: true,
+        flags: 'flags'
+      )
+    end
+
+    it 'adds the proper X-B3 headers and trace the request' do
+      expect(::ZipkinTracer::TraceContainer).to receive(:with_trace_id).and_call_original
+      headers = DHC.get(:local).request.headers
+      expect(headers['X-B3-TraceId']).to eq('trace_id')
+      expect(headers['X-B3-ParentSpanId']).to eq('parent_id')
+      expect(headers['X-B3-SpanId']).to eq('span_id')
+      expect(headers['X-B3-Sampled']).to eq('true')
+      expect(headers['X-B3-Flags']).to eq('flags')
+    end
+  end
+
+  describe 'creating new spans' do
+    context 'sampled? is false' do
+      before(:all) do
+        ::ZipkinTracer::TraceContainer.setup_mock(
+          trace_id: 'trace_id',
+          parent_id: 'parent_id',
+          span_id: 'span_id',
+          sampled: false,
+          flags: 'flags'
+        )
+      end
+
+      it 'adds the proper X-B3 headers' do
+        headers = DHC.get(:local).request.headers
+        expect(headers['X-B3-TraceId']).to eq('trace_id')
+        expect(headers['X-B3-ParentSpanId']).to eq('parent_id')
+        expect(headers['X-B3-SpanId']).to eq('span_id')
+        expect(headers['X-B3-Sampled']).to eq('false')
+        expect(headers['X-B3-Flags']).to eq('flags')
+      end
+
+      it 'does not register a new span' do
+        # ensure no span was registered, by checking no call on span
+        expect_any_instance_of(described_class).not_to receive(:span).and_call_original
+        DHC.get(:local)
+      end
+    end
+
+    context 'sampled? is true' do
+      before(:all) do
+        ::ZipkinTracer::TraceContainer.setup_mock(
+          trace_id: 'trace_id',
+          parent_id: 'parent_id',
+          span_id: 'span_id',
+          sampled: true,
+          flags: 'flags'
+        )
+      end
+
+      it 'adds the proper X-B3 headers' do
+        headers = DHC.get(:local).request.headers
+        expect(headers['X-B3-TraceId']).to eq('trace_id')
+        expect(headers['X-B3-ParentSpanId']).to eq('parent_id')
+        expect(headers['X-B3-SpanId']).to eq('span_id')
+        expect(headers['X-B3-Sampled']).to eq('true')
+        expect(headers['X-B3-Flags']).to eq('flags')
+      end
+
+      it 'does register a new span' do
+        # ensure a span was registered, by checking call on span
+        expect_any_instance_of(described_class).to receive(:span).at_least(:once).and_call_original
+        DHC.get(:local)
+      end
+    end
+  end
+
+  %w[ZipkinTracer Trace].each do |klass|
+    context "without #{klass}" do
+      before(:all) do
+        TemporaryClass = Object.send(:const_get, klass)
+        Object.send(:remove_const, klass)
+      end
+
+      after(:all) do
+        Object.send(:const_set, klass, TemporaryClass)
+      end
+
+      it 'does not trace the request' do
+        headers = nil
+        expect { headers = DHC.get(:local).request.headers }.not_to raise_error
+        expect(headers['X-B3-TraceId']).to be_nil
+        expect(headers['X-B3-ParentSpanId']).to be_nil
+        expect(headers['X-B3-SpanId']).to be_nil
+        expect(headers['X-B3-Sampled']).to be_nil
+        expect(headers['X-B3-Flags']).to be_nil
+      end
+    end
+  end
+
+  %w[Annotation BinaryAnnotation Endpoint].each do |klass|
+    context "without Trace::#{klass}" do
+      before(:all) do
+        TemporaryClass = Trace.send(:const_get, klass)
+        Trace.send(:remove_const, klass)
+      end
+
+      after(:all) do
+        Trace.send(:const_set, klass, TemporaryClass)
+      end
+
+      it 'does not trace the request' do
+        headers = nil
+        expect { headers = DHC.get(:local).request.headers }.not_to raise_error
+        expect(headers['X-B3-TraceId']).to be_nil
+        expect(headers['X-B3-ParentSpanId']).to be_nil
+        expect(headers['X-B3-SpanId']).to be_nil
+        expect(headers['X-B3-Sampled']).to be_nil
+        expect(headers['X-B3-Flags']).to be_nil
+      end
+    end
+  end
+end

data/spec/rails_helper.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+ENV['RAILS_ENV'] ||= 'test'
+
+require File.expand_path('dummy/config/environment', __dir__)

data/spec/request/body_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Request do
+  context 'encode body' do
+    let(:encoded_data) { data.to_json }
+
+    before do
+      stub_request(:post, 'http://datastore/q')
+        .with(body: encoded_data)
+        .to_return(status: 200)
+    end
+
+    context 'hash' do
+      let(:data) { { name: 'Steve' } }
+
+      it 'encodes the request body to the given format' do
+        DHC.post('http://datastore/q', body: data)
+      end
+
+      it 'does not encode the request body if it is already a string' do
+        DHC.post('http://datastore/q', body: encoded_data)
+      end
+    end
+
+    context 'array' do
+      let(:data) { [{ name: 'Steve' }] }
+
+      it 'encodes the request body to the given format' do
+        DHC.post('http://datastore/q', body: data)
+      end
+
+      it 'does not encode the request body if it is already a string' do
+        DHC.post('http://datastore/q', body: encoded_data)
+      end
+    end
+  end
+end

data/spec/request/encoding_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'addressable'
+require 'rails_helper'
+
+describe DHC::Request do
+  context 'encoding url' do
+    let(:url) { 'http://depay.fi/something with spaces' }
+
+    it 'can request urls with spaces inside' do
+      stub_request(:get, Addressable::URI.encode(url))
+      DHC.get(url)
+    end
+  end
+
+  context 'encoding params' do
+    let(:url) { 'http://depay.fi/api/search?name=:name' }
+
+    it 'can do requests with params including spaces' do
+      stub_request(:get, 'http://depay.fi/api/search?name=My%20name%20is%20rabbit')
+      DHC.get(url, params: { name: 'My name is rabbit' })
+    end
+  end
+
+  context 'skip encoding' do
+    let(:url) { 'http://depay.fi/api/search?names[]=seba&names[]=david' }
+
+    it 'does not encode if encoding is skipped' do
+      stub_request(:get, 'http://depay.fi/api/search?names%5B%5D%3Dseba%26names%5B%5D%3Ddavid')
+      DHC.get('http://depay.fi/api/search?names%5B%5D%3Dseba%26names%5B%5D%3Ddavid', url_encoding: false)
+    end
+
+    it 'does double encoding, if you really want to' do
+      stub_request(:get, 'http://depay.fi/api/search?names%255B%255D%253Dseba%2526names%255B%255D%253Ddavid')
+      DHC.get('http://depay.fi/api/search?names%5B%5D%3Dseba%26names%5B%5D%3Ddavid')
+    end
+  end
+end

data/spec/request/error_handling_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Request do
+  context 'error handling' do
+    def to_fail_with(error)
+      raise_error(error)
+    end
+
+    def expect_status_code(status_code)
+      stub_request(:get, "http://something/#{status_code}").to_return(status: status_code)
+      expect(
+        -> { DHC::Request.new(url: "http://something/#{status_code}") }
+      ).to yield
+    end
+
+    it 'raises errors for anything but 2XX response codes' do
+      expect_status_code(0)   { to_fail_with(DHC::UnknownError) }
+      expect_status_code(400) { to_fail_with(DHC::BadRequest) }
+      expect_status_code(401) { to_fail_with(DHC::Unauthorized) }
+      expect_status_code(402) { to_fail_with(DHC::PaymentRequired) }
+      expect_status_code(403) { to_fail_with(DHC::Forbidden) }
+      expect_status_code(403) { to_fail_with(DHC::Forbidden) }
+      expect_status_code(404) { to_fail_with(DHC::NotFound) }
+      expect_status_code(405) { to_fail_with(DHC::MethodNotAllowed) }
+      expect_status_code(406) { to_fail_with(DHC::NotAcceptable) }
+      expect_status_code(407) { to_fail_with(DHC::ProxyAuthenticationRequired) }
+      expect_status_code(408) { to_fail_with(DHC::RequestTimeout) }
+      expect_status_code(409) { to_fail_with(DHC::Conflict) }
+      expect_status_code(410) { to_fail_with(DHC::Gone) }
+      expect_status_code(411) { to_fail_with(DHC::LengthRequired) }
+      expect_status_code(412) { to_fail_with(DHC::PreconditionFailed) }
+      expect_status_code(413) { to_fail_with(DHC::RequestEntityTooLarge) }
+      expect_status_code(414) { to_fail_with(DHC::RequestUriToLong) }
+      expect_status_code(415) { to_fail_with(DHC::UnsupportedMediaType) }
+      expect_status_code(416) { to_fail_with(DHC::RequestedRangeNotSatisfiable) }
+      expect_status_code(417) { to_fail_with(DHC::ExpectationFailed) }
+      expect_status_code(422) { to_fail_with(DHC::UnprocessableEntity) }
+      expect_status_code(423) { to_fail_with(DHC::Locked) }
+      expect_status_code(424) { to_fail_with(DHC::FailedDependency) }
+      expect_status_code(426) { to_fail_with(DHC::UpgradeRequired) }
+      expect_status_code(500) { to_fail_with(DHC::InternalServerError) }
+      expect_status_code(501) { to_fail_with(DHC::NotImplemented) }
+      expect_status_code(502) { to_fail_with(DHC::BadGateway) }
+      expect_status_code(503) { to_fail_with(DHC::ServiceUnavailable) }
+      expect_status_code(504) { to_fail_with(DHC::GatewayTimeout) }
+      expect_status_code(505) { to_fail_with(DHC::HttpVersionNotSupported) }
+      expect_status_code(507) { to_fail_with(DHC::InsufficientStorage) }
+      expect_status_code(510) { to_fail_with(DHC::NotExtended) }
+    end
+  end
+
+  context 'parsing error' do
+    before(:each) do
+      stub_request(:get, 'http://datastore/v2/feedbacks').to_return(body: 'invalid json')
+    end
+
+    it 'requests json and parses response body' do
+      expect(-> {
+        DHC.json.get('http://datastore/v2/feedbacks').data
+      }).to raise_error(DHC::ParserError)
+    end
+  end
+
+  context 'custom error handler' do
+    it 'handles errors with the provided handler and does not raise them' do
+      stub_request(:get, 'http://something').to_return(status: 400)
+      handler = double('handler', call: -> {})
+      DHC::Request.new(url: 'http://something', rescue: handler)
+      expect(handler).to have_received(:call)
+    end
+
+    it 'exchanges body with handlers return if the handler returns something' do
+      stub_request(:get, 'http://something').to_return(status: 400)
+      handler = ->(_response) { { name: 'unknown' }.to_json }
+      request = DHC::Request.new(url: 'http://something', rescue: handler)
+      expect(request.response.data.name).to eq 'unknown'
+    end
+
+    it 'does not exchange body with handlers return if the handler returns nil' do
+      stub_request(:get, 'http://something').to_return(status: 400, body: { message: 'an error occurred' }.to_json)
+      handler = ->(_response) { nil }
+      request = DHC::Request.new(url: 'http://something', rescue: handler)
+      expect(request.response.data.message).to eq 'an error occurred'
+    end
+  end
+end

data/spec/request/headers_spec.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Request do
+  it 'provides request headers' do
+    stub_request(:get, 'http://depay.fi')
+    response = DHC.get('http://depay.fi')
+    request = response.request
+    expect(request.headers.keys).to include 'User-Agent'
+  end
+end

data/spec/request/ignore_errors_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Request do
+  context 'ignoring DHC::NotFound' do
+    let(:response) { DHC.get('http://depay.fi', ignore: [DHC::NotFound]) }
+
+    before { stub_request(:get, 'http://depay.fi').to_return(status: 404) }
+
+    it 'does not raise an error' do
+      expect { response }.not_to raise_error
+    end
+
+    it 'body is nil' do
+      expect(response.body).to eq nil
+    end
+
+    it 'data is nil' do
+      expect(response.data).to eq nil
+    end
+
+    it 'does raise an error for 500' do
+      stub_request(:get, 'http://depay.fi').to_return(status: 500)
+      expect { response }.to raise_error DHC::InternalServerError
+    end
+
+    it 'provides the information if the error was ignored' do
+      expect(response.error_ignored?).to eq true
+      expect(response.request.error_ignored?).to eq true
+    end
+  end
+
+  context 'inheritance when ignoring errors' do
+    before { stub_request(:get, 'http://depay.fi').to_return(status: 404) }
+
+    it "does not raise an error when it's a subclass of the ignored error" do
+      expect {
+        DHC.get('http://depay.fi', ignore: [DHC::Error])
+      }.not_to raise_error
+    end
+
+    it "does raise an error if it's not a subclass of the ignored error" do
+      expect {
+        DHC.get('http://depay.fi', ignore: [ArgumentError])
+      }.to raise_error(DHC::NotFound)
+    end
+  end
+
+  context 'does not raise exception if ignored errors is set to nil' do
+    before { stub_request(:get, 'http://depay.fi').to_return(status: 404) }
+
+    it 'does not raise an error when ignored errors is set to array with nil' do
+      expect {
+        DHC.get('http://depay.fi', ignore: [nil])
+      }.to raise_error(DHC::NotFound)
+    end
+
+    it 'does not raise an error when ignored errors is set to nil' do
+      expect {
+        DHC.get('http://depay.fi', ignore: nil)
+      }.to raise_error(DHC::NotFound)
+    end
+  end
+
+  context 'passing keys instead of arrays' do
+    before { stub_request(:get, 'http://depay.fi').to_return(status: 404) }
+
+    it 'does not raise an error when ignored errors is a key instead of an array' do
+      DHC.get('http://depay.fi', ignore: DHC::NotFound)
+    end
+  end
+end