dhs 1.0.0

data/spec/record/options_getter_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHS::Record do
+  context 'options' do
+    before do
+      class Record < DHS::Record
+        endpoint 'http://depay.fi/records'
+      end
+    end
+
+    let(:raw) do
+      { options: { criticality: :high } }
+    end
+
+    def record
+      DHS::Record.new DHS::Data.new(raw, nil, Record)
+    end
+
+    it 'is possible to fetch data from a key called options from an instance' do
+      expect(record.options.criticality).to eq :high
+    end
+  end
+end

data/spec/record/options_spec.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHS::Record do
+  let(:datastore) do
+    'http://datastore/v2'
+  end
+
+  before do
+    DHC.config.placeholder('datastore', datastore)
+    class Record < DHS::Record
+      endpoint '{+datastore}/records', validates: { persist: false }
+    end
+  end
+
+  let(:options) { { auth: { bearer: '123' }, validates: { persist: false } } }
+  let(:params) { { name: 'Steve' } }
+
+  context 'options' do
+    it 'is possible to pass options to the chain' do
+      expect(DHC).to receive(:request)
+        .with(options.merge(params: params).merge(url: 'http://datastore/v2/records'))
+        .and_call_original
+      stub_request(:get, 'http://datastore/v2/records?name=Steve')
+        .to_return(body: { name: 'Steve', is: 'awesome' }.to_json)
+      Record.options(options).where(params).first
+    end
+
+    it 'applies last one wins also to the options' do
+      stub_request(:get, 'http://datastore/v2/records')
+        .to_return(body: { name: 'Steve', is: 'awesome' }.to_json)
+      expect(DHC).to receive(:request)
+        .with(options.merge(url: 'http://datastore/v2/records'))
+        .and_call_original
+      Record.options(auth: 'basic').options(options).where.first
+    end
+
+    it 'is also applicable to find' do
+      stub_request(:get, 'http://datastore/v2/records?id=123').to_return(body: {}.to_json)
+      expect(DHC).to receive(:request)
+        .with(options.merge(params: { id: '123' }, url: 'http://datastore/v2/records'))
+        .and_call_original
+      Record.options(options).find('123')
+    end
+
+    it 'is also applicable to find_by' do
+      stub_request(:get, 'http://datastore/v2/records?id=123&limit=1').to_return(body: {}.to_json)
+      expect(DHC).to receive(:request)
+        .with(options.merge(params: { id: '123', limit: 1 }, url: 'http://datastore/v2/records'))
+        .and_call_original
+      Record.options(options).find_by(id: '123')
+    end
+
+    it 'is also applicable to first' do
+      stub_request(:get, 'http://datastore/v2/records').to_return(body: {}.to_json)
+      expect(DHC).to receive(:request)
+        .with(options.merge(url: 'http://datastore/v2/records'))
+        .and_call_original
+      Record.options(options).first
+    end
+
+    it 'is also applicable to create' do
+      stub_request(:post, 'http://datastore/v2/records').to_return(body: {}.to_json)
+      expect(DHC).to receive(:request)
+        .with(options.merge(method: :post, url: 'http://datastore/v2/records', body: { name: 'Steve' }, headers: {}))
+        .and_call_original
+      Record.options(options).create(name: 'Steve')
+    end
+
+    context 'actions on single records' do
+      let!(:record) do
+        stub_request(:get, 'http://datastore/v2/records?id=123').to_return(body: { href: 'http://datastore/v2/records/123' }.to_json)
+        Record.find(123)
+      end
+
+      context 'save' do
+        before do
+          stub_request(:post, 'http://datastore/v2/records/123').to_return(body: {}.to_json)
+          expect(DHC).to receive(:request)
+            .with(options.merge(method: :post, url: 'http://datastore/v2/records/123', body: { href: 'http://datastore/v2/records/123' }, headers: {}))
+            .and_call_original
+        end
+
+        it 'applies directly on save' do
+          record.save(options)
+        end
+
+        it 'applies directly on save!' do
+          record.save!(options)
+        end
+
+        it 'applies chaining them with save' do
+          record.options(options).save
+        end
+
+        it 'applies chaining them with save!' do
+          record.options(options).save!
+        end
+      end
+
+      context 'destroy' do
+        before do
+          stub_request(:delete, 'http://datastore/v2/records/123').to_return(body: {}.to_json)
+          expect(DHC).to receive(:request)
+            .with(options.merge(method: :delete, url: 'http://datastore/v2/records/123'))
+            .and_call_original
+        end
+
+        it 'applies directly on destroy' do
+          record.destroy(options)
+        end
+
+        it 'applies chaining them with destroy' do
+          record.options(options).destroy
+        end
+      end
+
+      context 'update' do
+        before do
+          stub_request(:post, 'http://datastore/v2/records/123').to_return(body: {}.to_json)
+          body = { href: 'http://datastore/v2/records/123', name: 'steve' }
+          expect(DHC).to receive(:request)
+            .with(options.merge(method: :post, url: 'http://datastore/v2/records/123', body: body))
+            .and_call_original
+        end
+
+        it 'applies directly on update' do
+          record.update({ name: 'steve' }, options)
+        end
+
+        it 'applies directly on update!' do
+          record.update!({ name: 'steve' }, options)
+        end
+
+        it 'applies chaining them with update' do
+          record.options(options).update(name: 'steve')
+        end
+
+        it 'applies chaining them with update!' do
+          record.options(options).update!(name: 'steve')
+        end
+      end
+
+      context 'valid' do
+        before do
+          stub_request(:post, 'http://datastore/v2/records?persist=false').to_return(body: {}.to_json)
+          body = DHS::Data.new({ href: 'http://datastore/v2/records/123' }, nil, Record)
+          expect(DHC).to receive(:request)
+            .with(options.merge(url: '{+datastore}/records', method: :post, params: { persist: false }, body: body))
+            .and_call_original
+        end
+
+        it 'applies directly on valid' do
+          record.valid?(options)
+        end
+
+        it 'applies chaining them with valid' do
+          record.options(options).valid?
+        end
+      end
+    end
+  end
+end

data/spec/record/paginatable_collection_spec.rb

@@ -0,0 +1,360 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHS::Record do
+  before { DHC.config.placeholder('datastore', datastore) }
+  let(:datastore) { 'http://depay.fi/v2' }
+
+  context 'default pagination behaviour' do
+    before do
+      class Record < DHS::Record
+        endpoint '{+datastore}/feedbacks'
+      end
+    end
+
+    it 'also works when there is no item in the first response' do
+      stub_request(:get, "#{datastore}/feedbacks?limit=100")
+        .to_return(
+          status: 200,
+          body: { items: [], total: 200, offset: 0 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=100")
+        .to_return(
+          status: 200,
+          body: { items: [], total: 200, offset: 0 }.to_json
+        )
+      all = Record.all
+      expect(all).to be_kind_of Record
+      expect(all._proxy).to be_kind_of DHS::Collection
+      expect(all.length).to eq 0
+    end
+
+    it 'also works when there is no total in the stubbing' do
+      stub_request(:get, 'http://depay.fi/v2/feedbacks?limit=100').to_return(body: { items: (1..100).to_a }.to_json)
+      stub_request(:get, 'http://depay.fi/v2/feedbacks?limit=100&offset=100').to_return(body: { items: [] }.to_json)
+      all = Record.all
+      expect(all).to be_kind_of Record
+      expect(all._proxy).to be_kind_of DHS::Collection
+      expect(all.length).to eq 100
+    end
+
+    it 'also works when there is no key "items" in the stubbing' do
+      stub_request(:get, 'http://depay.fi/v2/feedbacks?limit=100').to_return(body: (1..100).to_a.to_json)
+      stub_request(:get, 'http://depay.fi/v2/feedbacks?limit=100&offset=100').to_return(body: [].to_json)
+      all = Record.all
+      expect(all).to be_kind_of Record
+      expect(all._proxy).to be_kind_of DHS::Collection
+      expect(all.length).to eq 100
+    end
+  end
+
+  context 'pagination using offset(0,100,200,...)' do
+    before do
+      class Record < DHS::Record
+        configuration pagination_strategy: 'offset', pagination_key: 'offset'
+        endpoint '{+datastore}/feedbacks'
+      end
+    end
+
+    it 'fetches all records from the backend' do
+      stub_request(:get, "#{datastore}/feedbacks?limit=100")
+        .to_return(
+          status: 200,
+          body: { items: (1..100).to_a, limit: 100, total: 300, offset: 0 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=100")
+        .to_return(
+          status: 200,
+          body: { items: (101..200).to_a, limit: 100, total: 300, offset: 100 }.to_json
+        )
+      last_request = stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=200")
+        .to_return(
+          status: 200,
+          body: { items: (201..300).to_a, limit: 100, total: 300, offset: 200 }.to_json
+        )
+      all = Record.all
+      all.first # fetch/resolve
+      assert_requested last_request
+      expect(all).to be_kind_of Record
+      expect(all._data._proxy).to be_kind_of DHS::Collection
+      expect(all.count).to eq 300
+      expect(all.last).to eq 300
+    end
+
+    it 'fetches all, also if there is a rest and the total is not divideable trough the limit' do
+      stub_request(:get, "#{datastore}/feedbacks?limit=100")
+        .to_return(
+          status: 200,
+          body: { items: (1..100).to_a, limit: 100, total: 223, offset: 0 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=100")
+        .to_return(
+          status: 200,
+          body: { items: (101..200).to_a, limit: 100, total: 223, offset: 100 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=200")
+        .to_return(
+          status: 200,
+          body: { items: (201..223).to_a, limit: 100, total: 223, offset: 200 }.to_json
+        )
+      all = Record.all
+      expect(all).to be_kind_of Record
+      expect(all._data._proxy).to be_kind_of DHS::Collection
+      expect(all.count).to eq 223
+      expect(all.last).to eq 223
+    end
+
+    it 'also fetches all when there is no meta information for limit' do
+      stub_request(:get, "#{datastore}/feedbacks?limit=100")
+        .to_return(
+          status: 200,
+          body: { items: (1..100).to_a, total: 300, offset: 0 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=100")
+        .to_return(
+          status: 200,
+          body: { items: (101..200).to_a, total: 300, offset: 100 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=200")
+        .to_return(
+          status: 200,
+          body: { items: (201..300).to_a, total: 300, offset: 200 }.to_json
+        )
+      all = Record.all
+      expect(all).to be_kind_of Record
+      expect(all._proxy).to be_kind_of DHS::Collection
+      expect(all.count).to eq 300
+      expect(all.last).to eq 300
+    end
+  end
+
+  context 'pagination using page(1,2,3,...)' do
+    before do
+      class Record < DHS::Record
+        configuration pagination_strategy: 'page', pagination_key: 'page'
+        endpoint '{+datastore}/feedbacks'
+      end
+    end
+
+    it 'fetches all records from the backend' do
+      stub_request(:get, "#{datastore}/feedbacks?limit=100")
+        .to_return(
+          status: 200,
+          body: { items: (1..100).to_a, limit: 100, total: 300, page: 1 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&page=2")
+        .to_return(
+          status: 200,
+          body: { items: (101..200).to_a, limit: 100, total: 300, page: 2 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&page=3")
+        .to_return(
+          status: 200,
+          body: { items: (201..300).to_a, limit: 100, total: 300, page: 3 }.to_json
+        )
+      all = Record.all
+      expect(all).to be_kind_of Record
+      expect(all._data._proxy).to be_kind_of DHS::Collection
+      expect(all.count).to eq 300
+      expect(all.last).to eq 300
+    end
+
+    it 'also fetches all when there is no meta information for limit' do
+      stub_request(:get, "#{datastore}/feedbacks?limit=100")
+        .to_return(
+          status: 200,
+          body: { items: (1..100).to_a, total: 300, page: 1 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&page=2")
+        .to_return(
+          status: 200,
+          body: { items: (101..200).to_a, total: 300, page: 2 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&page=3")
+        .to_return(
+          status: 200,
+          body: { items: (201..300).to_a, total: 300, page: 3 }.to_json
+        )
+      all = Record.all
+      expect(all).to be_kind_of Record
+      expect(all._proxy).to be_kind_of DHS::Collection
+      expect(all.count).to eq 300
+      expect(all.last).to eq 300
+    end
+
+    it 'fetches all, also if there is a rest and the total is not divideable trough the limit' do
+      stub_request(:get, "#{datastore}/feedbacks?limit=100")
+        .to_return(
+          status: 200,
+          body: { items: (1..100).to_a, limit: 100, total: 223, page: 1 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&page=2")
+        .to_return(
+          status: 200,
+          body: { items: (101..200).to_a, limit: 100, total: 223, page: 2 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&page=3")
+        .to_return(
+          status: 200,
+          body: { items: (201..223).to_a, limit: 100, total: 223, page: 3 }.to_json
+        )
+      all = Record.all
+      expect(all).to be_kind_of Record
+      expect(all._data._proxy).to be_kind_of DHS::Collection
+      expect(all.count).to eq 223
+      expect(all.last).to eq 223
+    end
+  end
+
+  context 'pagination using start(1,101,201,...)' do
+    before do
+      class Record < DHS::Record
+        configuration pagination_strategy: 'start', pagination_key: 'start'
+        endpoint '{+datastore}/feedbacks'
+      end
+    end
+
+    it 'fetches all records from the backend' do
+      stub_request(:get, "#{datastore}/feedbacks?limit=100")
+        .to_return(
+          status: 200,
+          body: { items: (1..100).to_a, limit: 100, total: 300, start: 1 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&start=101")
+        .to_return(
+          status: 200,
+          body: { items: (101..200).to_a, limit: 100, total: 300, start: 101 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&start=201")
+        .to_return(
+          status: 200,
+          body: { items: (201..300).to_a, limit: 100, total: 300, start: 201 }.to_json
+        )
+      all = Record.all
+      expect(all).to be_kind_of Record
+      expect(all._data._proxy).to be_kind_of DHS::Collection
+      expect(all.count).to eq 300
+      expect(all.last).to eq 300
+    end
+
+    it 'also fetches all when there is no meta information for limit' do
+      stub_request(:get, "#{datastore}/feedbacks?limit=100")
+        .to_return(
+          status: 200,
+          body: { items: (1..100).to_a, total: 300, start: 1 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&start=101")
+        .to_return(
+          status: 200,
+          body: { items: (101..200).to_a, total: 300, start: 101 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&start=201")
+        .to_return(
+          status: 200,
+          body: { items: (201..300).to_a, total: 300, start: 201 }.to_json
+        )
+      all = Record.all
+      expect(all).to be_kind_of Record
+      expect(all._proxy).to be_kind_of DHS::Collection
+      expect(all.count).to eq 300
+      expect(all.last).to eq 300
+    end
+
+    it 'fetches all, also if there is a rest and the total is not divideable trough the limit' do
+      stub_request(:get, "#{datastore}/feedbacks?limit=100")
+        .to_return(
+          status: 200,
+          body: { items: (1..100).to_a, limit: 100, total: 223, start: 1 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&start=101")
+        .to_return(
+          status: 200,
+          body: { items: (101..200).to_a, limit: 100, total: 223, start: 101 }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&start=201")
+        .to_return(
+          status: 200,
+          body: { items: (201..223).to_a, limit: 100, total: 223, start: 201 }.to_json
+        )
+      all = Record.all
+      expect(all).to be_kind_of Record
+      expect(all._data._proxy).to be_kind_of DHS::Collection
+      expect(all.count).to eq 223
+      expect(all.last).to eq 223
+    end
+  end
+
+  context 'pagination using links' do
+    before do
+      class Record < DHS::Record
+        configuration pagination_strategy: 'link'
+        endpoint '{+datastore}/feedbacks'
+      end
+    end
+
+    it 'fetches all records from the backend' do
+      stub_request(:get, "#{datastore}/feedbacks?limit=100")
+        .to_return(
+          status: 200,
+          body: { items: (1..100).to_a, limit: 100, next: { href: "#{datastore}/feedbacks?limit=100&cursor=x" } }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&cursor=x")
+        .to_return(
+          status: 200,
+          body: { items: (101..200).to_a, limit: 100, next: { href: "#{datastore}/feedbacks?limit=100&cursor=y" } }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&cursor=y")
+        .to_return(
+          status: 200,
+          body: { items: (201..300).to_a, limit: 100, next: { href: "#{datastore}/feedbacks?limit=100&cursor=z" } }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&cursor=z")
+        .to_return(
+          status: 200,
+          body: { items: [], limit: 100 }.to_json
+        )
+      all = Record.all
+
+      expect(all).to be_kind_of Record
+      expect(all._data._proxy).to be_kind_of DHS::Collection
+      expect(all.count).to eq 300
+      expect(all.last).to eq 300
+    end
+
+    it 'fetches all, also if there is a rest and the total is not divideable trough the limit' do
+      stub_request(:get, "#{datastore}/feedbacks?limit=100")
+        .to_return(
+          status: 200,
+          body: { items: (1..100).to_a, limit: 100, next: { href: "#{datastore}/feedbacks?limit=100&cursor=x" } }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&cursor=x")
+        .to_return(
+          status: 200,
+          body: { items: (101..200).to_a, limit: 100, next: { href: "#{datastore}/feedbacks?limit=100&cursor=y" } }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&cursor=y")
+        .to_return(
+          status: 200,
+          body: { items: (201..300).to_a, limit: 100, next: { href: "#{datastore}/feedbacks?limit=100&cursor=z" } }.to_json
+        )
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&cursor=z")
+        .to_return(
+          status: 200,
+          body: { items: [301], limit: 100 }.to_json
+        )
+
+      all = nil
+      expect(lambda do
+        all = Record.all.fetch
+      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/DePayFi/dhs#pagination-strategy-link\).}
+      ).to_stderr
+
+      expect(all).to be_kind_of Record
+      expect(all._data._proxy).to be_kind_of DHS::Collection
+      expect(all.count).to eq 301
+      expect(all.last).to eq 301
+    end
+  end
+end