dhc 1.0.0

data/spec/endpoint/placeholders_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Endpoint do
+  context 'placeholders' do
+    it 'returns all placeholders alphabetically sorted' do
+      endpoint = DHC::Endpoint.new('{+datastore}/v2/{campaign_id}/feedbacks')
+      expect(
+        endpoint.placeholders
+      ).to eq %i[campaign_id datastore]
+    end
+
+    it 'allows basic auth token in url, like used on github' do
+      stub_request(:get, 'https://d123token:@api.github.com/search')
+        .to_return(body: {}.to_json)
+      expect(-> {
+        DHC.get('https://d123token:@api.github.com/search')
+      }).not_to raise_error
+    end
+
+    it 'allows complete basic auth (username password) in url, like used for the gemserer' do
+      stub_request(:get, 'https://name:password@gemserver.com')
+        .to_return(body: {}.to_json)
+      expect(-> {
+        DHC.get('https://name:password@gemserver.com')
+      }).not_to raise_error
+    end
+  end
+end

data/spec/endpoint/remove_interpolated_params_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Endpoint do
+  it 'removes params used for interpolation' do
+    params = {
+      datastore: 'http://datastore',
+      campaign_id: 'abc',
+      has_reviews: true
+    }
+    endpoint = DHC::Endpoint.new('{+datastore}/v2/{campaign_id}/feedbacks')
+    removed = endpoint.remove_interpolated_params!(params)
+    expect(params).to eq(has_reviews: true)
+    expect(removed).to eq(datastore: 'http://datastore', campaign_id: 'abc')
+  end
+end

data/spec/endpoint/values_as_params_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Endpoint do
+  context 'values_as_params' do
+    [
+      ['{+datastore}/v2/places', 'http://depay.fi:8082/v2/places', {
+        datastore: 'http://depay.fi:8082'
+      }],
+      ['{+datastore}/v2/places/{id}', 'http://depay.fi:8082/v2/places/ZW9OJyrbt4OZE9ueu80w-A', {
+        datastore: 'http://depay.fi:8082',
+        id: 'ZW9OJyrbt4OZE9ueu80w-A'
+      }],
+      ['{+datastore}/v2/places/{namespace}/{id}', 'http://depay.fi:8082/v2/places/switzerland/ZW9OJyrbt', {
+        datastore: 'http://depay.fi:8082',
+        namespace: 'switzerland',
+        id: 'ZW9OJyrbt'
+      }]
+    ].each do |example|
+      template = example[0]
+      url = example[1]
+      params = example[2]
+
+      it "for the template #{template} it extracts #{params.keys.join(', ')} from the url" do
+        extracted = DHC::Endpoint.values_as_params(template, url)
+        expect(extracted).to eq(params)
+      end
+    end
+  end
+end

data/spec/error/dup_spec.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Error do
+  it 'does not dup' do
+    options = { errors: [described_class] }
+    expect(
+      options.deep_dup[:errors].include?(described_class)
+    ).to eq true
+  end
+end

data/spec/error/find_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Error do
+  def response(code, timedout = false)
+    DHC::Response.new(OpenStruct.new(code: code, 'timed_out?' => timedout), nil)
+  end
+
+  context 'find' do
+    it 'finds error class by status code' do
+      expect(DHC::Error.find(response('0', true))).to eq DHC::Timeout
+      expect(DHC::Error.find(response('400'))).to eq DHC::BadRequest
+      expect(DHC::Error.find(response('401'))).to eq DHC::Unauthorized
+      expect(DHC::Error.find(response('402'))).to eq DHC::PaymentRequired
+      expect(DHC::Error.find(response('403'))).to eq DHC::Forbidden
+      expect(DHC::Error.find(response('403'))).to eq DHC::Forbidden
+      expect(DHC::Error.find(response('404'))).to eq DHC::NotFound
+      expect(DHC::Error.find(response('405'))).to eq DHC::MethodNotAllowed
+      expect(DHC::Error.find(response('406'))).to eq DHC::NotAcceptable
+      expect(DHC::Error.find(response('407'))).to eq DHC::ProxyAuthenticationRequired
+      expect(DHC::Error.find(response('408'))).to eq DHC::RequestTimeout
+      expect(DHC::Error.find(response('409'))).to eq DHC::Conflict
+      expect(DHC::Error.find(response('410'))).to eq DHC::Gone
+      expect(DHC::Error.find(response('411'))).to eq DHC::LengthRequired
+      expect(DHC::Error.find(response('412'))).to eq DHC::PreconditionFailed
+      expect(DHC::Error.find(response('413'))).to eq DHC::RequestEntityTooLarge
+      expect(DHC::Error.find(response('414'))).to eq DHC::RequestUriToLong
+      expect(DHC::Error.find(response('415'))).to eq DHC::UnsupportedMediaType
+      expect(DHC::Error.find(response('416'))).to eq DHC::RequestedRangeNotSatisfiable
+      expect(DHC::Error.find(response('417'))).to eq DHC::ExpectationFailed
+      expect(DHC::Error.find(response('422'))).to eq DHC::UnprocessableEntity
+      expect(DHC::Error.find(response('423'))).to eq DHC::Locked
+      expect(DHC::Error.find(response('424'))).to eq DHC::FailedDependency
+      expect(DHC::Error.find(response('426'))).to eq DHC::UpgradeRequired
+      expect(DHC::Error.find(response('500'))).to eq DHC::InternalServerError
+      expect(DHC::Error.find(response('501'))).to eq DHC::NotImplemented
+      expect(DHC::Error.find(response('502'))).to eq DHC::BadGateway
+      expect(DHC::Error.find(response('503'))).to eq DHC::ServiceUnavailable
+      expect(DHC::Error.find(response('504'))).to eq DHC::GatewayTimeout
+      expect(DHC::Error.find(response('505'))).to eq DHC::HttpVersionNotSupported
+      expect(DHC::Error.find(response('507'))).to eq DHC::InsufficientStorage
+      expect(DHC::Error.find(response('510'))).to eq DHC::NotExtended
+    end
+
+    it 'finds error class also by extended status codes' do
+      expect(DHC::Error.find(response('40001'))).to eq DHC::BadRequest
+      expect(DHC::Error.find(response('50002'))).to eq DHC::InternalServerError
+    end
+
+    it 'returns UnknownError if no specific error was found' do
+      expect(DHC::Error.find(response('0'))).to eq DHC::UnknownError
+      expect(DHC::Error.find(response(''))).to eq DHC::UnknownError
+      expect(DHC::Error.find(response('600'))).to eq DHC::UnknownError
+    end
+  end
+end

data/spec/error/response_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Error do
+  context 'response' do
+    it 'throws timeout exception in case of a timeout' do
+      stub_request(:any, 'depay.fi').to_return(status: 403)
+      begin
+        DHC.get('depay.fi')
+      rescue => e
+        expect(e.response).to be_kind_of(DHC::Response)
+        expect(e.response.code).to eq 403
+      end
+    end
+  end
+end

data/spec/error/timeout_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Error do
+  context 'timeout' do
+    it 'throws timeout exception in case of a timeout' do
+      stub_request(:any, 'depay.fi').to_timeout
+      expect(lambda {
+        DHC.get('depay.fi')
+      }).to raise_error DHC::Timeout
+    end
+  end
+end

data/spec/error/to_s_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC::Error do
+  context 'to_s' do
+    let(:invalid) { (+"in\xc3lid").force_encoding('ASCII-8BIT') }
+    let(:valid) { 'vælid' }
+
+    context 'check assumptions' do
+      it 'joining raises an error' do
+        expect { [valid, invalid].join }.to raise_error Encoding::CompatibilityError
+      end
+      it 'interpolation raises an error' do
+        expect { "#{valid} #{invalid}" }.to raise_error Encoding::CompatibilityError
+      end
+      it 'to_json on an array raises an error' do
+        expect { [valid, invalid].to_json }.to raise_error Encoding::UndefinedConversionError
+      end
+
+      it 'to_s on a hash does not raise an error' do
+        expect { { valid: valid, invalid: invalid }.to_s }.not_to raise_error
+      end
+
+      it 'to_json on a hash does raise an error' do
+        expect { { valid: valid, invalid: invalid }.to_json }.to raise_error Encoding::UndefinedConversionError
+      end
+    end
+
+    it 'invalid body, valid message' do
+      stub_request(:get, 'http://depay.fi')
+        .to_return(status: 200, body: "{ text : '#{invalid}' }")
+      response = DHC.get('http://depay.fi')
+      expect { DHC::Error.new(valid, response).to_s }.not_to raise_error # Encoding::CompatibilityError
+    end
+
+    it 'valid body, invalid message' do
+      stub_request(:get, 'http://depay.fi')
+        .to_return(status: 200, body: "{ text : '#{valid}' }")
+      response = DHC.get('http://depay.fi')
+      expect { DHC::Error.new(invalid, response).to_s }.not_to raise_error # Encoding::CompatibilityError
+    end
+    # the other cases cannot be tested (for example what happens if the headers contain invalid data)
+    # because the mocking framework triggers the encoding error already
+
+    context 'some mocked response' do
+      let(:request) do
+        double('DHC::Request',
+               method: 'GET',
+               url: 'http://example.com/sessions',
+               headers: { 'Bearer Token' => 'aaaaaaaa-bbbb-cccc-dddd-eeee' },
+               options: { followlocation: true,
+                          auth: { bearer: 'aaaaaaaa-bbbb-cccc-dddd-eeee' },
+                          params: { limit: 20 }, url: 'http://example.com/sessions' })
+      end
+
+      let(:response) do
+        double('DHC::Response',
+               request: request,
+               code: 500,
+               options: { return_code: :internal_error, response_headers: '' },
+               body: '{"status":500,"message":"undefined"}')
+      end
+
+      subject { DHC::Error.new('The error message', response) }
+
+      before do
+        allow(request).to receive(:is_a?).with(DHC::Request).and_return(true)
+        allow(response).to receive(:is_a?).with(DHC::Response).and_return(true)
+      end
+
+      it 'produces correct debug output' do
+        expect(subject.to_s.split("\n")).to eq(<<-MSG.strip_heredoc.split("\n"))
+          GET http://example.com/sessions
+          Options: {:followlocation=>true, :auth=>{:bearer=>"aaaaaaaa-bbbb-cccc-dddd-eeee"}, :params=>{:limit=>20}, :url=>"http://example.com/sessions"}
+          Headers: {"Bearer Token"=>"aaaaaaaa-bbbb-cccc-dddd-eeee"}
+          Response Code: 500 (internal_error)
+          Response Options: {:return_code=>:internal_error, :response_headers=>""}
+          {"status":500,"message":"undefined"}
+          The error message
+        MSG
+      end
+    end
+  end
+end

data/spec/formats/form_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC do
+  include ActionDispatch::TestProcess
+
+  context 'form' do
+    it 'formats requests to be application/x-www-form-urlencoded' do
+      stub = stub_request(:post, 'http://depay.fi/')
+        .with(body: 'client_id=1234&client_secret=4567&grant_type=client_credentials')
+        .with(headers: { 'Content-Type': 'application/x-www-form-urlencoded' })
+        .to_return(status: 200)
+
+      DHC.form.post(
+        'http://depay.fi',
+        body: {
+          client_id: '1234',
+          client_secret: '4567',
+          grant_type: 'client_credentials'
+        }
+      )
+
+      expect(stub).to have_been_requested
+    end
+  end
+end

data/spec/formats/json_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC do
+  context 'formats' do
+    it 'adds Content-Type, Accept and Accept-Charset Headers to the request' do
+      stub_request(:get, 'http://depay.fi/')
+        .with(headers: {
+                'Accept' => 'application/json,application/vnd.api+json',
+                'Content-Type' => 'application/json; charset=utf-8',
+                'Accept-Charset' => 'utf-8'
+              })
+        .to_return(body: {}.to_json)
+      DHC.json.get('http://depay.fi')
+    end
+
+    context 'header key as symbol' do
+      it 'raises an error when trying to set content-type header even though the format is used' do
+        expect(lambda {
+          DHC.post(
+            'http://depay.fi',
+            headers: {
+              'Content-Type': 'multipart/form-data'
+            }
+          )
+        }).to raise_error 'Content-Type header is not allowed for formatted requests!\nSee https://github.com/DePayFi/dhc#formats for more information.'
+      end
+
+      it 'raises an error when trying to set accept header even though the format is used' do
+        expect(lambda {
+          DHC.post(
+            'http://depay.fi',
+            headers: {
+              'Accept': 'multipart/form-data'
+            }
+          )
+        }).to raise_error 'Accept header is not allowed for formatted requests!\nSee https://github.com/DePayFi/dhc#formats for more information.'
+      end
+    end
+
+    context 'header key as string' do
+      it 'raises an error when trying to set content-type header even though the format is used' do
+        expect(lambda {
+          DHC.post(
+            'http://depay.fi',
+            headers: {
+              'Content-Type' => 'multipart/form-data'
+            }
+          )
+        }).to raise_error 'Content-Type header is not allowed for formatted requests!\nSee https://github.com/DePayFi/dhc#formats for more information.'
+      end
+
+      it 'raises an error when trying to set accept header even though the format is used' do
+        expect(lambda {
+          DHC.post(
+            'http://depay.fi',
+            headers: {
+              'Accept' => 'multipart/form-data'
+            }
+          )
+        }).to raise_error 'Accept header is not allowed for formatted requests!\nSee https://github.com/DePayFi/dhc#formats for more information.'
+      end
+    end
+  end
+end

data/spec/formats/multipart_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC do
+  include ActionDispatch::TestProcess
+
+  context 'multipart' do
+    let(:file) { Rack::Test::UploadedFile.new(Tempfile.new) }
+    let(:body) { { size: 2231 }.to_json }
+    let(:location) { 'http://depay.fi/uploads/image.jpg' }
+
+    it 'formats requests to be multipart/form-data' do
+      stub_request(:post, 'http://depay.fi/') do |request|
+        raise 'Content-Type header wrong' unless request.headers['Content-Type'] == 'multipart/form-data'
+        raise 'Body wrongly formatted' unless request.body.match(/file=%23%3CActionDispatch%3A%3AHttp%3A%3AUploadedFile%3A.*%3E&type=Image/)
+      end.to_return(status: 200, body: body, headers: { 'Location' => location })
+      response = DHC.multipart.post(
+        'http://depay.fi',
+        body: { file: file, type: 'Image' }
+      )
+      expect(response.body).to eq body
+      expect(response.headers['Location']).to eq location
+    end
+  end
+end

data/spec/formats/plain_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC do
+  include ActionDispatch::TestProcess
+
+  context 'plain' do
+    let(:file) { Rack::Test::UploadedFile.new(Tempfile.new) }
+
+    it 'leaves plains requests unformatted' do
+      stub_request(:post, 'http://depay.fi/')
+        .with(body: /file=%23%3CRack%3A%3ATest%3A%3AUploadedFile%3.*%3E&type=Image/)
+        .to_return do |request|
+          expect(request.headers['Content-Type']).to be_blank
+
+          { status: 204 }
+        end
+      response = DHC.plain.post(
+        'http://depay.fi',
+        body: { file: file, type: 'Image' }
+      )
+      expect(lambda {
+        response.body
+        response.data
+      }).not_to raise_error
+    end
+  end
+end

data/spec/interceptors/after_request_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHC do
+  context 'interceptor' do
+    before(:each) do
+      class SomeInterceptor < DHC::Interceptor
+        def after_request; end
+      end
+      DHC.configure { |c| c.interceptors = [SomeInterceptor] }
+    end
+
+    it 'can perform some actions after a request was fired' do
+      expect_any_instance_of(SomeInterceptor).to receive(:after_request)
+      stub_request(:get, 'http://depay.fi')
+      DHC.get('http://depay.fi')
+    end
+  end
+end