lhs 24.0.0

data/spec/record/includes_spec.rb

@@ -0,0 +1,693 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  context 'includes all' do
+    before do
+      class Customer < LHS::Record
+        endpoint 'http://datastore/customers/{id}'
+      end
+
+      class User < LHS::Record
+        configuration pagination_strategy: 'link'
+        endpoint 'http://datastore/users'
+      end
+    end
+
+    let(:amount_of_contracts) { 33 }
+    let(:amount_of_products) { 22 }
+    let(:amount_of_users_1st_page) { 10 }
+    let(:amount_of_users_2nd_page) { 3 }
+    let(:amount_of_users) { amount_of_users_1st_page + amount_of_users_2nd_page }
+
+    let!(:customer_request) do
+      stub_request(:get, 'http://datastore/customers/1')
+        .to_return(
+          body: {
+            contracts: { href: 'http://datastore/customers/1/contracts' },
+            users: { href: 'http://datastore/users?limit=10' }
+          }.to_json
+        )
+    end
+
+    #
+    # Contracts
+    #
+
+    let!(:contracts_request) do
+      stub_request(:get, "http://datastore/customers/1/contracts?limit=100")
+        .to_return(
+          body: {
+            items: 10.times.map do
+              {
+                products: { href: 'http://datastore/products' }
+              }
+            end,
+            limit: 10,
+            offset: 0,
+            total: amount_of_contracts
+          }.to_json
+        )
+    end
+
+    def additional_contracts_request(offset, amount)
+      stub_request(:get, "http://datastore/customers/1/contracts?limit=10&offset=#{offset}")
+        .to_return(
+          body: {
+            items: amount.times.map do
+              {
+                products: { href: 'http://datastore/products' }
+              }
+            end,
+            limit: 10,
+            offset: offset,
+            total: amount_of_contracts
+          }.to_json
+        )
+    end
+
+    let!(:contracts_request_page_2) do
+      additional_contracts_request(10, 10)
+    end
+
+    let!(:contracts_request_page_3) do
+      additional_contracts_request(20, 10)
+    end
+
+    let!(:contracts_request_page_4) do
+      additional_contracts_request(30, 3)
+    end
+
+    #
+    # Products
+    #
+
+    let!(:products_request) do
+      stub_request(:get, "http://datastore/products?limit=100")
+        .to_return(
+          body: {
+            items: 10.times.map do
+              { name: 'LBC' }
+            end,
+            limit: 10,
+            offset: 0,
+            total: amount_of_products
+          }.to_json
+        )
+    end
+
+    def additional_products_request(offset, amount)
+      stub_request(:get, "http://datastore/products?limit=10&offset=#{offset}")
+        .to_return(
+          body: {
+            items: amount.times.map do
+              { name: 'LBC' }
+            end,
+            limit: 10,
+            offset: offset,
+            total: amount_of_products
+          }.to_json
+        )
+    end
+
+    let!(:products_request_page_2) do
+      additional_products_request(10, 10)
+    end
+
+    let!(:products_request_page_3) do
+      additional_products_request(20, 2)
+    end
+
+    #
+    # Users
+    #
+
+    let!(:users_request) do
+      stub_request(:get, 'http://datastore/users?limit=10')
+        .to_return(
+          body: {
+            items: amount_of_users_1st_page.times.map do
+              { name: 'Hans Muster' }
+            end,
+            limit: 10,
+            next: { href: 'http://datastore/users?for_user_id=10&limit=10' }
+          }.to_json
+        )
+    end
+
+    let!(:users_request_page_2) do
+      stub_request(:get, 'http://datastore/users?for_user_id=10&limit=10')
+        .to_return(
+          body: {
+            items: amount_of_users_2nd_page.times.map do
+              { name: 'Lisa Müller' }
+            end,
+            limit: 10,
+            next: { href: 'http://datastore/users?for_user_id=13&limit=10' }
+          }.to_json
+        )
+    end
+
+    let!(:users_request_page_3) do
+      stub_request(:get, 'http://datastore/users?for_user_id=13&limit=10')
+        .to_return(
+          body: {
+            items: [],
+            limit: 10
+          }.to_json
+        )
+    end
+
+    it 'includes all linked business objects no matter pagination' do
+      customer = nil
+
+      expect(lambda do
+        customer = Customer
+          .includes(:users, contracts: :products)
+          .find(1)
+      end).to output(
+        %r{\[WARNING\] You are loading all pages from a resource paginated with links only. As this is performed sequentially, it can result in very poor performance! \(https://github.com/local-ch/lhs#pagination-strategy-link\).}
+      ).to_stderr
+
+      expect(customer.users.length).to eq amount_of_users
+      expect(customer.contracts.length).to eq amount_of_contracts
+      expect(customer.contracts.first.products.length).to eq amount_of_products
+      expect(customer_request).to have_been_requested.at_least_once
+      expect(contracts_request).to have_been_requested.at_least_once
+      expect(contracts_request_page_2).to have_been_requested.at_least_once
+      expect(contracts_request_page_3).to have_been_requested.at_least_once
+      expect(contracts_request_page_4).to have_been_requested.at_least_once
+      expect(products_request).to have_been_requested.at_least_once
+      expect(products_request_page_2).to have_been_requested.at_least_once
+      expect(products_request_page_3).to have_been_requested.at_least_once
+      expect(users_request).to have_been_requested.at_least_once
+      expect(users_request_page_2).to have_been_requested.at_least_once
+      expect(users_request_page_3).to have_been_requested.at_least_once
+    end
+
+    context 'links already contain pagination parameters' do
+      let!(:customer_request) do
+        stub_request(:get, 'http://datastore/customers/1')
+          .to_return(
+            body: {
+              contracts: { href: 'http://datastore/customers/1/contracts?limit=5&offset=0' }
+            }.to_json
+          )
+      end
+
+      let!(:contracts_request) do
+        stub_request(:get, "http://datastore/customers/1/contracts?limit=100")
+          .to_return(
+            body: {
+              items: 10.times.map do
+                {
+                  products: { href: 'http://datastore/products' }
+                }
+              end,
+              limit: 10,
+              offset: 0,
+              total: amount_of_contracts
+            }.to_json
+          )
+      end
+
+      it 'overwrites existing pagination paramters if they are already contained in a string' do
+        expect(LHC).to receive(:request)
+          .with(url: "http://datastore/customers/1").and_call_original
+
+        expect(LHC).to receive(:request)
+          .with(url: "http://datastore/customers/1/contracts",
+                all: true,
+                params: { limit: 100 }).and_call_original
+
+        expect(LHC).to receive(:request)
+          .with([{ url: "http://datastore/customers/1/contracts",
+                   all: true,
+                   params: { limit: 10, offset: 10 } },
+                 { url: "http://datastore/customers/1/contracts",
+                   all: true,
+                   params: { limit: 10, offset: 20 } },
+                 { url: "http://datastore/customers/1/contracts",
+                   all: true,
+                   params: { limit: 10, offset: 30 } }]).and_call_original
+
+        customer = Customer
+          .includes(:contracts)
+          .find(1)
+        expect(customer.contracts.length).to eq amount_of_contracts
+      end
+    end
+
+    context 'includes for an empty array' do
+      before do
+        class Contract < LHS::Record
+          endpoint 'http://datastore/contracts/{id}'
+        end
+        stub_request(:get, %r{http://datastore/contracts/\d})
+          .to_return(body: {
+            options: nested_resources
+          }.to_json)
+      end
+
+      context 'empty array' do
+        let(:nested_resources) { [] }
+
+        it 'includes all in case of an empty array' do
+          expect(
+            -> { Contract.includes(:product).includes(:options).find(1) }
+          ).not_to raise_error
+          expect(
+            -> { Contract.includes(:product).includes(:options).find(1, 2) }
+          ).not_to raise_error
+        end
+      end
+
+      context 'weird array without hrefs' do
+        before do
+          stub_request(:get, "http://datastore/options/1?limit=100")
+            .to_return(body: { type: 'REACH_EXT' }.to_json)
+        end
+
+        let(:nested_resources) { [{ href: 'http://datastore/options/1' }, { type: 'E_COMMERCE' }] }
+
+        it 'includes in case of an unexpect objects within array' do
+          expect(
+            -> { Contract.includes(:product).includes(:options).find(1) }
+          ).not_to raise_error
+          expect(
+            -> { Contract.includes(:product).includes(:options).find(1, 2) }
+          ).not_to raise_error
+        end
+      end
+    end
+
+    context 'include a known/identifiable record' do
+      before do
+        class Contract < LHS::Record
+          endpoint 'http://datastore/contracts/{id}'
+        end
+
+        class Entry < LHS::Record
+          endpoint '{+datastore}/entry/v1/{id}.json'
+        end
+
+        LHC.config.placeholder(:datastore, 'http://datastore')
+      end
+
+      let!(:customer_request) do
+        stub_request(:get, %r{http://datastore/customers/\d+})
+          .to_return(
+            body: {
+              contracts: [{ href: 'http://datastore/contracts/1' }, { href: 'http://datastore/contracts/2' }]
+            }.to_json
+          )
+      end
+
+      let!(:contracts_request) do
+        stub_request(:get, %r{http://datastore/contracts/\d+})
+          .to_return(
+            body: {
+              type: 'contract',
+              entry: { href: 'http://datastore/entry/v1/1.json' }
+            }.to_json
+          )
+      end
+
+      let!(:entry_request) do
+        stub_request(:get, %r{http://datastore/entry/v1/\d+.json})
+          .to_return(
+            body: {
+              name: 'Casa Ferlin'
+            }.to_json
+          )
+      end
+
+      it 'loads included identifiable records without raising exceptions' do
+        customer = Customer.includes(contracts: :entry).find(1, 2).first
+        expect(customer.contracts.first.href).to eq 'http://datastore/contracts/1'
+        expect(customer.contracts.first.type).to eq 'contract'
+        expect(customer.contracts.first.entry.name).to eq 'Casa Ferlin'
+      end
+    end
+
+    context 'includes all for parallel loaded ids' do
+      before do
+        class Place < LHS::Record
+          endpoint 'http://datastore/places/{id}'
+        end
+      end
+
+      let!(:place_request_1) do
+        stub_request(:get, %r{http://datastore/places/1})
+          .to_return(
+            body: {
+              category_relations: [
+                { href: 'http://datastore/category_relations/1' },
+                { href: 'http://datastore/category_relations/2' }
+              ]
+            }.to_json
+          )
+      end
+
+      let!(:place_request_2) do
+        stub_request(:get, %r{http://datastore/places/2})
+          .to_return(
+            body: {
+              category_relations: []
+            }.to_json
+          )
+      end
+
+      let!(:place_request_3) do
+        stub_request(:get, %r{http://datastore/places/3})
+          .to_return(
+            body: {
+              category_relations: [
+                { href: 'http://datastore/category_relations/1' },
+                { href: 'http://datastore/category_relations/3' }
+              ]
+            }.to_json
+          )
+      end
+
+      let!(:category_relation_request_1) do
+        stub_request(:get, %r{http://datastore/category_relations/1})
+          .to_return(
+            body: {
+              name: "Category 1"
+            }.to_json
+          )
+      end
+
+      let!(:category_relation_request_2) do
+        stub_request(:get, %r{http://datastore/category_relations/2})
+          .to_return(
+            body: {
+              name: "Category 2"
+            }.to_json
+          )
+      end
+
+      let!(:category_relation_request_3) do
+        stub_request(:get, %r{http://datastore/category_relations/3})
+          .to_return(
+            body: {
+              name: "Category 3"
+            }.to_json
+          )
+      end
+
+      let(:category_name) { 'Category Relation' }
+
+      it 'requests places in parallel and includes category relation' do
+        places = Place.includes(:category_relations).find(1, 2, 3)
+        expect(places[0].category_relations[0].name).to eq 'Category 1'
+        expect(places[0].category_relations[1].name).to eq 'Category 2'
+        expect(places[2].category_relations[0].name).to eq 'Category 1'
+        expect(places[2].category_relations[1].name).to eq 'Category 3'
+      end
+    end
+  end
+
+  context 'Linked resources' do
+    before do
+      stub_request(:get, 'http://datastore/places/1/contracts?offset=0&limit=10')
+        .to_return(
+          body: {
+            href:  "http://datastore/v2/places/1/contracts?offset=0&limit=10",
+            items: [{ href: "http://datastore/v2/contracts/1" }],
+            offset: 0,
+            limit: 10,
+            total: 10
+          }.to_json
+        )
+
+      stub_request(:get, "http://datastore/v2/contracts/1")
+        .to_return(
+          body: {
+            customer: { name: 'Swisscom Directories AG' }
+          }.to_json
+        )
+
+      stub_request(:get, 'http://datastore/places/1?limit=1')
+        .to_return(
+          body: { href: 'http://datastore/places/1', contracts: { href: 'http://datastore/places/1/contracts?offset=0&limit=10' } }.to_json
+        )
+
+      class Place < LHS::Record
+        endpoint 'http://datastore/places/{id}'
+      end
+
+      class Contract < LHS::Record
+        endpoint 'http://datastore/places/{place_id}/contracts'
+      end
+    end
+
+    it 'does not use the root record endpoints when including nested records' do
+      place = Place
+        .includes(:contracts)
+        .find_by(id: 1)
+      expect(place.contracts.first.customer.name).to eq 'Swisscom Directories AG'
+    end
+  end
+
+  context 'nested includes all' do
+    context 'with optional children' do
+
+      let(:favorites_request_stub) do
+        stub_request(:get, %r{http://datastore/favorites})
+          .to_return(
+            body: {
+              items: [{
+                href: "http://datastore/favorites/1",
+                place: {
+                  href: "http://datastore/places/1"
+                }
+              }, {
+                href: "http://datastore/favorite/2",
+                place: {
+                  href: "http://datastore/places/2"
+                }
+              }, {
+                href: "http://datastore/favorite/3",
+                place: {
+                  href: "http://datastore/places/3"
+                }
+              }],
+              total: 3,
+              offset: 0,
+              limit: 100
+            }.to_json
+          )
+      end
+
+      let(:place1_request_stub) do
+        stub_request(:get, %r{http://datastore/places/1})
+          .to_return(
+            body: {
+              href: "http://datastore/places/1",
+              name: 'Place 1',
+              contracts: {
+                href: "http://datastore/places/1/contracts"
+              }
+            }.to_json
+          )
+      end
+
+      let(:place2_request_stub) do
+        stub_request(:get, %r{http://datastore/places/2})
+          .to_return(
+            body: {
+              href: "http://datastore/places/2",
+              name: 'Place 2'
+            }.to_json
+          )
+      end
+
+      let(:place3_request_stub) do
+        stub_request(:get, %r{http://datastore/places/3})
+          .to_return(
+            body: {
+              href: "http://datastore/places/3",
+              name: 'Place 3',
+              contracts: {
+                href: "http://datastore/places/3/contracts"
+              }
+            }.to_json
+          )
+      end
+
+      let(:contracts_request_for_place1_stub) do
+        stub_request(:get, %r{http://datastore/places/1/contracts})
+          .to_return(
+            body: {
+              items: [{
+                href: "http://datastore/places/1/contracts/1",
+                name: 'Contract 1'
+              }],
+              total: 1,
+              offset: 0,
+              limit: 10
+            }.to_json
+          )
+      end
+
+      let(:contracts_request_for_place3_stub) do
+        stub_request(:get, %r{http://datastore/places/3/contracts})
+          .to_return(
+            body: {
+              items: [{
+                href: "http://datastore/places/3/contracts/1",
+                name: 'Contract 3'
+              }],
+              total: 1,
+              offset: 0,
+              limit: 10
+            }.to_json
+          )
+      end
+
+      before do
+        class Favorite < LHS::Record
+          endpoint 'http://datastore/favorites'
+        end
+
+        class Place < LHS::Record
+          endpoint 'http://datastore/places/{id}'
+        end
+
+        class Contract < LHS::Record
+          endpoint 'http://datastore/places/{place_id}/contracts'
+        end
+
+        favorites_request_stub
+        place1_request_stub
+        place2_request_stub
+        place3_request_stub
+        contracts_request_for_place1_stub
+        contracts_request_for_place3_stub
+      end
+
+      it 'includes nested objects when they exist' do
+        favorites = Favorite.includes(:place).includes(place: :contracts).all
+
+        expect(favorites.first.place.name).to eq('Place 1')
+        expect(favorites.first.place.contracts.first.name).to eq('Contract 1')
+      end
+
+      it 'does not include nested objects when they are not there' do
+        favorites = Favorite.includes(:place).includes(place: :contracts).all
+
+        expect(favorites[1].place.name).to eq('Place 2')
+        expect(favorites[1].place.contracts).to be(nil)
+      end
+
+      it 'does include and merges objects after nil objects in collections' do
+        favorites = Favorite.includes(:place).includes(place: :contracts).all
+
+        expect(favorites.last.place.name).to eq('Place 3')
+        expect(favorites.last.place.contracts.first.name).to eq('Contract 3')
+      end
+    end
+  end
+
+  context 'includes collection trough single item' do
+
+    before do
+      class Place < LHS::Record
+        endpoint 'https://places/{id}'
+      end
+
+      stub_request(:get, 'https://places/1')
+        .to_return(
+          body: {
+            customer: { href: 'https://customers/1' }
+          }.to_json
+        )
+
+      stub_request(:get, 'https://customers/1?limit=100')
+        .to_return(
+          body: {
+            addresses: { 'href': 'https://customer/1/addresses' }
+          }.to_json
+        )
+
+      stub_request(:get, 'https://customer/1/addresses?limit=100')
+        .to_return(
+          body: {
+            items: [
+              { city: 'Zurich', no: 1 },
+              { city: 'Zurich', no: 2 }
+            ],
+            total: 2
+          }.to_json
+        )
+    end
+
+    it 'includes a collection trough a single item without exceptions' do
+      place = Place
+        .includes(customer: :addresses)
+        .find(1)
+      expect(place.customer.addresses.map(&:no)).to eq [1, 2]
+    end
+  end
+
+  context 'does not fail including all linked resources' do
+
+    before do
+      class CustomerOnboardingToken < LHS::Record
+        endpoint 'https://token/{id}'
+      end
+
+      class Place < LHS::Record
+        endpoint 'https://places/{id}'
+      end
+
+      class AvailableAsset < LHS::Record
+        endpoint 'https://assets'
+      end
+
+      stub_request(:get, 'https://token/1')
+        .to_return(
+          body: {
+            places: [{ href: 'https://places/1' }]
+          }.to_json
+        )
+
+      stub_request(:get, 'https://places/1?limit=100')
+        .to_return(
+          body: {
+            available_assets: { 'href': 'https://assets?limit=10&offset=0' }
+          }.to_json
+        )
+
+      stub_request(:get, 'https://assets?limit=10&offset=0')
+        .to_return(
+          body: {
+            items: 10.times.map { { asset_code: 'CATEGORIES' } },
+            total: 17,
+            offset: 0,
+            limit: 10
+          }.to_json
+        )
+
+      stub_request(:get, 'https://assets?limit=10&offset=10')
+        .to_return(
+          body: {
+            items: 7.times.map { { asset_code: 'CATEGORIES' } },
+            total: 17,
+            offset: 0,
+            limit: 10
+          }.to_json
+        )
+    end
+
+    it 'includes a collection trough a single item without exceptions' do
+      token = CustomerOnboardingToken
+        .includes(places: :available_assets)
+        .find(1)
+      expect(token.places.first.available_assets.length).to eq 17
+    end
+  end
+end