lhs 24.0.0

data/spec/autoloading_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+describe LHS, type: :request do
+  context 'autoloading' do
+
+    let(:endpoints) { LHS::Record::Endpoints.all }
+
+    it "pre/re-loads all LHS classes initialy, because it's necessary for endpoint-to-record-class-discovery", reset_before: false do
+
+      expect(endpoints['http://datastore/v2/users']).to be_present
+      expect(endpoints['http://datastore/v2/users/{id}']).to be_present
+
+      expect(
+        DummyUser.endpoints.detect { |endpoint| endpoint.url == 'http://datastore/v2/users' }
+      ).to be_present
+      expect(
+        DummyUser.endpoints.detect { |endpoint| endpoint.url == 'http://datastore/v2/users/{id}' }
+      ).to be_present
+    end
+
+    it "also pre/re-loads all LHS classes that inherited from an LHS provider, because it's necessary for endpoint-to-record-class-discovery", reset_before: false do
+
+      expect(endpoints['http://customers']).to be_present
+      expect(endpoints['http://customers/{id}']).to be_present
+
+      expect(
+        DummyCustomer.endpoints.detect { |endpoint| endpoint.url == 'http://customers' }
+      ).to be_present
+      expect(
+        DummyCustomer.endpoints.detect { |endpoint| endpoint.url == 'http://customers/{id}' }
+      ).to be_present
+
+      customer_request = stub_request(:get, "http://customers/1")
+        .with(
+          headers: {
+            'Authorization' => 'token123'
+          }
+        )
+        .to_return(body: { name: 'Steve' }.to_json)
+
+      DummyCustomer.find(1)
+
+      expect(customer_request).to have_been_requested
+    end
+  end
+end

data/spec/collection/accessors_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Collection do
+  let(:items) { [{ name: 'Steve' }] }
+  let(:extra) { 'extra' }
+  let(:collection) { Record.where }
+
+  context 'accessors' do
+    let(:response_data) do
+      {
+        items: items,
+        extra: extra,
+        total: 1
+      }
+    end
+
+    before do
+      class Record < LHS::Record
+        endpoint 'http://datastore/records`'
+      end
+      stub_request(:get, %r{http://datastore/records})
+        .to_return(body: response_data.to_json)
+    end
+
+    it 'allows access to extra data passed with collection' do
+      expect(collection.extra).to eq(extra)
+    end
+  end
+end

data/spec/collection/collection_items_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Collection do
+  let(:datastore) { 'http://local.ch/v2' }
+  let(:items) { [{ name: 'Steve' }] }
+  let(:collection) { Account.where }
+
+  before do
+    LHC.config.placeholder('datastore', datastore)
+    class Account < LHS::Record
+      endpoint '{+datastore}/accounts'
+    end
+    stub_request(:get, "http://local.ch/v2/accounts")
+      .to_return(body: response_data.to_json)
+  end
+
+  context 'plain array' do
+    let(:response_data) do
+      items
+    end
+
+    it 'initalises a collection' do
+      expect(collection.first.name).to eq 'Steve'
+    end
+
+    it 'casts items to be instance of defined LHS::Record' do
+      expect(collection.first).to be_kind_of Account
+    end
+  end
+
+  context 'items key' do
+    let(:response_data) do
+      {
+        items: items
+      }
+    end
+
+    it 'initalises a collection when reponse contains a key items containing an array of items' do
+      expect(collection.first.name).to eq 'Steve'
+    end
+  end
+end

data/spec/collection/configurable_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Collection do
+  let(:search) { 'http://local.ch/search' }
+  let(:limit) { 10 }
+  let(:total) { 20 }
+
+  before do
+    LHC.config.placeholder('search', search)
+    class Search < LHS::Record
+      configuration items_key: :docs, limit_key: :size, pagination_key: :start, pagination_strategy: :start, total_key: :totalResults
+      endpoint '{+search}/{type}'
+    end
+    stub_request(:get, "http://local.ch/search/phonebook?size=10").to_return(
+      body: {
+        docs: (1..10).to_a,
+        start: 1,
+        size: limit,
+        totalResults: total
+      }.to_json
+    )
+    stub_request(:get, "http://local.ch/search/phonebook?size=10&start=11").to_return(
+      body: {
+        docs: (11..20).to_a,
+        start: 11,
+        size: limit,
+        totalResults: total
+      }.to_json
+    )
+  end
+
+  context 'lets you configure how to deal with collections' do
+    it 'initalises and gives access to collections according to configuration' do
+      results = Search.all(type: :phonebook, size: 10)
+      expect(results.count).to eq total
+      expect(results.total).to eq total
+      expect(results.limit).to eq limit
+      expect(results.offset).to eq 11
+    end
+  end
+end

data/spec/collection/delegate_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Collection do
+  let(:data) do
+    ['ROLE_USER', 'ROLE_LOCALCH_ACCOUNT']
+  end
+
+  let(:collection) do
+    LHS::Collection.new(LHS::Data.new(data))
+  end
+
+  context 'delegates methods to raw' do
+    %w(length size last sample present? blank? empty? compact).each do |method|
+      it "delegates #{method} to raw" do
+        expect(collection.send(method.to_sym)).not_to be_nil
+      end
+    end
+  end
+end

data/spec/collection/enumerable_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Collection do
+  let(:data) do
+    [1, 2, 3]
+  end
+
+  let(:collection) do
+    LHS::Collection.new(LHS::Data.new(data))
+  end
+
+  context 'enumerable' do
+    it 'works with map' do
+      expect(
+        collection.map { |x| x + 1 }
+      ).to eq [2, 3, 4]
+    end
+
+    it 'works with select' do
+      expect(
+        collection.select { |x| x == 2 }
+      ).to eq [2]
+    end
+  end
+end

data/spec/collection/href_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Collection do
+  let(:collection) do
+    LHS::Collection.new(LHS::Data.new([]))
+  end
+
+  context 'array misses href' do
+    it 'works with empty array' do
+      expect(
+        collection.href
+      ).to eq nil
+    end
+  end
+end

data/spec/collection/meta_data_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Collection do
+  let(:total) { 0 }
+
+  let(:limit) { 50 }
+
+  let(:offset) { 0 }
+
+  let(:collection) do
+    {
+      href: "#{datastore}/feedbacks",
+      items: [],
+      total: total,
+      limit: limit,
+      offset: offset
+    }
+  end
+
+  let(:item) do
+    {
+      href: "#{datastore}/users/1",
+      feedbacks: collection
+    }
+  end
+
+  let(:datastore) { 'http://local.ch/v2' }
+
+  before do
+    LHC.config.placeholder('datastore', datastore)
+    class Feedback < LHS::Record
+      endpoint '{+datastore}/feedbacks'
+      endpoint '{+datastore}/feedbacks/{id}'
+    end
+    class User < LHS::Record
+      endpoint '{+datastore}/users'
+      endpoint '{+datastore}/users/{id}'
+    end
+  end
+
+  it 'provides meta data for collections' do
+    stub_request(:get, "#{datastore}/feedbacks").to_return(status: 200, body: collection.to_json)
+    feedbacks = Feedback.where
+    expect(feedbacks.total).to eq total
+    expect(feedbacks.limit).to eq limit
+    expect(feedbacks.offset).to eq offset
+    expect(feedbacks.href).to eq "#{datastore}/feedbacks"
+  end
+
+  it 'provides meta data also when navigating' do
+    stub_request(:get, "#{datastore}/users/1").to_return(status: 200, body: item.to_json)
+    user = User.find(1)
+    expect(user.feedbacks.href).to eq "#{datastore}/feedbacks"
+  end
+end

data/spec/collection/respond_to_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Collection do
+  let(:data) do
+    ['ROLE_USER', 'ROLE_LOCALCH_ACCOUNT']
+  end
+
+  let(:collection) do
+    LHS::Data.new(LHS::Data.new(data))
+  end
+
+  context '#respond_to?' do
+    # In this case raw collection is an Array implementing first
+    it 'forwards calls to raw collection' do
+      expect(collection.respond_to?(:first)).to be(true)
+    end
+  end
+end

data/spec/collection/to_a_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Collection do
+  let(:items) { [{ name: 'Steve' }] }
+  let(:extra) { 'extra' }
+  let(:collection) { Record.where }
+
+  context 'to_a' do
+    let(:response_data) do
+      {
+        items: items,
+        extra: extra,
+        total: 1
+      }
+    end
+
+    let(:subject) { collection.to_a }
+
+    before do
+      class Record < LHS::Record
+        endpoint 'http://datastore/records`'
+      end
+      stub_request(:get, %r{http://datastore/records})
+        .to_return(body: response_data.to_json)
+    end
+
+    it 'returns an array and not LHS::Data' do
+      expect(subject).to be_kind_of Array
+      expect(subject).not_to be_kind_of LHS::Data
+    end
+  end
+end

data/spec/collection/to_ary_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Collection do
+  let(:items) { [{ name: 'Steve' }] }
+  let(:extra) { 'extra' }
+  let(:collection) { Record.where }
+
+  context 'to_ary' do
+    before do
+      class Record < LHS::Record
+        endpoint 'http://datastore/records`'
+      end
+      stub_request(:get, %r{http://datastore/records})
+        .to_return(body: response_data.to_json)
+    end
+
+    let(:response_data) do
+      {
+        items: items,
+        extra: extra,
+        total: 1
+      }
+    end
+
+    let(:subject) { collection.to_ary }
+
+    it 'returns an array' do
+      expect(subject).to be_present
+      expect(subject).to be_kind_of Array
+      expect(subject[0]).to be_kind_of Record
+      expect(subject[0].name).to eq 'Steve'
+    end
+
+    it 'responds to to_ary' do
+      expect(subject.respond_to?(:to_ary)).to eq true
+    end
+  end
+end

data/spec/collection/without_object_items_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Collection do
+  let(:datastore) { 'http://local.ch/v2' }
+
+  before do
+    LHC.config.placeholder('datastore', datastore)
+    class Account < LHS::Record
+      endpoint '{+datastore}/accounts/{id}'
+    end
+  end
+
+  let(:data) {
+    {
+      'authorities' => ['ROLE_USER', 'ROLE_LOCALCH_ACCOUNT']
+    }
+  }
+
+  it 'lets you access items of an array if they are not objects' do
+    stub_request(:get, "#{datastore}/accounts/1").to_return(status: 200, body: data.to_json)
+    feedback = Account.find(1)
+    expect(feedback.authorities.first).to eq 'ROLE_USER'
+    expect(feedback.authorities[1]).to eq 'ROLE_LOCALCH_ACCOUNT'
+  end
+end

data/spec/complex/reduce_spec.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Complex do
+  it 'returns nil when result is empty' do
+    expect(LHS::Complex.reduce([])).to be_nil
+  end
+
+  it 'forwards primitive types' do
+    expect(LHS::Complex.reduce(entry_id: 123)).to eq(entry_id: 123)
+  end
+
+  it 'fails when trying to merge primitive types' do
+    expect {
+      LHS::Complex.reduce([{ entry: true }, { entry: :content }])
+    }.to raise_error(ArgumentError)
+  end
+
+  it 'does not fail trying to merge primitive types when they are the same' do
+    expect {
+      LHS::Complex.reduce([{ entry: true }, { entry: true }])
+    }.not_to raise_error
+  end
+
+  context 'first level' do
+    context 'reduces symbols into/with X' do
+      it 'reduces symbols into hash' do
+        expect(LHS::Complex.reduce([
+          { entries: :contract },
+          :entries
+        ])).to eq(entries: :contract)
+      end
+
+      it 'reduces symbols into array' do
+        expect(LHS::Complex.reduce([
+          [:contracts],
+          :entries
+        ])).to eq([:contracts, :entries])
+        expect(LHS::Complex.reduce([
+          [:entries],
+          :entries
+        ])).to eq(:entries)
+      end
+
+      it 'reduces symbols with symbols' do
+        expect(LHS::Complex.reduce([
+          :contracts,
+          :entries
+        ])).to eq([:contracts, :entries])
+        expect(LHS::Complex.reduce([
+          :entries,
+          :entries
+        ])).to eq(:entries)
+      end
+    end
+
+    context 'reduces arrays into/with X' do
+      it 'reduces arrays into an hash' do
+        expect(LHS::Complex.reduce([
+          { entries: :contract },
+          [:entries]
+        ])).to eq(entries: :contract)
+        expect(LHS::Complex.reduce([
+          { entries: :contract },
+          [:products]
+        ])).to eq([{ entries: :contract }, :products])
+      end
+
+      it 'reduces arrays into an arrays' do
+        expect(LHS::Complex.reduce([
+          [:entries],
+          [:entries]
+        ])).to eq(:entries)
+        expect(LHS::Complex.reduce([
+          [:entries],
+          [:products]
+        ])).to eq([:entries, :products])
+      end
+
+      it 'reduces arrays into an symbols' do
+        expect(LHS::Complex.reduce([
+          :entries,
+          [:entries]
+        ])).to eq(:entries)
+        expect(LHS::Complex.reduce([
+          :entries,
+          [:products]
+        ])).to eq([:entries, :products])
+      end
+    end
+
+    context 'reduces hashes into/with X' do
+      it 'reduces hash into an hash' do
+        expect(LHS::Complex.reduce([
+          { entries: :contract },
+          { entries: :products }
+        ])).to eq(entries: [:contract, :products])
+        expect(LHS::Complex.reduce([
+          { entries: :contract },
+          { entries: :contract }
+        ])).to eq(entries: :contract)
+      end
+
+      it 'reduces hash into an array' do
+        expect(LHS::Complex.reduce([
+          [:entries],
+          { entries: :products }
+        ])).to eq(entries: :products)
+        expect(LHS::Complex.reduce([
+          [{ entries: :contract }],
+          { entries: :contract }
+        ])).to eq(entries: :contract)
+      end
+
+      it 'reduces hash into a symbol' do
+        expect(LHS::Complex.reduce([
+          :entries,
+          { entries: :products }
+        ])).to eq(entries: :products)
+        expect(LHS::Complex.reduce([
+          :products,
+          { entries: :contract }
+        ])).to eq([:products, { entries: :contract }])
+      end
+    end
+
+    context 'reduces array into/with X' do
+      it 'reduces array into hash' do
+        expect(LHS::Complex.reduce([
+          { entries: :contract },
+          [:entries, :products]
+        ])).to eq([{ entries: :contract }, :products])
+      end
+
+      it 'reduces array into array' do
+        expect(LHS::Complex.reduce([
+          [:contracts],
+          [:entries, :products, :contracts]
+        ])).to eq([:contracts, :entries, :products])
+      end
+
+      it 'reduces array with symbols' do
+        expect(LHS::Complex.reduce([
+          :contracts,
+          [:entries, :products]
+        ])).to eq([:contracts, :entries, :products])
+      end
+    end
+  end
+
+  context 'multi-level' do
+    it 'reduces a complex multi-level example' do
+      expect(LHS::Complex.reduce([
+        :contracts,
+        [:entries, products: { content_ads: :address }],
+        products: { content_ads: { place: :location } }
+      ])).to eq([
+        :contracts,
+        :entries,
+        products: { content_ads: [:address, { place: :location }] }
+      ])
+    end
+
+    it 'reduces another complex multi-level example' do
+      expect(LHS::Complex.reduce([
+        [entries: :content_ads, products: :price],
+        [:entries, products: { content_ads: :address }],
+        [entries: { content_ads: :owner }, products: [{ price: :region }, :image, { content_ads: :owner }]]
+      ])).to eq(
+        entries: { content_ads: :owner },
+        products: [{ content_ads: [:address, :owner], price: :region }, :image]
+      )
+    end
+
+    it 'reduces another complex multi-level example (single plus array)' do
+      expect(LHS::Complex.reduce([
+        { entries: :products },
+        { entries: [:customer, :contracts] }
+      ])).to eq(
+        entries: [:products, :customer, :contracts]
+      )
+    end
+
+    it 'reduces another complex multi-level example (single hash plus array)' do
+      expect(LHS::Complex.reduce([
+        { entries: { customer: :contracts } },
+        { entries: [:customer, :content_ads] }
+      ])).to eq(
+        entries: [{ customer: :contracts }, :content_ads]
+      )
+    end
+
+    it 'reduces properly' do
+      expect(LHS::Complex.reduce([
+        [:entries, :place, :content_ads], [{ place: :content_ads }], { content_ads: :place }
+      ])).to eq(
+        [:entries, { place: :content_ads, content_ads: :place }]
+      )
+    end
+  end
+end