lhs 24.0.0

data/spec/record/dig_configuration_spec.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  before do
+    class Business < LHS::Record
+      configuration(
+        items_key: [:response, :businesses],
+        total_key: [:response, :count],
+        limit_key: { body: [:response, :max] },
+        pagination_key: { body: [:response, :offset] },
+        pagination_strategy: :offset
+      )
+      endpoint 'http://uberall/businesses'
+    end
+  end
+
+  let(:stub_single_business_request) do
+    stub_request(:get, "http://uberall/businesses?identifier=ABC123&limit=1")
+      .to_return(body: {
+        status: "SUCCESS",
+        response: {
+          offset: 0,
+          max: 50,
+          count: 1,
+          businesses: [
+            {
+              identifier: 'ABC123',
+              name: 'localsearch'
+            }
+          ]
+        }
+      }.to_json)
+  end
+
+  let(:stub_multiple_businesses_request) do
+    stub_request(:get, "http://uberall/businesses?name=localsearch")
+      .to_return(body: {
+        status: "SUCCESS",
+        response: {
+          offset: 0,
+          max: 50,
+          count: 2,
+          businesses: [
+            {
+              identifier: 'ABC123',
+              name: 'localsearch'
+            },
+            {
+              identifier: 'ABC121',
+              name: 'Swisscom'
+            }
+          ]
+        }
+      }.to_json)
+  end
+
+  context 'access nested keys for configuration' do
+    it 'uses paths from configuration to access nested values' do
+      stub_single_business_request
+      business = Business.find_by(identifier: 'ABC123')
+      expect(business.identifier).to eq 'ABC123'
+      expect(business.name).to eq 'localsearch'
+    end
+
+    it 'digs for meta data when meta information is nested' do
+      stub_multiple_businesses_request
+      businesses = Business.where(name: 'localsearch')
+      expect(businesses.length).to eq 2
+      expect(businesses.count).to eq 2
+      expect(businesses.offset).to eq 0
+    end
+  end
+end

data/spec/record/dup_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  describe '#dup' do
+    before do
+      class Appointment < LHS::Record
+      end
+    end
+
+    it 'returns a copy of an object' do
+      appointment = Appointment.new
+      copy = appointment.dup
+      expect(copy.inspect).to match(/Appointment/)
+      expect(copy).to be_kind_of(Appointment)
+      expect(copy.object_id).not_to eql(appointment.object_id)
+    end
+  end
+end

data/spec/record/endpoint_inheritance_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  context 'inherit endpoints' do
+    before do
+      class Base < LHS::Record
+        endpoint 'records/{id}'
+      end
+
+      class Example < Base
+      end
+    end
+
+    it 'inherits endpoints based on ruby class_attribute behaviour' do
+      request = stub_request(:get, 'http://records/1').to_return(body: [].to_json)
+      Example.find(1)
+      Base.find(1)
+      assert_requested(request, times: 2)
+    end
+  end
+
+  context 'define endpoints in subclass' do
+    before do
+      class Base < LHS::Record
+        endpoint 'records/{id}'
+      end
+
+      class Example < Base
+        endpoint 'records'
+      end
+    end
+
+    it 'inherits endpoints based on ruby class_attribute behaviour' do
+      stub_request(:get, 'http://records?color=blue').to_return(body: [].to_json)
+      Example.where(color: 'blue')
+      expect(
+        -> { Base.all.first }
+      ).to raise_error(RuntimeError, 'Compilation incomplete. Unable to find value for id.')
+    end
+  end
+
+  context 'ambiguous endpoints between super and subclass' do
+    before do
+      class Base < LHS::Record
+        endpoint 'records'
+      end
+
+      class Example < Base
+        endpoint 'examples/{id}'
+      end
+    end
+
+    it 'inherits endpoints based on ruby class_attribute behaviour' do
+      request = stub_request(:get, 'http://records?limit=100').to_return(body: [].to_json)
+      Base.all.first
+      assert_requested(request)
+
+      request = stub_request(:get, 'http://examples/1').to_return(body: {}.to_json)
+      Example.find(1)
+      assert_requested(request)
+    end
+  end
+end

data/spec/record/endpoint_options_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  context 'set options for an endpoint' do
+    before do
+      class Record < LHS::Record
+        endpoint 'backend/v2/feedbacks/{id}', cache_expires_in: 1.day, retry: 2, cache: true
+      end
+    end
+
+    it 'stores endpoints with options' do
+      expect(Record.endpoints[0].options).to eq(cache_expires_in: 86400, retry: 2, cache: true)
+    end
+
+    it 'uses the options that are configured for an endpoint' do
+      expect(LHC).to receive(:request)
+        .with(
+          cache_expires_in: 1.day,
+          retry: 2,
+          cache: true,
+          url: 'backend/v2/feedbacks/1'
+        ).and_call_original
+
+      stub_request(:get, "http://backend/v2/feedbacks/1").to_return(status: 200)
+      Record.find(1)
+    end
+
+    context 'deep merge endpoint options' do
+
+      before do
+        class Location < LHS::Record
+          endpoint 'http://uberall/locations', headers: { privateKey: '123' }
+        end
+      end
+
+      it 'deep merges options to not overwrite endpoint options' do
+        stub_request(:get, "http://uberall/locations")
+          .with(
+            headers: {
+              'Privatekey' => '123',
+              'X-Custom' => '123'
+            }
+          )
+          .to_return(body: [].to_json)
+
+        Location.options(headers: { 'X-Custom' => '123' }).fetch
+      end
+    end
+  end
+end

data/spec/record/endpoint_priorities_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+
+  context 'endpoint priorities' do
+
+    before do
+      class Record < LHS::Record
+        endpoint 'https://api/v2/feedbacks'
+        endpoint 'https://api/v2/reviews'
+        endpoint 'https://api/v2/streets/{id}'
+        endpoint 'https://api/v2/feedbacks/{id}'
+        endpoint 'https://api/v2/reviews/{id}'
+      end
+    end
+
+    it 'always takes the first endpoint found' do
+      stub_request(:get, "https://api/v2/feedbacks").to_return(status: 200)
+      Record.fetch
+      stub_request(:get, "https://api/v2/streets/1").to_return(status: 200)
+      Record.find(1)
+    end
+  end
+end

data/spec/record/endpoints_spec.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  context 'endpoints' do
+    let(:datastore) { 'http://local.ch/v2' }
+
+    before do
+      LHC.config.placeholder(:datastore, datastore)
+      class Record < LHS::Record
+        endpoint '{+datastore}/entries/{entry_id}/content-ads/{campaign_id}/feedbacks'
+        endpoint '{+datastore}/{campaign_id}/feedbacks'
+        endpoint '{+datastore}/feedbacks'
+      end
+    end
+
+    it 'stores all the endpoints by url' do
+      expect(LHS::Record::Endpoints.all['{+datastore}/entries/{entry_id}/content-ads/{campaign_id}/feedbacks']).to be_present
+      expect(LHS::Record::Endpoints.all['{+datastore}/{campaign_id}/feedbacks']).to be_present
+      expect(LHS::Record::Endpoints.all['{+datastore}/feedbacks']).to be_present
+    end
+
+    it 'stores the endpoints of the service' do
+      expect(Record.endpoints.count).to eq 3
+      expect(Record.endpoints[0].url).to eq '{+datastore}/entries/{entry_id}/content-ads/{campaign_id}/feedbacks'
+      expect(Record.endpoints[1].url).to eq '{+datastore}/{campaign_id}/feedbacks'
+      expect(Record.endpoints[2].url).to eq '{+datastore}/feedbacks'
+    end
+
+    it 'finds the endpoint by the one with the most route param hits' do
+      expect(
+        Record.find_endpoint(campaign_id: '12345').url
+      ).to eq '{+datastore}/{campaign_id}/feedbacks'
+      expect(
+        Record.find_endpoint(campaign_id: '12345', entry_id: '123').url
+      ).to eq '{+datastore}/entries/{entry_id}/content-ads/{campaign_id}/feedbacks'
+    end
+
+    it 'finds the base endpoint (endpoint with least amount of route params)' do
+      expect(
+        Record.find_endpoint.url
+      ).to eq '{+datastore}/feedbacks'
+    end
+
+    context 'compute url from endpoint' do
+      before do
+        class Feedback < LHS::Record
+          endpoint '{+datastore}/feedbacks'
+          endpoint '{+datastore}/feedbacks/{id}'
+        end
+      end
+
+      it 'computes urls WITHOUT handling id separate' do
+        stub_request(:get, "#{datastore}/feedbacks/1").to_return(status: 200)
+        Feedback.find(1)
+      end
+    end
+
+    context 'unsorted endpoints' do
+      before do
+        class AnotherRecord < LHS::Record
+          endpoint '{+datastore}/feedbacks'
+          endpoint '{+datastore}/{campaign_id}/feedbacks'
+          endpoint '{+datastore}/entries/{entry_id}/content-ads/{campaign_id}/feedbacks'
+        end
+      end
+
+      it 'sorts endpoints before trying to find the best endpoint' do
+        stub_request(:get, "#{datastore}/entries/123/content-ads/123/feedbacks").to_return(status: 200)
+        AnotherRecord.where(campaign_id: 123, entry_id: 123)
+      end
+    end
+
+    context 'includes data without considering base endpoint of parent record if url is present' do
+      before do
+        class Contract < LHS::Record
+          endpoint '{+datastore}/contracts/:id'
+          endpoint '{+datastore}/entry/{entry_id}/contracts'
+        end
+      end
+
+      it 'uses urls instead of trying to find base endpoint of parent class' do
+        stub_request(:get, "#{datastore}/entry/123/contracts?limit=100")
+          .to_return(body: [{ product: { href: "#{datastore}/products/LBC" } }].to_json)
+        stub_request(:get, "#{datastore}/entry/123/contracts?limit=100&offset=100")
+          .to_return(body: [].to_json)
+        stub_request(:get, "#{datastore}/products/LBC")
+          .to_return(body: { name: 'Local Business Card' }.to_json)
+        expect(lambda {
+          Contract.includes_first_page(:product).where(entry_id: '123').all.first
+        }).not_to raise_error # Multiple base endpoints found
+      end
+    end
+  end
+end

data/spec/record/equality_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  context 'equality' do
+    before do
+      class Record < LHS::Record
+        endpoint 'http://local.ch/records'
+      end
+    end
+
+    let(:raw) do
+      { name: 'Steve' }
+    end
+
+    def record
+      LHS::Record.new LHS::Data.new(raw, nil, Record)
+    end
+
+    it 'is equal when two data objects share the same raw data' do
+      expect(
+        record
+      ).to eq record
+    end
+  end
+end

data/spec/record/error_handling_integration_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+require 'lhc/rspec'
+
+describe 'Error handling with chains', type: :request do
+  let!(:request) do
+    stub_request(:get, "http://datastore/v2/records?color=blue")
+      .to_return(status: 404)
+  end
+
+  it 'handles errors in rails controllers when query resolved in controller',
+  dummy_models: true do
+    get '/error_handling_with_chains/fetch_in_controller'
+    expect(request).to have_been_made.once
+    expect(response.body).to include('Sorry there was an error.')
+  end
+
+  it 'handles errors in rails controllers when query resolved in view',
+  dummy_models: true do
+    get '/error_handling_with_chains/fetch_in_view'
+    expect(request).to have_been_made.once
+    expect(response.body).to include('Sorry there was an error.')
+  end
+end

data/spec/record/error_handling_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  let(:handler) { spy('handler') }
+
+  before do
+    class Record < LHS::Record
+      endpoint 'http://local.ch/v2/records'
+    end
+    stub_request(:get, "http://local.ch/v2/records?color=blue")
+      .to_return(status: 400)
+  end
+
+  it 'allows to chain error handling' do
+    expect {
+      Record.where(color: 'blue').rescue(LHC::Error, ->(_error) { handler.handle }).first
+    }.not_to raise_error
+    expect(handler).to have_received(:handle)
+  end
+
+  it 'reraises in case chained error is not matched' do
+    expect {
+      Record.where(color: 'blue').rescue(LHC::Conflict, ->(_error) { handler.handle }).first
+    }.to raise_error(LHC::Error)
+    expect(handler).not_to have_received(:handle)
+  end
+
+  it 'calls all the handlers' do
+    expect {
+      Record.where(color: 'blue')
+        .rescue(LHC::Error, ->(_error) { handler.handle_1 })
+        .rescue(LHC::Error, ->(_error) { handler.handle_2 })
+        .first
+    }.not_to raise_error
+    expect(handler).to have_received(:handle_1)
+    expect(handler).to have_received(:handle_2)
+  end
+end

data/spec/record/expanded_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  before do
+    class Record < LHS::Record
+      endpoint 'http://local.ch/v2/records'
+    end
+  end
+
+  let!(:request_collection) do
+    stub_request(:get, "http://local.ch/v2/records?color=blue")
+      .to_return(body: {
+        items: [
+          { href: 'http://local.ch/v2/records/1' },
+          { href: 'http://local.ch/v2/records/2' }
+        ]
+      }.to_json)
+  end
+
+  let!(:request_item_1) do
+    stub_request(:get, "http://local.ch/v2/records/1?via=collection")
+      .to_return(body: {
+        name: 'Steve'
+      }.to_json)
+  end
+
+  let!(:request_item_2) do
+    stub_request(:get, "http://local.ch/v2/records/2?via=collection")
+      .to_return(body: {
+        name: 'John'
+      }.to_json)
+  end
+
+  it 'expands collections that just contains links' do
+    records = Record.where(color: 'blue').expanded(params: { via: 'collection' })
+    expect(records[0].name).to eq 'Steve'
+    expect(records[1].name).to eq 'John'
+    assert_requested request_collection
+    assert_requested request_item_1
+    assert_requested request_item_2
+  end
+
+  context 'without options' do
+    let!(:request_item_1) do
+      stub_request(:get, "http://local.ch/v2/records/1")
+        .to_return(body: {
+          name: 'Steve'
+        }.to_json)
+    end
+
+    let!(:request_item_2) do
+      stub_request(:get, "http://local.ch/v2/records/2")
+        .to_return(body: {
+          name: 'John'
+        }.to_json)
+    end
+
+    it 'works also without options' do
+      records = Record.where(color: 'blue').expanded
+      expect(records[0].name).to eq 'Steve'
+      expect(records[1].name).to eq 'John'
+      assert_requested request_collection
+      assert_requested request_item_1
+      assert_requested request_item_2
+    end
+  end
+end