lhc 3.4.0 → 3.5.0

data/spec/interceptors/return_response_spec.rb

@@ -1,37 +1,34 @@
 require 'rails_helper'
 
 describe LHC do
-
   context 'interceptor' do
-
     before(:each) do
       class CacheInterceptor < LHC::Interceptor
 
-        def before_request(request)
-          return LHC::Response.new(Typhoeus::Response.new(response_body: 'Im served from cache'), nil)
+        def before_request(_request)
+          LHC::Response.new(Typhoeus::Response.new(response_body: 'Im served from cache'), nil)
         end
       end
-      LHC.configure { |c| c.interceptors = [CacheInterceptor] }
+      described_class.configure { |c| c.interceptors = [CacheInterceptor] }
     end
 
     it 'can return a response rather then doing a real request' do
-      response = LHC.get('http://local.ch')
+      response = described_class.get('http://local.ch')
       expect(response.body).to eq 'Im served from cache'
     end
 
     context 'misusage' do
-
       before(:each) do
         class AnotherInterceptor < LHC::Interceptor
-          def before_request(request)
-            return LHC::Response.new(Typhoeus::Response.new({}), nil)
+          def before_request(_request)
+            LHC::Response.new(Typhoeus::Response.new({}), nil)
           end
         end
       end
 
       it 'raises an exception when two interceptors try to return a response' do
-        expect(->{
-          LHC.get('http://local.ch', interceptors: [CacheInterceptor, AnotherInterceptor])
+        expect(lambda {
+          described_class.get('http://local.ch', interceptors: [CacheInterceptor, AnotherInterceptor])
         }).to raise_error 'Response already set from another interceptor'
       end
     end

data/spec/request/encoding_spec.rb

@@ -1,19 +1,16 @@
 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))
+      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

data/spec/request/error_handling_spec.rb

@@ -1,9 +1,7 @@
 require 'rails_helper'
 
 describe LHC::Request do
-
   context 'error handling' do
-
     def to_fail_with(error)
       raise_error(error)
     end
@@ -49,4 +47,17 @@ describe LHC::Request do
       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
 end

data/spec/request/headers_spec.rb

@@ -1,11 +1,10 @@
 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).to eq({"User-Agent"=>"Typhoeus - https://github.com/typhoeus/typhoeus"})
+    expect(request.headers).to eq("User-Agent" => "Typhoeus - https://github.com/typhoeus/typhoeus")
   end
 end

data/spec/request/option_dup_spec.rb

@@ -1,12 +1,11 @@
 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' } }) }
+    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' } })
+    expect(options).to eq(params: { entity_id: '123' })
   end
 end

data/spec/request/parallel_requests_spec.rb

@@ -1,7 +1,6 @@
 require 'rails_helper'
 
 describe LHC::Request do
-
   let(:request_options) do
     [
       { url: 'http://www.local.ch/restaurants' },
@@ -22,12 +21,12 @@ describe LHC::Request do
   end
 
   context 'interceptors' do
-
     before(:each) do
       class TestInterceptor < LHC::Interceptor; end
       LHC.configure { |c| c.interceptors = [TestInterceptor] }
     end
 
+    # rubocop:disable RSpec/InstanceVariable
     it 'calls interceptors also for parallel requests' do
       stub_parallel_requests
       @called = 0
@@ -36,5 +35,6 @@ describe LHC::Request do
       LHC.request(request_options)
       expect(@called).to eq 2
     end
+    # rubocop:enable RSpec/InstanceVariable
   end
 end

data/spec/request/url_patterns_spec.rb

@@ -1,24 +1,23 @@
 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})
+    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})
+    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}.to_json)
+    LHC.json.post('http://datastore:8080/v2/places/:id', body: { id: 123 }.to_json)
   end
 end

data/spec/response/body_spec.rb

@@ -1,15 +1,13 @@
 require 'rails_helper'
 
 describe LHC::Response do
-
   context 'body' do
-
     let(:body) { 'this is a body' }
 
-    let(:raw_response) { OpenStruct.new({ body: body }) }
+    let(:raw_response) { OpenStruct.new(body: body) }
 
     it 'provides response body' do
-      response = LHC::Response.new(raw_response, nil)
+      response = described_class.new(raw_response, nil)
       expect(response.body).to eq body
     end
   end

data/spec/response/code_spec.rb

@@ -1,15 +1,13 @@
 require 'rails_helper'
 
 describe LHC::Response do
-
   context 'code' do
-
     let(:code) { 200 }
 
-    let(:raw_response) { OpenStruct.new({ code: code }) }
+    let(:raw_response) { OpenStruct.new(code: code) }
 
     it 'provides response code' do
-      response = LHC::Response.new(raw_response, nil)
+      response = described_class.new(raw_response, nil)
       expect(response.code).to eq code
     end
   end

data/spec/response/data_spec.rb

@@ -1,14 +1,12 @@
 require 'rails_helper'
 
 describe LHC::Response do
-
   context 'data' do
-
     let(:value) { 'some_value' }
 
-    let(:body) {{ some_key: {nested: value} }}
+    let(:body) { { some_key: { nested: value } } }
 
-    let(:raw_response) { OpenStruct.new({ body: body.to_json }) }
+    let(:raw_response) { OpenStruct.new(body: body.to_json) }
 
     it 'makes data from response body available' do
       response = LHC::Response.new(raw_response, nil)

data/spec/response/effective_url_spec.rb

@@ -1,15 +1,13 @@
 require 'rails_helper'
 
 describe LHC::Response do
-
   context 'effective_url' do
-
     let(:effective_url) { 'https://www.local.ch' }
 
     let(:raw_response) { OpenStruct.new(effective_url: effective_url) }
 
     it 'provides effective_url' do
-      response = LHC::Response.new(raw_response, nil)
+      response = described_class.new(raw_response, nil)
       expect(response.effective_url).to eq effective_url
     end
   end

data/spec/response/headers_spec.rb

@@ -1,17 +1,15 @@
 require 'rails_helper'
 
 describe LHC::Response do
-
   context 'headers' do
-
     let(:headers) do
       { 'Content-Encoding' => 'UTF-8' }
     end
 
-    let(:raw_response) { OpenStruct.new({ headers: headers }) }
+    let(:raw_response) { OpenStruct.new(headers: headers) }
 
     it 'provides headers' do
-      response = LHC::Response.new(raw_response, nil)
+      response = described_class.new(raw_response, nil)
       expect(response.headers).to eq headers
     end
   end

data/spec/response/options_spec.rb

@@ -1,17 +1,15 @@
 require 'rails_helper'
 
 describe LHC::Response do
-
   context 'headers' do
-
     let(:options) do
       { 'return_code' => :ok }
     end
 
-    let(:raw_response) { OpenStruct.new({ options: options }) }
+    let(:raw_response) { OpenStruct.new(options: options) }
 
     it 'provides headers' do
-      response = LHC::Response.new(raw_response, nil)
+      response = described_class.new(raw_response, nil)
       expect(response.options).to eq options
     end
   end

data/spec/response/success_spec.rb

@@ -1,10 +1,9 @@
 require 'rails_helper'
 
 describe LHC::Response do
-
   context 'success?' do
-    let(:response_success) { LHC::Response.new(Typhoeus::Response.new(response_code: 200, mock: true), nil) }
-    let(:response_error) { LHC::Response.new(Typhoeus::Response.new(response_code: 404, mock: true), nil) }
+    let(:response_success) { described_class.new(Typhoeus::Response.new(response_code: 200, mock: true), nil) }
+    let(:response_error) { described_class.new(Typhoeus::Response.new(response_code: 404, mock: true), nil) }
 
     it { expect(response_success.success?).to be_truthy }
     it { expect(response_error.success?).to be_falsy }

data/spec/response/time_spec.rb

@@ -1,16 +1,14 @@
 require 'rails_helper'
 
 describe LHC::Response do
-
   context 'time' do
-
     let(:time) { 1.3 }
 
-    let(:raw_response) { OpenStruct.new({time: time}) }
+    let(:raw_response) { OpenStruct.new(time: time) }
 
     it 'provides response time in milliseconds' do
-      response = LHC::Response.new(raw_response, nil)
-      expect(response.time).to eq time*1000
+      response = described_class.new(raw_response, nil)
+      expect(response.time).to eq time * 1000
     end
   end
 end

data/spec/spec_helper.rb

@@ -2,4 +2,4 @@ require 'pry'
 require 'webmock/rspec'
 require 'lhc'
 
-Dir[File.join(__dir__, "support/**/*.rb")].each {|f| require f}
+Dir[File.join(__dir__, "support/**/*.rb")].each { |f| require f }

data/spec/support/reset_config.rb

@@ -1,7 +1,5 @@
 RSpec.configure do |config|
-
   config.before(:each) do
     LHC::Config.instance.reset
   end
-
 end

data/spec/timeouts/no_signal_spec.rb

@@ -1,11 +1,9 @@
 require 'rails_helper'
 
 describe LHC::Request do
-
   context 'timeouts' do
-
     it 'has no_signal options set to true by default' do
-      expect_any_instance_of(Ethon::Easy).to receive(:http_request).with(anything(), anything(), hash_including(:nosignal => true)).and_call_original
+      expect_any_instance_of(Ethon::Easy).to receive(:http_request).with(anything, anything, hash_including(nosignal: true)).and_call_original
       stub_request(:get, "http://local.ch/")
       LHC.get('http://local.ch')
     end

data/spec/timeouts/timings_spec.rb

@@ -1,59 +1,53 @@
 require 'rails_helper'
 
 describe LHC::Request do
-
   context 'timeouts' do
-
     context "when timeout is not a whole number and timeout_ms is not set" do
-
-      let(:options) { {:timeout => 0.1} }
+      let(:options) { { timeout: 0.1 } }
 
       it "ceils timeout and sets timeout_ms" do
         expect_any_instance_of(Ethon::Easy).to receive(:http_request)
-        .with(anything(), anything(), hash_including(:timeout_ms => 100, :timeout => 1))
-        .and_call_original
+          .with(anything, anything, hash_including(timeout_ms: 100, timeout: 1))
+          .and_call_original
         stub_request(:get, "http://local.ch/")
         LHC.get('http://local.ch', options)
       end
     end
 
-     context "when timeout is not a whole number and timeout_ms is set" do
-
-        let(:options) { {:timeout => 0.1, :timeout_ms => 123} }
+    context "when timeout is not a whole number and timeout_ms is set" do
+      let(:options) { { timeout: 0.1, timeout_ms: 123 } }
 
-        it "ceils timeout and does not change timeout_ms" do
-          expect_any_instance_of(Ethon::Easy).to receive(:http_request)
-          .with(anything(), anything(), hash_including(:timeout_ms => 123, :timeout => 1))
+      it "ceils timeout and does not change timeout_ms" do
+        expect_any_instance_of(Ethon::Easy).to receive(:http_request)
+          .with(anything, anything, hash_including(timeout_ms: 123, timeout: 1))
           .and_call_original
-          stub_request(:get, "http://local.ch/")
-          LHC.get('http://local.ch', options)
-        end
+        stub_request(:get, "http://local.ch/")
+        LHC.get('http://local.ch', options)
       end
+    end
 
-      context "when connecttimeout is not a whole number and connecttimeout_ms is not set" do
-
-        let(:options) { {:connecttimeout => 0.1} }
+    context "when connecttimeout is not a whole number and connecttimeout_ms is not set" do
+      let(:options) { { connecttimeout: 0.1 } }
 
-        it "ceils connecttimeout and sets connecttimeout_ms" do
-          expect_any_instance_of(Ethon::Easy).to receive(:http_request)
-          .with(anything(), anything(), hash_including(:connecttimeout_ms => 100, :connecttimeout => 1))
+      it "ceils connecttimeout and sets connecttimeout_ms" do
+        expect_any_instance_of(Ethon::Easy).to receive(:http_request)
+          .with(anything, anything, hash_including(connecttimeout_ms: 100, connecttimeout: 1))
           .and_call_original
-          stub_request(:get, "http://local.ch/")
-          LHC.get('http://local.ch', options)
-        end
+        stub_request(:get, "http://local.ch/")
+        LHC.get('http://local.ch', options)
       end
+    end
 
-      context "when connecttimeout is not a whole number and connecttimeout_ms is set" do
-
-        let(:options) { {:connecttimeout => 0.1, :connecttimeout_ms => 123} }
+    context "when connecttimeout is not a whole number and connecttimeout_ms is set" do
+      let(:options) { { connecttimeout: 0.1, connecttimeout_ms: 123 } }
 
-        it "ceils connecttimeout and does not change connecttimeout_ms" do
-          expect_any_instance_of(Ethon::Easy).to receive(:http_request)
-          .with(anything(), anything(), hash_including(:connecttimeout_ms => 123, :connecttimeout => 1))
+      it "ceils connecttimeout and does not change connecttimeout_ms" do
+        expect_any_instance_of(Ethon::Easy).to receive(:http_request)
+          .with(anything, anything, hash_including(connecttimeout_ms: 123, connecttimeout: 1))
           .and_call_original
-          stub_request(:get, "http://local.ch/")
-          LHC.get('http://local.ch', options)
-        end
+        stub_request(:get, "http://local.ch/")
+        LHC.get('http://local.ch', options)
       end
+    end
   end
 end