lhs 24.0.0

data/spec/pagination/offset/pages_left_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  let(:offset) { 0 }
+  let(:data_hash) { { items: 98.times.map { { foo: 'bar' } }, total: 98, offset: offset, limit: 10 } }
+
+  let(:data) do
+    LHS::Data.new(data_hash, nil, Record)
+  end
+
+  let(:pagination) { LHS::Pagination::Offset.new(data) }
+
+  it 'responds to pages_left' do
+    expect(pagination.pages_left).to eq(9)
+  end
+
+  context 'when there is no offset' do
+    let(:offset) { nil }
+
+    it 'responds to pages_left' do
+      expect(pagination.pages_left).to eq(9)
+    end
+  end
+end

data/spec/pagination/parameters_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+require 'webrick'
+
+describe LHS::Record do
+
+  before do
+    class Location < LHS::Record
+      endpoint 'http://uberall/locations'
+      configuration(
+        limit_key: { body: %i[response max], parameter: :max },
+        pagination_key: { body: %i[response offset], parameter: :offset },
+        total_key: %i[response count],
+        items_key: %i[response locations],
+        pagination_strategy: :offset
+      )
+    end
+  end
+
+  context 'explicit pagination parameters for retrieving pages' do
+
+    it 'uses explicit parameters when retrieving pages' do
+      stub_request(:get, "http://uberall/locations?max=100")
+        .to_return(body: {
+          response: {
+            locations: 10.times.map { |_| { name: WEBrick::Utils.random_string(10) } },
+            max: 10,
+            offset: 0,
+            count: 30
+          }
+        }.to_json)
+
+      stub_request(:get, "http://uberall/locations?max=10&offset=10")
+        .to_return(body: {
+          response: {
+            locations: 10.times.map { |_| { name: WEBrick::Utils.random_string(10) } },
+            max: 10,
+            offset: 10,
+            count: 30
+          }
+        }.to_json)
+
+      stub_request(:get, "http://uberall/locations?max=10&offset=20")
+        .to_return(body: {
+          response: {
+            locations: 10.times.map { |_| { name: WEBrick::Utils.random_string(10) } },
+            max: 10,
+            offset: 20,
+            count: 30
+          }
+        }.to_json)
+
+      locations = Location.all.fetch
+      expect(locations.length).to eq 30
+      expect(locations.count).to eq 30
+      expect(locations.offset).to eq 20
+      expect(locations.limit).to eq 10
+    end
+  end
+end

data/spec/proxy/create_sub_resource_spec.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Item do
+  before do
+    class Feedback < LHS::Record
+      endpoint 'http://datastore/v2/feedbacks/{id}'
+    end
+
+    class Review < LHS::Record
+      endpoint 'http://datastore/v2/feedbacks/{feedback_id}/reviews'
+    end
+  end
+
+  context 'create sub-resource' do
+    let!(:create_review_request) do
+      stub_request(:post, "http://datastore/v2/feedbacks/1/reviews")
+        .to_return(body: {
+          href: 'http://datastore/v2/feedbacks/1/reviews/1',
+          title: 'Simply awesome'
+        }.to_json)
+    end
+
+    context 'for a nested item' do
+      let(:feedback) { Feedback.find(1) }
+      let(:review) do
+        feedback.review.create(
+          title: 'Simply awesome'
+        )
+      end
+
+      before do
+        stub_request(:get, "http://datastore/v2/feedbacks/1/reviews")
+          .to_return(body: {
+            href: 'http://datastore/v2/feedbacks/1/reviews',
+            title: 'Simply awesome'
+          }.to_json)
+      end
+
+      context 'without the object' do
+        before do
+          stub_request(:get, "http://datastore/v2/feedbacks/1")
+            .to_return(body: {
+              review: {
+                href: 'http://datastore/v2/feedbacks/1/reviews'
+              }
+            }.to_json)
+        end
+
+        it 'creates an item' do
+          review
+          assert_requested(create_review_request)
+
+          expect(feedback.review.title).to eq 'Simply awesome'
+          expect(review.title).to eq 'Simply awesome'
+        end
+      end
+
+      context 'with existing item' do
+        before do
+          stub_request(:get, "http://datastore/v2/feedbacks/1")
+            .to_return(body: {
+              review: {
+                href: 'http://datastore/v2/feedbacks/1/reviews',
+                title: 'Simply awesome'
+              }
+            }.to_json)
+        end
+
+        it 'raises error' do
+          expect { review }.to raise_error(ArgumentError)
+
+          assert_not_requested(create_review_request)
+        end
+      end
+    end
+
+    context 'for a nested collection' do
+      let(:review) do
+        feedback.reviews.create(
+          title: 'Simply awesome'
+        )
+      end
+
+      before do
+        stub_request(:get, "http://datastore/v2/feedbacks/1/reviews")
+          .to_return(body: {
+            items: [{
+              href: 'http://datastore/v2/feedbacks/1/reviews/1',
+              title: 'Simply awesome'
+            }]
+          }.to_json)
+      end
+
+      context 'when expanded' do
+        before do
+          stub_request(:get, "http://datastore/v2/feedbacks/1")
+            .to_return(body: {
+              reviews: {
+                href: 'http://datastore/v2/feedbacks/1/reviews',
+                items: []
+              }
+            }.to_json)
+        end
+
+        let(:feedback) { Feedback.includes(:reviews).find(1) }
+
+        it 'creates an item' do
+          review
+          assert_requested(create_review_request)
+
+          expect(feedback.reviews.first.title).to eq 'Simply awesome'
+          expect(review.title).to eq 'Simply awesome'
+        end
+      end
+
+      context 'when not expanded' do
+        before do
+          stub_request(:get, "http://datastore/v2/feedbacks/1")
+            .to_return(body: {
+              reviews: {
+                href: 'http://datastore/v2/feedbacks/1/reviews'
+              }
+            }.to_json)
+        end
+
+        let(:feedback) { Feedback.find(1) }
+
+        it 'creates an item' do
+          review
+          assert_requested(create_review_request)
+
+          expect(feedback.reviews.first.title).to eq 'Simply awesome'
+          expect(review.title).to eq 'Simply awesome'
+        end
+      end
+    end
+  end
+
+  context 'error messages' do
+    let!(:create_review_request) do
+      stub_request(:post, "http://datastore/v2/feedbacks/1/reviews")
+        .to_return(
+          status: 400,
+          body: {
+            status: 400,
+            message: 'Validation failed',
+            field_errors: [{
+              code: 'UNSATISFIED_PROPERTY_VALUE_MAXIMUM_LENGTH',
+              path: ['title'],
+              message: 'Title is too long'
+            }]
+          }.to_json
+        )
+    end
+
+    let(:feedback) { Feedback.find(1) }
+    let(:review) do
+      feedback.review.create(
+        title: 'Simply awesome'
+      )
+    end
+
+    before do
+      stub_request(:get, "http://datastore/v2/feedbacks/1")
+        .to_return(body: {
+          review: {
+            href: 'http://datastore/v2/feedbacks/1/reviews'
+          }
+        }.to_json)
+    end
+
+    it 'are propagated when creation fails' do
+      review
+      assert_requested(create_review_request)
+
+      expect(review.title).to eq 'Simply awesome'
+      expect(review.errors.messages[:title]).to include('UNSATISFIED_PROPERTY_VALUE_MAXIMUM_LENGTH')
+    end
+  end
+end

data/spec/proxy/load_spec.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Proxy do
+  before do
+    class Record < LHS::Record
+      endpoint '{+datastore}/v2/feedbacks'
+    end
+
+    stub_request(:get, 'http://local.ch/v2/content-ads/51dfc5690cf271c375c5a12d')
+      .to_return(status: 200, body: load_json(:localina_content_ad))
+  end
+
+  let(:json) do
+    load_json(:feedbacks)
+  end
+
+  let(:data) do
+    LHS::Data.new(json, nil, Record)
+  end
+
+  let(:item) do
+    data[0]
+  end
+
+  let(:link) do
+    item.campaign
+  end
+
+  context 'load' do
+    it 'is loading data remotely when not present yet' do
+      expect(link.load!.id).to be_present
+      expect(link.id).to be_present
+    end
+
+    it 'can be reloaded' do
+      expect(link.load!.id).to be_present
+      stub_request(:get, 'http://local.ch/v2/content-ads/51dfc5690cf271c375c5a12d')
+        .to_return(status: 404)
+      expect(-> { link.reload!.id })
+        .to raise_error LHC::NotFound
+    end
+  end
+
+  context 'endpoint options' do
+    before do
+      class AnotherRecord < LHS::Record
+        endpoint '{+datastore}/v2/feedbacks', params: { color: :blue }
+      end
+    end
+
+    let(:record) do
+      AnotherRecord.new(href: 'http://datastore/v2/feedbacks')
+    end
+
+    it 'applies endpoint options on load!' do
+      stub_request(:get, 'http://datastore/v2/feedbacks?color=blue')
+        .to_return(body: {}.to_json)
+      record.load!
+    end
+  end
+
+  context 'per request options' do
+    let(:record) do
+      Record.new(href: 'http://datastore/v2/feedbacks')
+    end
+
+    it 'applies options passed to load' do
+      stub_request(:get, 'http://datastore/v2/feedbacks?color=blue')
+        .to_return(body: {}.to_json)
+      record.load!(params: { color: 'blue' })
+    end
+  end
+end

data/spec/proxy/record_identification_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Proxy do
+  before do
+    class Search < LHS::Record
+      endpoint 'http://search/results', items_key: :docs
+    end
+
+    class Feedback < LHS::Record
+      endpoint 'http://datastore/places/{place_id}/feedbacks'
+    end
+  end
+
+  context 'identifying records' do
+    it 'identifies records correctly even if parent record has another configuration set' do
+      stub_request(:get, "http://search/results?what=Blumen")
+        .to_return(body: {
+          place: { href: 'http://datastore/places/1' }
+        }.to_json)
+      stub_request(:get, "http://datastore/places/1")
+        .to_return(body: {
+          feedbacks: { href: 'http://datastore/places/1/feedbacks?limit=10&offset=0' }
+        }.to_json)
+      stub_request(:get, "http://datastore/places/1/feedbacks?limit=10&offset=0")
+        .to_return(body: {
+          items: [{ review: 'Nice restaurant' }]
+        }.to_json)
+      result = Search.where(what: 'Blumen').includes_first_page(place: :feedbacks)
+      expect(result.place.feedbacks).to be_kind_of Feedback
+      expect(result.place.feedbacks.first.review).to eq 'Nice restaurant'
+    end
+  end
+end

data/spec/rails_helper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+ENV["RAILS_ENV"] ||= 'test'
+ENV['DUMMYAPP_PATH'] = "spec/dummy"
+
+require 'rails/rollbar_runner'
+require 'spec_helper'
+require File.expand_path("../dummy/config/environment", __FILE__)
+require 'rspec/rails'
+
+RSpec.configure do |config|
+  config.infer_spec_type_from_file_location!
+end

data/spec/record/all_spec.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  context 'all' do
+    before do
+      class Record < LHS::Record
+        endpoint 'http://datastore/feedbacks'
+      end
+    end
+
+    it 'is querying endpoint without pagination when using all' do
+      stub_request(:get, "http://datastore/feedbacks?limit=100").to_return(body: { items: 300.times.map { { foo: 'bar' } }, total: 300 }.to_json)
+      records = Record.all
+      expect(records).to be_kind_of Record
+      expect(records.size).to eq(300)
+    end
+
+    context 'is chainable with where and works like where' do
+      let(:total) { 22 }
+      let(:limit) { 10 }
+      let!(:first_page_request) do
+        stub_request(:get, "http://datastore/feedbacks?color=blue&limit=100")
+          .to_return(body: { items: 10.times.map { { foo: 'bar' } }, total: total, limit: limit, offset: 0 }.to_json)
+      end
+      let!(:second_page_request) do
+        stub_request(:get, "http://datastore/feedbacks?color=blue&limit=#{limit}&offset=10")
+          .to_return(body: { items: 10.times.map { { foo: 'bar' } }, total: total, limit: limit, offset: 10 }.to_json)
+      end
+      let!(:third_page_request) do
+        stub_request(:get, "http://datastore/feedbacks?color=blue&limit=#{limit}&offset=20")
+          .to_return(body: { items: 2.times.map { { foo: 'bar' } }, total: total, limit: limit, offset: 20 }.to_json)
+      end
+
+      it 'fetches all remote objects' do
+        records = Record.where(color: 'blue').all
+        expect(records.length).to eq total
+        expect(first_page_request).to have_been_requested.times(1)
+        expect(second_page_request).to have_been_requested.times(1)
+        expect(third_page_request).to have_been_requested.times(1)
+        records = Record.all.where(color: 'blue')
+        expect(records.length).to eq total
+        expect(first_page_request).to have_been_requested.times(2)
+        expect(second_page_request).to have_been_requested.times(2)
+        expect(third_page_request).to have_been_requested.times(2)
+        records = Record.all(color: 'blue')
+        expect(records.length).to eq total
+        expect(first_page_request).to have_been_requested.times(3)
+        expect(second_page_request).to have_been_requested.times(3)
+        expect(third_page_request).to have_been_requested.times(3)
+      end
+
+      it 'works in combination with include and includes' do
+        records = Record.includes_first_page(:product).includes(:options).all(color: 'blue')
+        expect(records.length).to eq total
+        expect(first_page_request).to have_been_requested.times(1)
+        expect(second_page_request).to have_been_requested.times(1)
+        expect(third_page_request).to have_been_requested.times(1)
+      end
+    end
+  end
+
+  context 'all without current page indicator' do
+    before do
+      class Category < LHS::Record
+        configuration(
+          items_key: %i(response results),
+          limit_key: :max,
+          pagination_key: :offset,
+          pagination_strategy: :offset
+        )
+
+        endpoint 'http://store/categories'
+      end
+    end
+
+    def stub_batch(url, items = 10)
+      stub_request(:get, url)
+        .to_return(
+          body: {
+            response: {
+              results: items.times.map { { name: 'category' } }
+            }
+          }.to_json
+        )
+    end
+
+    it 'is able to fetch all remote objects without any current page indicator by simply increasing the offset until response is empty with a limit' do
+      stub_batch('http://store/categories?language=en&max=10&offset=0')
+      stub_batch('http://store/categories?language=en&max=10&offset=10')
+      stub_batch('http://store/categories?language=en&max=10&offset=20')
+      stub_batch('http://store/categories?language=en&max=10&offset=30', 0)
+      records = Category.limit(10).all(language: 'en').fetch
+      expect(records.length).to eq 30
+    end
+
+    it 'is able to fetch all remote objects without any current page indicator by simply increasing the offset until response is empty' do
+      stub_batch('http://store/categories?language=en&max=100', 100)
+      stub_batch('http://store/categories?language=en&max=100&offset=100', 100)
+      stub_batch('http://store/categories?language=en&max=100&offset=200', 100)
+      stub_batch('http://store/categories?language=en&max=100&offset=300', 0)
+      records = Category.all(language: 'en').fetch
+      expect(records.length).to eq 300
+    end
+
+    it 'outputs a warning, if all is requested, but endpoint does not implement pagination meta data' do
+      stub_batch('http://store/categories?language=en&max=100', 100)
+      stub_batch('http://store/categories?language=en&max=100&offset=100', 100)
+      stub_batch('http://store/categories?language=en&max=100&offset=200', 100)
+      stub_batch('http://store/categories?language=en&max=100&offset=300', 0)
+      expect(-> { Category.all(language: 'en').fetch }).to output(
+        %r{\[Warning\] "all" has been requested, but endpoint does not provide pagination meta data. If you just want to fetch the first response, use "where" or "fetch".}
+      ).to_stderr
+    end
+
+    context 'with record set to not paginated' do
+      before do
+        class Record < LHS::Record
+          configuration paginated: false
+          endpoint 'http://datastore/records'
+        end
+      end
+
+      it 'just fetches the first response' do
+        stub_request(:get, "http://datastore/records")
+          .to_return(body: [{ name: 'Steve' }].to_json)
+        records = Record.all
+        expect(records.first.name).to eq 'Steve'
+      end
+    end
+  end
+end