lhc 12.0.0

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", __FILE__)

data/spec/request/body_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC::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
+        LHC.post('http://datastore/q', body: data)
+      end
+
+      it 'does not encode the request body if it is already a string' do
+        LHC.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
+        LHC.post('http://datastore/q', body: data)
+      end
+
+      it 'does not encode the request body if it is already a string' do
+        LHC.post('http://datastore/q', body: encoded_data)
+      end
+    end
+  end
+end

data/spec/request/encoding_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC::Request do
+  context 'encoding url' do
+    let(:url) { 'http://local.ch/something with spaces' }
+
+    it 'can request urls with spaces inside' do
+      stub_request(:get, URI.encode(url))
+      LHC.get(url)
+    end
+  end
+
+  context 'encoding params' do
+    let(:url) { 'http://local.ch/api/search?name=:name' }
+
+    it 'can do requests with params including spaces' do
+      stub_request(:get, 'http://local.ch/api/search?name=My%20name%20is%20rabbit')
+      LHC.get(url, params: { name: 'My name is rabbit' })
+    end
+  end
+
+  context 'skip encoding' do
+    let(:url) { 'http://local.ch/api/search?names[]=seba&names[]=david' }
+
+    it 'does not encode if encoding is skipped' do
+      stub_request(:get, 'http://local.ch/api/search?names%5B%5D%3Dseba%26names%5B%5D%3Ddavid')
+      LHC.get('http://local.ch/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://local.ch/api/search?names%255B%255D%253Dseba%2526names%255B%255D%253Ddavid')
+      LHC.get('http://local.ch/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 LHC::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(
+        -> { LHC::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(LHC::UnknownError) }
+      expect_status_code(400) { to_fail_with(LHC::BadRequest) }
+      expect_status_code(401) { to_fail_with(LHC::Unauthorized) }
+      expect_status_code(402) { to_fail_with(LHC::PaymentRequired) }
+      expect_status_code(403) { to_fail_with(LHC::Forbidden) }
+      expect_status_code(403) { to_fail_with(LHC::Forbidden) }
+      expect_status_code(404) { to_fail_with(LHC::NotFound) }
+      expect_status_code(405) { to_fail_with(LHC::MethodNotAllowed) }
+      expect_status_code(406) { to_fail_with(LHC::NotAcceptable) }
+      expect_status_code(407) { to_fail_with(LHC::ProxyAuthenticationRequired) }
+      expect_status_code(408) { to_fail_with(LHC::RequestTimeout) }
+      expect_status_code(409) { to_fail_with(LHC::Conflict) }
+      expect_status_code(410) { to_fail_with(LHC::Gone) }
+      expect_status_code(411) { to_fail_with(LHC::LengthRequired) }
+      expect_status_code(412) { to_fail_with(LHC::PreconditionFailed) }
+      expect_status_code(413) { to_fail_with(LHC::RequestEntityTooLarge) }
+      expect_status_code(414) { to_fail_with(LHC::RequestUriToLong) }
+      expect_status_code(415) { to_fail_with(LHC::UnsupportedMediaType) }
+      expect_status_code(416) { to_fail_with(LHC::RequestedRangeNotSatisfiable) }
+      expect_status_code(417) { to_fail_with(LHC::ExpectationFailed) }
+      expect_status_code(422) { to_fail_with(LHC::UnprocessableEntity) }
+      expect_status_code(423) { to_fail_with(LHC::Locked) }
+      expect_status_code(424) { to_fail_with(LHC::FailedDependency) }
+      expect_status_code(426) { to_fail_with(LHC::UpgradeRequired) }
+      expect_status_code(500) { to_fail_with(LHC::InternalServerError) }
+      expect_status_code(501) { to_fail_with(LHC::NotImplemented) }
+      expect_status_code(502) { to_fail_with(LHC::BadGateway) }
+      expect_status_code(503) { to_fail_with(LHC::ServiceUnavailable) }
+      expect_status_code(504) { to_fail_with(LHC::GatewayTimeout) }
+      expect_status_code(505) { to_fail_with(LHC::HttpVersionNotSupported) }
+      expect_status_code(507) { to_fail_with(LHC::InsufficientStorage) }
+      expect_status_code(510) { to_fail_with(LHC::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(-> {
+        LHC.json.get('http://datastore/v2/feedbacks').data
+      }).to raise_error(LHC::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: -> {})
+      LHC::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 = LHC::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 = LHC::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 LHC::Request do
+  it 'provides request headers' do
+    stub_request(:get, 'http://local.ch')
+    response = LHC.get('http://local.ch')
+    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 LHC::Request do
+  context 'ignoring LHC::NotFound' do
+    let(:response) { LHC.get('http://local.ch', ignore: [LHC::NotFound]) }
+
+    before { stub_request(:get, 'http://local.ch').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://local.ch').to_return(status: 500)
+      expect { response }.to raise_error LHC::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://local.ch').to_return(status: 404) }
+
+    it "does not raise an error when it's a subclass of the ignored error" do
+      expect {
+        LHC.get('http://local.ch', ignore: [LHC::Error])
+      }.not_to raise_error
+    end
+
+    it "does raise an error if it's not a subclass of the ignored error" do
+      expect {
+        LHC.get('http://local.ch', ignore: [ArgumentError])
+      }.to raise_error(LHC::NotFound)
+    end
+  end
+
+  context 'does not raise exception if ignored errors is set to nil' do
+    before { stub_request(:get, 'http://local.ch').to_return(status: 404) }
+
+    it "does not raise an error when ignored errors is set to array with nil" do
+      expect {
+        LHC.get('http://local.ch', ignore: [nil])
+      }.to raise_error(LHC::NotFound)
+    end
+
+    it "does not raise an error when ignored errors is set to nil" do
+      expect {
+        LHC.get('http://local.ch', ignore: nil)
+      }.to raise_error(LHC::NotFound)
+    end
+  end
+
+  context 'passing keys instead of arrays' do
+    before { stub_request(:get, 'http://local.ch').to_return(status: 404) }
+
+    it "does not raise an error when ignored errors is a key instead of an array" do
+      LHC.get('http://local.ch', ignore: LHC::NotFound)
+    end
+  end
+end

data/spec/request/option_dup_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC::Request do
+  it 'does not alter the options that where passed' do
+    LHC.configure { |c| c.endpoint(:kpi_tracker, 'http://analytics/track/{entity_id}/w', params: { env: 'PROD' }) }
+    options = { params: { entity_id: '123' } }
+    stub_request(:get, "http://analytics/track/123/w?env=PROD")
+    LHC.get(:kpi_tracker, options)
+    expect(options).to eq(params: { entity_id: '123' })
+  end
+end

data/spec/request/parallel_requests_spec.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC::Request do
+  let(:request_options) do
+    [
+      { url: 'http://www.local.ch/restaurants' },
+      { url: 'http://www.local.ch' }
+    ]
+  end
+
+  let(:stub_parallel_requests) do
+    stub_request(:get, "http://www.local.ch/restaurants").to_return(status: 200, body: '1')
+    stub_request(:get, "http://www.local.ch").to_return(status: 200, body: '2')
+  end
+
+  it 'does parallel requests if you provide an array of requests' do
+    stub_parallel_requests
+    responses = LHC.request(request_options)
+    expect(responses[0].body).to eq '1'
+    expect(responses[1].body).to eq '2'
+  end
+
+  context 'interceptors' do
+    before(:each) do
+      class TestInterceptor < LHC::Interceptor; end
+      LHC.configure { |c| c.interceptors = [TestInterceptor] }
+    end
+
+    it 'calls interceptors also for parallel requests' do
+      stub_parallel_requests
+      @called = 0
+      allow_any_instance_of(TestInterceptor)
+        .to receive(:before_request) { @called += 1 }
+      LHC.request(request_options)
+      expect(@called).to eq 2
+    end
+  end
+
+  context 'webmock disabled' do
+    before do
+      WebMock.disable!
+    end
+
+    after do
+      WebMock.enable!
+    end
+
+    it 'does not memorize parallelization handlers in typhoeus (hydra) in case one request of the parallization fails' do
+      begin
+        LHC.request([{ url: 'https://www.google.com/' }, { url: 'https://nonexisting123' }, { url: 'https://www.google.com/' }, { url: 'https://nonexisting123' }])
+      rescue LHC::UnknownError
+      end
+
+      LHC.request([{ url: 'https://www.google.com' }])
+    end
+  end
+end

data/spec/request/params_encoding_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC::Request do
+  context 'without an encoding setting' do
+    it 'encodes array params in default rack format' do
+      stub_request(:get, 'http://datastore/q?a%5B%5D=1&a%5B%5D=2&a%5B%5D=3')
+      LHC.get('http://datastore/q', params: { a: [1, 2, 3] })
+    end
+  end
+
+  context 'with encoding set to :rack' do
+    it 'encodes array params in rack format' do
+      stub_request(:get, 'http://datastore/q?a%5B%5D=1&a%5B%5D=2&a%5B%5D=3')
+      LHC.get('http://datastore/q', params: { a: [1, 2, 3] }, params_encoding: :rack)
+    end
+  end
+
+  context 'with encoding set to :multi' do
+    it 'encodes array params in multi format' do
+      stub_request(:get, 'http://datastore/q?a=1&a=2&a=3')
+      LHC.get('http://datastore/q', params: { a: [1, 2, 3] }, params_encoding: :multi)
+    end
+  end
+end

data/spec/request/request_without_rails_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe LHC::Request do
+  before do
+    allow_any_instance_of(LHC::Request).to receive(:use_configured_endpoint!)
+    allow_any_instance_of(LHC::Request).to receive(:generate_url_from_template!)
+  end
+  context 'request without rails' do
+    it 'does have deep_merge dependency met' do
+      expect { LHC::Request.new({}, false) }.not_to raise_error
+    end
+  end
+end

data/spec/request/url_patterns_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC::Request do
+  it 'compiles url in case of configured endpoints' do
+    options = { params: {
+      has_reviews: true
+    } }
+    url = 'http://datastore/v2/campaign/{campaign_id}/feedbacks'
+    LHC.configure { |c| c.endpoint(:feedbacks, url, options) }
+    stub_request(:get, 'http://datastore/v2/campaign/123/feedbacks?has_reviews=true')
+    LHC.get(:feedbacks, params: { campaign_id: 123 })
+  end
+
+  it 'compiles url when doing a request' do
+    stub_request(:get, 'http://datastore:8080/v2/feedbacks/123')
+    LHC.get('http://datastore:8080/v2/feedbacks/{id}', params: { id: 123 })
+  end
+
+  it 'considers body when compiling urls' do
+    stub_request(:post, "http://datastore:8080/v2/places/123")
+    LHC.json.post('http://datastore:8080/v2/places/{id}', body: { id: 123 })
+  end
+
+  context 'custom data structures that respond to as_json (like LHS data or record)' do
+    before do
+      class CustomStructure
+
+        def initialize(data)
+          @data = data
+        end
+
+        def as_json
+          @data.as_json
+        end
+
+        def to_json
+          as_json.to_json
+        end
+      end
+    end
+
+    let(:data) do
+      CustomStructure.new(id: '12345')
+    end
+
+    it 'compiles url from body params when body object respond_to(:as_json)' do
+      stub_request(:post, "http://datastore/places/12345")
+        .to_return(status: 200)
+      LHC.post('http://datastore/places/{id}', body: data)
+    end
+  end
+end

data/spec/request/user_agent_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHC::Request do
+  before do
+    LHC.send(:remove_const, :Request)
+    load('lhc/concerns/lhc/request/user_agent_concern.rb')
+    load('lhc/request.rb')
+  end
+
+  context 'default headers' do
+    context 'agent' do
+      it 'sets header agent information to be LHC' do
+        stub_request(:get, "http://local.ch/")
+          .with(
+            headers: {
+              'User-Agent' => "LHC (#{LHC::VERSION}; Dummy) [https://github.com/local-ch/lhc]"
+            }
+          )
+          .to_return(status: 200)
+        LHC.get('http://local.ch')
+      end
+    end
+  end
+end