dhs 1.0.0

data/spec/record/pagination_chain_spec.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHS::Record do
+  context 'pagination chain' do
+    context 'default pagination (offset)' do
+      before do
+        class Record < DHS::Record
+          endpoint 'http://depay.fi/records'
+          endpoint 'http://depay.fi/records/{id}'
+        end
+      end
+
+      it 'allows to chain pagination methods' do
+        request = stub_request(:get, 'http://depay.fi/records?color=blue&offset=200&limit=100').to_return(body: [].to_json)
+        Record.where(color: 'blue').page(3).first
+        expect(request).to have_been_made.times(1)
+        request = stub_request(:get, 'http://depay.fi/records?color=blue&offset=20&limit=10').to_return(body: [].to_json)
+        Record.where(color: 'blue').page(3).per(10).first
+        Record.where(color: 'blue').per(10).page(3).first
+        Record.where(color: 'blue').per(20).page(5).per(10).page(3).first
+        expect(request).to have_been_made.times(3)
+      end
+
+      it 'allows to start chains with pagination methods' do
+        request = stub_request(:get, 'http://depay.fi/records?color=blue&offset=200&limit=100').to_return(body: [].to_json)
+        Record.page(3).where(color: 'blue').first
+        expect(request).to have_been_made.times(1)
+        request = stub_request(:get, 'http://depay.fi/records?color=blue&offset=20&limit=10').to_return(body: [].to_json)
+        Record.page(3).per(10).where(color: 'blue').first
+        Record.per(10).page(3).where(color: 'blue').first
+        Record.per(20).page(5).where(color: 'blue').per(10).page(3).first
+        expect(request).to have_been_made.times(3)
+      end
+
+      it 'defaults page to 1' do
+        request = stub_request(:get, 'http://depay.fi/records?limit=10&offset=0').to_return(body: [].to_json)
+        Record.per(10).first
+        Record.per(10).page('').first
+        expect(request).to have_been_made.times(2)
+      end
+
+      it 'provides limit as alias for per' do
+        request = stub_request(:get, 'http://depay.fi/records?limit=10&offset=0').to_return(body: [].to_json)
+        Record.limit(10).first
+        Record.page('').limit(10).first
+        expect(request).to have_been_made.times(2)
+      end
+
+      it 'also works with strings' do
+        request = stub_request(:get, 'http://depay.fi/records?limit=10&offset=0').to_return(body: [].to_json)
+        Record.limit('10').first
+        Record.page('1').limit('10').first
+        expect(request).to have_been_made.times(2)
+      end
+    end
+
+    context 'start pagination' do
+      before do
+        class Record < DHS::Record
+          configuration pagination_strategy: 'start', pagination_key: 'start'
+          endpoint 'http://depay.fi/records'
+          endpoint 'http://depay.fi/records/{id}'
+        end
+      end
+
+      it 'allows to chain pagination methods' do
+        request = stub_request(:get, 'http://depay.fi/records?color=blue&start=201&limit=100').to_return(body: [].to_json)
+        Record.where(color: 'blue').page(3).first
+        expect(request).to have_been_made.times(1)
+        request = stub_request(:get, 'http://depay.fi/records?color=blue&start=21&limit=10').to_return(body: [].to_json)
+        Record.where(color: 'blue').page(3).per(10).first
+        Record.where(color: 'blue').per(10).page(3).first
+        Record.where(color: 'blue').per(20).page(5).per(10).page(3).first
+        expect(request).to have_been_made.times(3)
+      end
+    end
+
+    context 'page pagination' do
+      before do
+        class Record < DHS::Record
+          configuration pagination_strategy: 'page', pagination_key: 'page'
+          endpoint 'http://depay.fi/records'
+          endpoint 'http://depay.fi/records/{id}'
+        end
+      end
+
+      it 'allows to chain pagination methods' do
+        request = stub_request(:get, 'http://depay.fi/records?color=blue&page=3&limit=100').to_return(body: [].to_json)
+        Record.where(color: 'blue').page(3).first
+        expect(request).to have_been_made.times(1)
+        request = stub_request(:get, 'http://depay.fi/records?color=blue&page=3&limit=10').to_return(body: [].to_json)
+        Record.where(color: 'blue').page(3).per(10).first
+        Record.where(color: 'blue').per(10).page(3).first
+        Record.where(color: 'blue').per(20).page(5).per(10).page(3).first
+        expect(request).to have_been_made.times(3)
+      end
+    end
+  end
+end

data/spec/record/pagination_links_spec.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHS::Record do
+  context 'pagination links' do
+    before do
+      class Customer < DHS::Record
+        endpoint 'http://datastore/customer'
+      end
+    end
+
+    let!(:request) do
+      stub_request(:get, "http://datastore/customer#{query}")
+        .to_return(body: body)
+    end
+
+    let(:query) { "?name=#{name}&page=#{page}" }
+
+    let(:customers) do
+      Customer.where(name: name, page: page)
+    end
+
+    context 'next and previous link is present' do
+      let(:name) { 'Simpl' }
+      let(:page) { 2 }
+      let(:body) do
+        {
+          next: "http://datastore/customer?name=#{name}&page=3",
+          previous: "http://datastore/customer?name=#{name}&page=1",
+          items: [{ name: 'Simplificator' }]
+        }.to_json
+      end
+
+      it 'tells me that there is a next link' do
+        expect(customers.next?).to eq true
+        expect(customers.previous?).to eq true
+      end
+    end
+
+    context 'next link is present, previous is not' do
+      let(:name) { 'Simpl' }
+      let(:page) { 2 }
+      let(:body) do
+        {
+          next: "http://datastore/customer?name=#{name}&page=3",
+          items: [{ name: 'Simplificator' }]
+        }.to_json
+      end
+
+      it 'tells me that there is a next link' do
+        expect(customers.next?).to eq true
+        expect(customers.previous?).to eq false
+      end
+    end
+
+    context 'no next link and no previous link is present' do
+      let(:name) { 'Simplificator' }
+      let(:page) { 1 }
+      let(:body) do
+        {
+          items: [{ name: 'Simplificator' }]
+        }.to_json
+      end
+
+      it 'tells me that there is no next link' do
+        expect(customers.next?).to eq false
+        expect(customers.previous?).to eq false
+      end
+    end
+  end
+end

data/spec/record/pagination_spec.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHS::Record do
+  context 'pagination' do
+    let(:datastore) { 'http://depay.fi/v2' }
+    let(:record) { Feedback.where(entry_id: 1) }
+    let(:total) { 200 }
+    let(:total_pages) { total / limit }
+    let(:current_page) { offset + 1 }
+    let(:prev_page) { current_page - 1 }
+    let(:next_page) { current_page + 1 }
+    let(:offset) { 0 }
+    let(:limit) { 10 }
+    let(:body_json) do
+      {
+        items: [],
+        total: total,
+        offset: offset,
+        limit: limit
+      }.to_json
+    end
+
+    before do
+      DHC.config.placeholder('datastore', datastore)
+      class Feedback < DHS::Record
+        endpoint '{+datastore}/feedbacks'
+      end
+      stub_request(:get, 'http://depay.fi/v2/feedbacks?entry_id=1')
+        .to_return(body: body_json)
+    end
+
+    it 'responds to limit_value' do
+      expect(record.limit_value).to eq(limit)
+    end
+
+    it 'responds to total_pages' do
+      expect(record.total_pages).to eq(total_pages)
+    end
+
+    it 'responds to current_page' do
+      expect(record.current_page).to eq(current_page)
+    end
+
+    it 'responds to first_page' do
+      expect(record.first_page).to eq(1)
+    end
+
+    it 'responds to last_page' do
+      expect(record.last_page).to eq(total_pages)
+    end
+
+    it 'responds to prev_page' do
+      expect(record.prev_page).to eq(prev_page)
+    end
+
+    it 'responds to next_page' do
+      expect(record.next_page).to eq(next_page)
+    end
+
+    context 'when amount of total pages is not diviable by the limit' do
+      let(:total) { 2738 }
+      let(:limit) { 100 }
+
+      it 'rounds up' do
+        expect(record.total_pages).to eq(28)
+      end
+    end
+  end
+end

data/spec/record/persisted_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHS::Record do
+  context '#persisted?' do
+    let(:datastore) { 'http://depay.fi/v2' }
+
+    before do
+      DHC.config.placeholder('datastore', datastore)
+      class Feedback < DHS::Record
+        endpoint '{+datastore}/content-ads/{campaign_id}/feedbacks'
+      end
+    end
+
+    context 'for new record' do
+      context 'with a nil href' do
+        subject { Feedback.new }
+
+        it 'is false' do
+          expect(subject.persisted?).to be(false)
+        end
+      end
+
+      context 'with an empty href' do
+        subject { Feedback.new(href: '') }
+
+        it 'is false' do
+          expect(subject.persisted?).to be(false)
+        end
+      end
+    end
+
+    context 'for saved record' do
+      let(:campaign_id) { 'aaa' }
+      let(:parameters) { { recommended: true } }
+
+      subject { Feedback.new(parameters.merge(campaign_id: campaign_id)) }
+
+      before do
+        stub_request(:post, "#{datastore}/content-ads/#{campaign_id}/feedbacks")
+          .with(body: parameters.to_json)
+          .to_return(status: 200, body: parameters.merge(href: "#{datastore}/content-ads/#{campaign_id}/feedbacks/123456789").to_json)
+      end
+
+      it 'is true' do
+        subject.save
+        expect(subject.persisted?).to be(true)
+      end
+    end
+  end
+end

data/spec/record/provider_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHS::Record do
+  context 'provider' do
+    before do
+      module Provider
+        class BaseRecord < DHS::Record
+          provider params: { api_key: 123 }
+        end
+
+        class Record < Provider::BaseRecord
+          endpoint 'http://provider/records'
+        end
+      end
+
+      class AnotherRecord < DHS::Record
+        endpoint 'http://other_provider/records'
+      end
+
+      stub_request(:get, 'http://provider/records?id=1&api_key=123')
+        .to_return(body: { name: 'Steve' }.to_json)
+
+      stub_request(:get, 'http://other_provider/records?id=1')
+        .to_return(body: { name: 'Not Steve' }.to_json)
+    end
+
+    it 'applies provider options when making requests to that provider' do
+      record = Provider::Record.find(1)
+      expect(record.name).to eq 'Steve'
+    end
+
+    it 'does not apply provider options when making requests to other records' do
+      Provider::Record.find(1)
+      record = AnotherRecord.find(1)
+      expect(record.name).to eq 'Not Steve'
+    end
+  end
+end

data/spec/record/references_spec.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHS::Record do
+  context 'references' do
+    before do
+      class Customer < DHS::Record
+        endpoint 'http://datastore/customers/{id}'
+      end
+
+      class User < DHS::Record
+        endpoint 'http://datastore/users/{id}'
+        endpoint 'http://datastore/customers/{customer_id}/users/{id}'
+        def reversed_name
+          name.split.reverse.join(' ')
+        end
+      end
+    end
+
+    let!(:customer_request) do
+      stub_request(:get, 'http://datastore/customers/1')
+        .to_return(body: {
+          'electronic_addresses' => {
+            'href' => 'http://datastore/electronic_addresses'
+          },
+          'contact_addresses' => {
+            'href' => 'http://datastore/contact_addresses'
+          },
+          'users' => {
+            'href' => 'http://datastore/customers/1/users'
+          }
+        }.to_json)
+    end
+
+    let!(:electronic_addresses_request) do
+      stub_request(:get, 'http://datastore/electronic_addresses')
+        .with(referencing_options)
+        .to_return(body: [].to_json)
+    end
+
+    let!(:contact_addresses_request) do
+      stub_request(:get, 'http://datastore/contact_addresses')
+        .with(referencing_options)
+        .to_return(body: [].to_json)
+    end
+
+    let(:referencing_options) do
+      { headers: { 'Authentication' => 'Bearer 123' } }
+    end
+
+    it 'uses the "references" hash for all symbols of the "including" array' do
+      Customer
+        .includes_first_page(:electronic_addresses, :contact_addresses)
+        .references(
+          electronic_addresses: referencing_options,
+          contact_addresses: referencing_options
+        )
+        .find(1)
+      assert_requested(electronic_addresses_request)
+      assert_requested(contact_addresses_request)
+    end
+
+    describe 'mapping related classes correctly' do
+      before do
+        stub_request(:get, 'http://datastore/customers/1/users?limit=100').to_return(
+          status: 200,
+          body: {
+            href: 'http://datastore/customers/1/users?offset=0&limit=100',
+            items: [
+              { href: 'http://datastore/customers/1/users/1' }
+            ],
+            total: 1,
+            offset: 0,
+            limit: 10
+          }.to_json
+        )
+
+        stub_request(:get, 'http://datastore/customers/1/users/1')
+          .with(headers: { 'Authentication' => 'Bearer 123' })
+          .to_return(body: { href: 'http://datastore/users/1', name: 'Elizabeth Baker' }.to_json)
+      end
+
+      it 'maps correctly' do
+        users = Customer
+          .includes(:users)
+          .references(users: referencing_options)
+          .find(1)
+          .users
+
+        expect(users.first.reversed_name).to be_present
+      end
+    end
+  end
+end

data/spec/record/relation_caching_spec.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHS::Record do
+  context 'cache' do
+    let(:transaction) { Transaction.find(1) }
+    let(:user) { transaction.user }
+
+    before do
+      class Transaction < DHS::Record
+        endpoint 'http://myservice/transactions'
+        endpoint 'http://myservice/transactions/{id}'
+        has_one :user
+      end
+
+      class User < DHS::Record
+        has_many :comments
+
+        def email
+          self[:email_address]
+        end
+      end
+
+      class Comment < DHS::Record
+      end
+
+      [1, 2].each do |id|
+        stub_request(:get, "http://myservice/transactions/#{id}")
+          .to_return(body: {
+            user: {
+              email_address: 'steve@depay.fi',
+              comments: []
+            }
+          }.to_json)
+      end
+    end
+
+    it 'caches the relation in memory' do
+      allow(DHS::Record).to receive(:for_url).and_return(User)
+      user_object_id = transaction.user.object_id
+      expect(transaction.user.object_id).to eql(user_object_id)
+      transaction2 = Transaction.find(2)
+      expect(transaction2.user.object_id).not_to eql(user_object_id)
+    end
+
+    it 'recalculates cache for relation when it was modified' do
+      allow(DHS::Record).to receive(:for_url).and_return(Comment)
+      expect(user.comments).to be_blank
+      comments_object_id = user.comments.object_id
+      user.comments = [Comment.new]
+      expect(user.comments.object_id).not_to eql(comments_object_id)
+      expect(user.comments).not_to be_blank
+    end
+  end
+
+  context 'clear cache' do
+    before do
+      class Place < DHS::Record
+        endpoint 'https://datastore/places/{id}', followlocation: true, headers: { 'Prefer' => 'redirect-strategy=redirect-over-not-found' }
+        has_many :available_assets
+      end
+
+      class AvailableAsset < DHS::Record
+      end
+
+      stub_request(:get, "http://datastore/places/#{place_id}/available-assets?limit=100")
+        .to_return(body: {
+          total: available_assets.size,
+          items: available_assets
+        }.to_json)
+    end
+
+    let(:place_id) { SecureRandom.urlsafe_base64 }
+
+    let(:place_hash) do
+      {
+        href: "https://datastore/places/#{place_id}",
+        id: place_id,
+        available_assets: { href: "http://datastore/places/#{place_id}/available-assets?offset=0&limit=10" }
+      }
+    end
+
+    let(:available_asset_hash) do
+      { asset_code: 'OPENING_HOURS' }
+    end
+
+    let(:available_assets) { [available_asset_hash] }
+
+    it 'clears the cache when using find' do
+      stub_request(:get, place_hash[:href])
+        .to_return(body: place_hash.to_json)
+      place = Place
+        .options(auth: { bearer: 'XYZ' })
+        .includes(:available_assets)
+        .find(place_id)
+      expect(place.available_assets.first).to be_a(AvailableAsset)
+    end
+
+    it 'clears the cache when using where' do
+      stub_request(:get, place_hash[:href])
+        .to_return(body: place_hash.to_json)
+      place = Place
+        .options(auth: { bearer: 'XYZ' })
+        .includes(:available_assets)
+        .where(id: place_id)
+      expect(place.available_assets.first).to be_a(AvailableAsset)
+    end
+
+    it 'clears the cache when using find_by' do
+      stub_request(:get, "https://datastore/places/#{place_id}?limit=1")
+        .to_return(body: place_hash.to_json)
+      place = Place
+        .options(auth: { bearer: 'XYZ' })
+        .includes(:available_assets)
+        .find_by(id: place_id)
+      expect(place.available_assets.first).to be_a(AvailableAsset)
+    end
+  end
+end