lhs 24.0.0

data/spec/record/reload_by_id_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  before do
+    class Record < LHS::Record
+      endpoint 'http://datastore/records'
+      endpoint 'http://datastore/records/{id}'
+    end
+
+    class AnotherRecord < LHS::Record
+      endpoint 'http://datastore/otherrecords'
+      endpoint 'http://datastore/otherrecords/{id}'
+
+      def id
+        another_id
+      end
+    end
+  end
+
+  context 'reload!' do
+    it 'reloads the record by id' do
+      stub_request(:post, "http://datastore/records")
+        .to_return(body: { id: 1, name: 'Steve' }.to_json)
+      record = Record.create!(name: 'Steve')
+      stub_request(:get, "http://datastore/records/1")
+        .to_return(body: { id: 1, name: 'Steve', async: 'data' }.to_json)
+      record.reload!
+      expect(record.async).to eq 'data'
+    end
+
+    it 'reloads the record by id if a record method defines the actual id' do
+      stub_request(:post, "http://datastore/otherrecords")
+        .to_return(body: { another_id: 2, name: 'Can' }.to_json)
+      record = AnotherRecord.create!(name: 'Can')
+      stub_request(:get, "http://datastore/otherrecords/2")
+        .to_return(body: { id: 2, name: 'Can', async: 'data' }.to_json)
+      record.reload!
+      expect(record.async).to eq 'data'
+    end
+  end
+end

data/spec/record/reload_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  before do
+    class Record < LHS::Record
+      endpoint 'http://datastore/records'
+      endpoint 'http://datastore/records/{id}'
+    end
+  end
+
+  let(:json) do
+    { id: 1, name: 'Steve' }.to_json
+  end
+
+  context 'reload!' do
+    it 'returns an instance of the record, not an LHS::Item' do
+      stub_request(:post, "http://datastore/records").to_return(body: json)
+      stub_request(:get, "http://datastore/records/1").to_return(body: json)
+      record = Record.create!(name: 'Steve')
+      expect(record).to be_kind_of Record
+      expect(record.reload!).to be_kind_of Record
+    end
+  end
+
+  context 'nested items' do
+
+    before do
+      class Location < LHS::Record
+        endpoint 'http://uberall/locations'
+        endpoint 'http://uberall/locations/{id}'
+
+        configuration item_key: [:response, :location], items_key: [:response, :locations]
+      end
+    end
+
+    it 'merges reloads properly' do
+      stub_request(:get, "http://uberall/locations?identifier=http://places/1&limit=1")
+        .to_return(
+          body: {
+            response: {
+              locations: [{
+                id: 1,
+                name: 'Fridolin'
+              }]
+            }
+          }.to_json
+        )
+      location = Location.find_by(identifier: 'http://places/1')
+      stub_request(:get, "http://uberall/locations/1")
+        .to_return(
+          body: {
+            response: {
+              location: {
+                normalizationStatus: 'NORMALIZED'
+              }
+            }
+          }.to_json
+        )
+      location.reload!
+      expect(location.normalizationStatus).to eq 'NORMALIZED'
+    end
+  end
+end

data/spec/record/request_spec.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  before do
+    class Record < LHS::Record
+      endpoint 'http://datastore/feedbacks/{id}'
+    end
+  end
+
+  context 'url pattern' do
+    let(:datastore) { 'http://local.ch/v2' }
+
+    before do
+      LHC.config.placeholder(:datastore, datastore)
+      class Record < LHS::Record
+        endpoint '{+datastore}/content-ads/{campaign_id}/feedbacks'
+        endpoint '{+datastore}/feedbacks'
+      end
+    end
+
+    it 'is using params as query params explicitly when provided in params namespace' do
+      request = stub_request(:get, "#{datastore}/content-ads/123/feedbacks?campaign_id=456").to_return(status: 200)
+      Record.where(campaign_id: 123, params: { campaign_id: '456' }).to_a
+      assert_requested(request)
+    end
+  end
+
+  context '#convert_options_to_endpoint' do
+    before do
+      class Record < LHS::Record
+        endpoint 'http://datastore/feedbacks/{id}', params: { tracking: 123 }
+      end
+    end
+
+    it 'identifies endpoint by given url and merges back endpoint template parameters' do
+      options = LHS::Record.send(:convert_options_to_endpoints, url: 'http://datastore/feedbacks/1')
+      expect(options[:params][:id]).to eq '1'
+      expect(options[:url]).to eq 'http://datastore/feedbacks/{id}'
+    end
+
+    it 'identifies endpoint by given url and merges back endpoint template parameters into an array, if array was given' do
+      options = LHS::Record.send(:convert_options_to_endpoints, [{ url: 'http://datastore/feedbacks/1' }])
+      expect(options[0][:params][:id]).to eq '1'
+      expect(options[0][:url]).to eq 'http://datastore/feedbacks/{id}'
+    end
+
+    it 'returnes nil if endpoint was not found for the given url' do
+      options = LHS::Record.send(:convert_options_to_endpoints, url: 'http://datastore/reviews/1')
+      expect(options).to eq nil
+    end
+  end
+
+  context '#extend_with_reference' do
+    it 'extends given options with the one for the refernce' do
+      options = LHS::Record.send(:extend_with_reference, { url: 'http://datastore/feedbacks/1' }, { auth: { bearer: '123' } })
+      expect(options[:auth][:bearer]).to eq '123'
+    end
+
+    it 'extends given list of options with the one for the refernce' do
+      options = LHS::Record.send(:extend_with_reference, [{ url: 'http://datastore/feedbacks/1' }], auth: { bearer: '123' })
+      expect(options[0][:auth][:bearer]).to eq '123'
+    end
+  end
+
+  context '#options_for_data' do
+    it 'extract request options from raw data' do
+      options = LHS::Record.send(:url_option_for, LHS::Data.new({ href: 'http://datastore/feedbacks/1' }, nil, Record))
+      expect(options[:url]).to eq 'http://datastore/feedbacks/1'
+    end
+
+    it 'extract a list of request options from raw data if data is a collection' do
+      options = LHS::Record.send(:url_option_for, LHS::Data.new({ items: [{ href: 'http://datastore/feedbacks/1' }] }, nil, Record))
+      expect(options[0][:url]).to eq 'http://datastore/feedbacks/1'
+    end
+
+    it 'extract request options from raw nested data' do
+      options = LHS::Record.send(:url_option_for, LHS::Data.new({ reviews: { href: 'http://datastore/reviews/1' } }, nil, Record), :reviews)
+      expect(options[:url]).to eq 'http://datastore/reviews/1'
+    end
+  end
+
+  context '#record_for_options' do
+    it 'identifies lhs record from given options, as all request have to be done through LHS Records' do
+      record = LHS::Record.send(:record_for_options, url: 'http://datastore/feedbacks/1')
+      expect(record).to eq Record
+    end
+  end
+end

data/spec/record/save_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  context 'save!' do
+    context 'without href' do
+      before do
+        LHC.config.placeholder('datastore', datastore)
+        class Feedback < LHS::Record
+          endpoint '{+datastore}/content-ads/{campaign_id}/feedbacks'
+        end
+      end
+
+      let(:datastore) { 'http://local.ch/v2' }
+      let(:campaign_id) { 12345 }
+      let(:object) { { recommended: true } }
+      let(:item) { Feedback.new(object.merge(campaign_id: campaign_id)) }
+      let!(:request) do
+        stub_request(:post, "#{datastore}/content-ads/#{campaign_id}/feedbacks")
+          .with(body: object.to_json)
+          .to_return(status: 200, body: object.to_json)
+      end
+
+      it 'removes params used to compute url from send data' do
+        item.save!
+        expect(request).to have_been_made.once
+      end
+
+      context 'item without data' do
+        let(:item) { Feedback.new(object) }
+
+        it 'takes params to find endpoint also from the options' do
+          item.save!(params: { campaign_id: campaign_id })
+          expect(request).to have_been_made.once
+        end
+      end
+    end
+  end
+end

data/spec/record/scope_chains_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  let(:datastore) do
+    'http://datastore/v2'
+  end
+
+  let(:response) do
+    { body: [{ name: 'Steve' }] }
+  end
+
+  before do
+    LHC.config.placeholder('datastore', datastore)
+    class Record < LHS::Record
+      endpoint '{+datastore}/records/'
+      scope :blue, -> { where(color: 'blue') }
+      scope :available, -> { where(availalbe: 'true') }
+      scope :limited_to, ->(limit) { where(limit: limit) }
+    end
+  end
+
+  context 'scope chains' do
+    it 'allows chaining multiple scopes' do
+      stub_request(:get, "http://datastore/v2/records/?availalbe=true&color=blue&limit=20").to_return(response)
+      expect(
+        Record.blue.available.limited_to(20).first.name
+      ).to eq 'Steve'
+    end
+
+    it 'allows to chain multiple scopes when first one has arguments' do
+      stub_request(:get, "http://datastore/v2/records/?availalbe=true&color=blue&limit=20").to_return(response)
+      expect(
+        Record.limited_to(20).blue.available.first.name
+      ).to eq 'Steve'
+    end
+  end
+end

data/spec/record/select_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  let(:record) do
+    LHS::Record.new(LHS::Data.new(['cat', 'dog']))
+  end
+
+  context 'select' do
+    it 'works with select' do
+      expect(
+        record.select { |x| x }.join
+      ).to eq 'catdog'
+    end
+  end
+end

data/spec/record/to_ary_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  let(:user_item) do
+    {
+      email: 'someone@somewhe.re'
+    }
+  end
+
+  let(:item) do
+    {
+      href: 'http://datastore/records/1',
+      user: user_item
+    }
+  end
+
+  let(:record) { Record.find(1) }
+
+  before do
+    class User < LHS::Record
+    end
+
+    class Record < LHS::Record
+      endpoint 'http://datastore/records/{id}'
+
+      has_one :user, class_name: 'User'
+    end
+
+    stub_request(:get, 'http://datastore/records/1')
+      .to_return(body: item.to_json)
+  end
+
+  describe 'respond_to?(:to_ary)' do
+    context 'when creating item' do
+      let(:record) do
+        Record.new(user: User.new)
+      end
+
+      it 'does not respond to to_ary' do
+        expect(record.user.respond_to?(:to_ary)).to eq false
+      end
+    end
+
+    context 'when returning a single item' do
+      it 'does not respond to to_ary' do
+        expect(record.user.respond_to?(:to_ary)).to eq false
+      end
+    end
+
+    context 'when returning array of items' do
+      let(:user_item) do
+        [
+          { email: 'someone@somewhe.re' },
+          { email: 'someone.else@somewhe.re' }
+        ]
+      end
+
+      it 'responds to to_ary' do
+        expect(record.user.respond_to?(:to_ary)).to eq true
+      end
+    end
+  end
+end

data/spec/record/to_hash_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  before do
+    class Record < LHS::Record
+      endpoint 'http://datastore/records'
+    end
+  end
+
+  let(:item) { { name: 'Thomas' } }
+  let(:body) { [item] }
+
+  it 'converts itself to hash' do
+    stub_request(:get, "http://datastore/records")
+      .to_return(body: body.to_json)
+    record = Record.where.first
+    expect(record.to_h).to eq item
+    expect(record.to_hash).to eq item
+  end
+end

data/spec/record/to_json_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  context 'to_json' do
+    let(:datastore) { 'http://local.ch/v2' }
+
+    before do
+      LHC.config.placeholder('datastore', datastore)
+      class Feedback < LHS::Record
+        endpoint '{+datastore}/feedbacks'
+      end
+    end
+
+    it 'converts to json' do
+      feedback = Feedback.new recommended: true
+      expect(feedback.as_json).to eq('recommended' => true)
+      expect(feedback.to_json).to eq("{\"recommended\":true}")
+    end
+  end
+end

data/spec/record/tracing_spec.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+
+  context 'tracing' do
+    context 'with tracing enabled' do
+
+      before do
+        allow(LHS.config).to receive(:trace).and_return(true)
+      end
+
+      context 'with non-paginated methods' do
+
+        let(:request) do
+          stub_request(:get, "https://records/3jg781")
+            .to_return(status: 204)
+        end
+
+        before do
+          class Record < LHS::Record
+            endpoint 'https://records'
+          end
+
+          expect(LHC).to receive(:request).with(anything) do |arguments|
+            expect(arguments[:source]).to include(__FILE__)
+            spy(:response)
+          end
+        end
+
+        %w[find find_by find_by! first first! last!].each do |method|
+          context method do
+            it 'forwards tracing options to lhc' do
+              Record.public_send(method, color: :blue)
+            end
+          end
+        end
+      end
+
+      context 'with paginated method last' do
+
+        before do
+          class Place < LHS::Record
+            endpoint 'http://datastore/places'
+          end
+
+          stub_request(:get, "http://datastore/places?limit=1")
+            .to_return(
+              body: {
+                items:  [
+                  { id: 'first-1', company_name: 'Localsearch AG' }
+                ],
+                total:  500,
+                limit:  1,
+                offset: 0
+              }.to_json
+            )
+
+          stub_request(:get, "http://datastore/places?limit=1&offset=499")
+            .to_return(
+              body: {
+                items:  [
+                  { id: 'last-500', company_name: 'Curious GmbH' }
+                ],
+                total:  500,
+                limit:  1,
+                offset: 0
+              }.to_json
+            )
+
+          expect(LHC).to receive(:request).and_call_original
+          expect(LHC).to receive(:request).with(hash_including(params: { offset: 499, limit: 1 })) do |arguments|
+            expect(arguments[:source]).to include(__FILE__)
+            spy(:response)
+          end
+        end
+
+        it 'forwards tracing options to lhc' do
+          Place.last
+        end
+      end
+    end
+
+    context 'tracing disabled (default)' do
+      context 'non-paginated methods' do
+
+        before do
+          class Record < LHS::Record
+            endpoint 'https://records'
+          end
+
+          expect(LHC).to receive(:request).with(anything) do |arguments|
+            expect(arguments).not_to include(:source)
+            spy(:response)
+          end
+        end
+
+        %w[find find_by find_by! first first! last!].each do |method|
+          context method do
+            it 'does not forward tracing options to lhc' do
+              Record.public_send(method, color: :blue)
+            end
+          end
+        end
+      end
+
+      context 'with paginated method last' do
+        before do
+          class Place < LHS::Record
+            endpoint 'http://datastore/places'
+          end
+
+          stub_request(:get, "http://datastore/places?limit=1")
+            .to_return(
+              body: {
+                items:  [
+                  { id: 'first-1', company_name: 'Localsearch AG' }
+                ],
+                total:  500,
+                limit:  1,
+                offset: 0
+              }.to_json
+            )
+
+          stub_request(:get, "http://datastore/places?limit=1&offset=499")
+            .to_return(
+              body: {
+                items:  [
+                  { id: 'last-500', company_name: 'Curious GmbH' }
+                ],
+                total:  500,
+                limit:  1,
+                offset: 0
+              }.to_json
+            )
+        end
+
+        it 'does not forward tracing options to lhc' do
+          # for first pagination requets (first-1)
+          expect(LHC).to receive(:request).and_call_original
+
+          # for second reques (last-500)
+          expect(LHC).to receive(:request).with(hash_including(params: { offset: 499, limit: 1 })) do |arguments|
+            expect(arguments).not_to include(:source)
+            spy(:response)
+          end
+
+          Place.last
+        end
+      end
+    end
+  end
+end