lhs 24.0.0

data/spec/record/fetch_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  before do
+    class Record < LHS::Record
+      endpoint 'http://datastore/records/'
+    end
+  end
+
+  context 'fetch' do
+
+    context 'to resolve the chain' do
+      let!(:request_stub) do
+        stub_request(:get, "http://datastore/records/?available=true&color=blue&range=%3E26")
+          .to_return(body: [{
+            name: 'Steve'
+          }].to_json)
+      end
+
+      it 'resolves chains' do
+        records = Record.where(color: 'blue').where(range: '>26', available: true).fetch
+        expect(request_stub).to have_been_requested
+        expect(records.first.name).to eq 'Steve'
+      end
+    end
+
+    context 'to fetch the first response' do
+      let!(:request_stub) do
+        stub_request(:get, "http://datastore/records/")
+          .to_return(body: [{ name: 'Steve' }])
+      end
+
+      it 'does fetch the first response if requested directly on the record' do
+        records = Record.fetch
+        expect(records.first.name).to eq 'Steve'
+      end
+    end
+  end
+end

data/spec/record/find_by_chains_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  before do
+    class Record < LHS::Record
+      endpoint 'http://datastore/records/'
+    end
+    stub_request(:get, "http://datastore/records/?limit=1&name=Steve&color=blue")
+      .to_return(body: [{ name: 'Steve', color: 'blue' }].to_json)
+  end
+
+  it 'allows chaining find_by' do
+    Record.options(params: { color: 'blue' }).find_by(name: 'Steve')
+  end
+
+  it 'allows chaining find_by!' do
+    Record.options(params: { color: 'blue' }).find_by!(name: 'Steve')
+  end
+end

data/spec/record/find_by_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  let(:datastore) { 'http://local.ch/v2' }
+
+  before do
+    LHC.config.placeholder(:datastore, datastore)
+    class Record < LHS::Record
+      endpoint '{+datastore}/content-ads/{campaign_id}/feedbacks'
+      endpoint '{+datastore}/content-ads/{campaign_id}/feedbacks/{id}'
+      endpoint '{+datastore}/feedbacks'
+      endpoint '{+datastore}/feedbacks/{id}'
+    end
+  end
+
+  context 'find_by' do
+    it 'finds a single record' do
+      stub_request(:get, "#{datastore}/feedbacks/z12f-3asm3ngals?limit=1")
+        .to_return(status: 200, body: load_json(:feedback))
+      record = Record.find_by(id: 'z12f-3asm3ngals')
+      expect(record.source_id).to be_kind_of String
+      expect(record).to be_kind_of Record
+    end
+
+    it 'returns nil if no record was found' do
+      stub_request(:get, "#{datastore}/feedbacks/something-inexistent?limit=1")
+        .to_return(status: 404)
+      expect(
+        Record.find_by(id: 'something-inexistent')
+      ).to eq nil
+    end
+
+    it 'return first item by parameters' do
+      json = load_json(:feedbacks)
+      stub_request(:get, "#{datastore}/feedbacks?has_reviews=true&limit=1")
+        .to_return(status: 200, body: json)
+      expect(
+        Record.find_by(has_reviews: true).id
+      ).to eq json['items'].first['id']
+    end
+
+    it 'returns nil if empty id' do
+      expect { Record.find_by(id: '') }.to raise_error LHS::Unprocessable
+    end
+
+    context 'when record has custom configurations for limit_key' do
+      before do
+        class Record < LHS::Record
+          endpoint '{+datastore}/feedbacks/{id}'
+          configuration(
+            limit_key: { body: %i[response max], parameter: :max }
+          )
+        end
+      end
+
+      it 'finds a single record with max parameter' do
+        stub_request(:get, "#{datastore}/feedbacks/z12f-3asm3ngals?max=1")
+          .to_return(status: 200, body: load_json(:feedback))
+        record = Record.find_by(id: 'z12f-3asm3ngals')
+        expect(record.source_id).to be_kind_of String
+        expect(record).to be_kind_of Record
+      end
+    end
+  end
+
+  context 'find_by!' do
+    it 'raises if nothing was found with parameters' do
+      stub_request(:get, "#{datastore}/feedbacks?has_reviews=true&limit=1")
+        .to_return(status: 200, body: { items: [] }.to_json)
+      expect { Record.find_by!(has_reviews: true) }
+        .to raise_error LHC::NotFound
+    end
+  end
+end

data/spec/record/find_each_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Collection do
+  let(:total) { 443 }
+
+  let(:limit) { 100 }
+
+  def api_response(ids, offset)
+    records = ids.map { |i| { id: i } }
+    {
+      items: records,
+      total: total,
+      limit: limit,
+      offset: offset
+    }.to_json
+  end
+
+  let(:datastore) { 'http://local.ch/v2' }
+
+  before do
+    LHC.config.placeholder('datastore', datastore)
+    class Record < LHS::Record
+      endpoint '{+datastore}/{campaign_id}/feedbacks'
+      endpoint '{+datastore}/feedbacks'
+    end
+  end
+
+  context 'find_each' do
+    it 'processes each record by fetching records in batches' do
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=1").to_return(status: 200, body: api_response((1..100).to_a, 1))
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=101").to_return(status: 200, body: api_response((101..200).to_a, 101))
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=201").to_return(status: 200, body: api_response((201..300).to_a, 201))
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=301").to_return(status: 200, body: api_response((301..400).to_a, 301))
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=401").to_return(status: 200, body: api_response((401..total).to_a, 401))
+      count = 0
+      Record.find_each do |record|
+        count += 1
+        expect(record.id).to eq(count)
+        expect(record).to be_kind_of Record
+        expect(record._proxy).to be_kind_of LHS::Item
+      end
+      expect(count).to eq total
+    end
+
+    it 'passes options to the requests made' do
+      request = stub_request(:get, "http://local.ch/v2/feedbacks?limit=100&offset=1")
+        .with(headers: { 'Authorization' => 'Bearer 123' })
+        .to_return(body: {
+          items: []
+        }.to_json)
+      Record.find_each(headers: { 'Authorization' => 'Bearer 123' }) { |record| }
+      expect(request).to have_been_made
+    end
+  end
+end

data/spec/record/find_in_batches_spec.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Collection do
+  let(:total) { 443 }
+
+  let(:limit) { 100 }
+
+  def api_response(ids, offset, options = {})
+    records = ids.map { |i| { id: i } }
+    {
+      options.fetch(:items_key, :items) => records,
+      options.fetch(:total_key, :total) => total,
+      options.fetch(:limit_key, :limit) => limit,
+      options.fetch(:pagination_key, :offset) => offset
+    }.to_json
+  end
+
+  let(:datastore) { 'http://local.ch/v2' }
+
+  before do
+    LHC.config.placeholder('datastore', datastore)
+    class Record < LHS::Record
+      endpoint '{+datastore}/{campaign_id}/feedbacks'
+      endpoint '{+datastore}/feedbacks'
+    end
+  end
+
+  context 'find_batches' do
+    it 'processes records in batches' do
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=1").to_return(status: 200, body: api_response((1..100).to_a, 1))
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=101").to_return(status: 200, body: api_response((101..200).to_a, 101))
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=201").to_return(status: 200, body: api_response((201..300).to_a, 201))
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=301").to_return(status: 200, body: api_response((301..400).to_a, 301))
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=401").to_return(status: 200, body: api_response((401..total).to_a, 401))
+      length = 0
+      Record.find_in_batches do |records|
+        length += records.length
+        expect(records).to be_kind_of Record
+        expect(records._proxy).to be_kind_of LHS::Collection
+      end
+      expect(length).to eq total
+    end
+
+    it 'adapts to backend max limit' do
+      stub_request(:get, "#{datastore}/feedbacks?limit=230&offset=1").to_return(status: 200, body: api_response((1..100).to_a, 1))
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=101").to_return(status: 200, body: api_response((101..200).to_a, 101))
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=201").to_return(status: 200, body: api_response((201..300).to_a, 201))
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=301").to_return(status: 200, body: api_response((301..400).to_a, 301))
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=401").to_return(status: 200, body: api_response((401..total).to_a, 401))
+      length = 0
+      Record.find_in_batches(batch_size: 230) do |records|
+        length += records.length
+        expect(records).to be_kind_of Record
+        expect(records._proxy).to be_kind_of LHS::Collection
+      end
+      expect(length).to eq total
+    end
+
+    it 'forwards offset' do
+      stub_request(:get, "#{datastore}/feedbacks?limit=100&offset=401").to_return(status: 200, body: api_response((401..total).to_a, 401))
+      Record.find_in_batches(start: 401) do |records|
+        expect(records.length).to eq(total - 400)
+      end
+    end
+  end
+
+  context 'configured pagination' do
+    before do
+      class Record < LHS::Record
+        endpoint '{+datastore}/{campaign_id}/feedbacks'
+        endpoint '{+datastore}/feedbacks'
+        configuration items_key: 'docs', limit_key: 'size', pagination_key: 'start', pagination_strategy: 'start', total_key: 'totalResults'
+      end
+    end
+
+    let(:options) { { items_key: 'docs', limit_key: 'size', pagination_key: 'start', total_key: 'totalResults' } }
+
+    it 'capable to do batch processing with configured pagination' do
+      stub_request(:get, "#{datastore}/feedbacks?size=230&start=1").to_return(status: 200, body: api_response((1..100).to_a, 1, options))
+      stub_request(:get, "#{datastore}/feedbacks?size=100&start=101").to_return(status: 200, body: api_response((101..200).to_a, 101, options))
+      stub_request(:get, "#{datastore}/feedbacks?size=100&start=201").to_return(status: 200, body: api_response((201..300).to_a, 201, options))
+      stub_request(:get, "#{datastore}/feedbacks?size=100&start=301").to_return(status: 200, body: api_response((301..400).to_a, 301, options))
+      stub_request(:get, "#{datastore}/feedbacks?size=100&start=401").to_return(status: 200, body: api_response((401..total).to_a, 401, options))
+      length = 0
+      Record.find_in_batches(batch_size: 230) do |records|
+        length += records.length
+        expect(records).to be_kind_of Record
+        expect(records._proxy).to be_kind_of LHS::Collection
+      end
+      expect(length).to eq total
+    end
+  end
+
+  context 'pagination with nested response' do
+    before do
+      class Record < LHS::Record
+        endpoint '{+datastore}/{campaign_id}/feedbacks'
+        endpoint '{+datastore}/feedbacks'
+        configuration items_key: [:response, :docs], limit_key: { body: [:response, :size], parameter: :size }, pagination_key: { body: [:response, :start], parameter: :start }, pagination_strategy: :start, total_key: [:response, :totalResults]
+      end
+    end
+
+    let(:options) { { items_key: 'docs', limit_key: 'size', pagination_key: 'start', total_key: 'totalResults' } }
+
+    it 'capable to do batch processing with configured pagination' do
+      stub_request(:get, "#{datastore}/feedbacks?size=230&start=1").to_return(status: 200, body: "{\"response\":#{api_response((1..100).to_a, 1, options)}}")
+      stub_request(:get, "#{datastore}/feedbacks?size=100&start=101").to_return(status: 200, body: "{\"response\":#{api_response((101..200).to_a, 101, options)}}")
+      stub_request(:get, "#{datastore}/feedbacks?size=100&start=201").to_return(status: 200, body: "{\"response\":#{api_response((201..300).to_a, 201, options)}}")
+      stub_request(:get, "#{datastore}/feedbacks?size=100&start=301").to_return(status: 200, body: "{\"response\":#{api_response((301..400).to_a, 301, options)}}")
+      stub_request(:get, "#{datastore}/feedbacks?size=100&start=401").to_return(status: 200, body: "{\"response\":#{api_response((401..total).to_a, 401, options)}}")
+      length = 0
+      Record.find_in_batches(batch_size: 230) do |records|
+        length += records.length
+        expect(records).to be_kind_of Record
+        expect(records._proxy).to be_kind_of LHS::Collection
+      end
+      expect(length).to eq total
+    end
+  end
+end

data/spec/record/find_in_parallel_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  before do
+    class Record < LHS::Record
+      endpoint 'http://datastore/records/{id}'
+    end
+  end
+
+  context 'find in parallel' do
+    before do
+      stub_request(:get, "http://datastore/records/1").to_return(status: 200, body: { id: 1 }.to_json)
+      stub_request(:get, "http://datastore/records/3").to_return(status: 200, body: { id: 3 }.to_json)
+    end
+
+    it 'finds records in parallel' do
+      stub_request(:get, "http://datastore/records/2").to_return(status: 200, body: { id: 2 }.to_json)
+      allow(Record).to receive(:request).and_call_original
+      data = Record.find([1, 2, 3])
+      expect(Record).to have_received(:request).once
+      expect(data[0].id).to eq 1
+      expect(data[1].id).to eq 2
+      expect(data[2].id).to eq 3
+    end
+
+    it 'raises an exeption if one of the parallel request fails' do
+      stub_request(:get, "http://datastore/records/2").to_return(status: 401)
+      expect(-> { Record.find([1, 2, 3]) }).to raise_error(LHC::Unauthorized)
+    end
+
+    it 'applies error handlers from the chain and returns whatever the error handler returns' do
+      stub_request(:get, "http://datastore/records/2").to_return(status: 401)
+      data = Record
+        .rescue(LHC::Unauthorized, ->(_response) { Record.new(name: 'unknown') })
+        .find(1, 2, 3)
+      expect(data[1].name).to eq 'unknown'
+    end
+  end
+
+  context 'find in parallel with extra methods' do
+    before do
+      class Record < LHS::Record
+        endpoint 'http://datastore/records/{id}'
+
+        def identifier
+          123456
+        end
+      end
+
+      stub_request(:get, "http://datastore/records/1").to_return(status: 200, body: { id: 1 }.to_json)
+      stub_request(:get, "http://datastore/records/2").to_return(status: 200, body: { id: 2 }.to_json)
+      stub_request(:get, "http://datastore/records/3").to_return(status: 200, body: { id: 3 }.to_json)
+    end
+
+    it 'finds single record in parallel' do
+      data = Record.find([1])
+      expect(data[0].identifier).to eq 123456
+    end
+
+    it 'finds records in parallel' do
+      data = Record.find([1, 2, 3])
+      expect(data[0].identifier).to eq 123456
+    end
+  end
+end

data/spec/record/find_spec.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  let(:datastore) { 'http://local.ch/v2' }
+
+  before do
+    LHC.config.placeholder(:datastore, datastore)
+    class Record < LHS::Record
+      endpoint '{+datastore}/content-ads/{campaign_id}/feedbacks'
+      endpoint '{+datastore}/content-ads/{campaign_id}/feedbacks/{id}'
+      endpoint '{+datastore}/feedbacks'
+      endpoint '{+datastore}/feedbacks/{id}'
+    end
+  end
+
+  context 'find' do
+    context 'finds a single unique record' do
+      before do
+        stub_request(:get, "#{datastore}/feedbacks/z12f-3asm3ngals")
+          .to_return(status: 200, body: load_json(:feedback))
+      end
+
+      it 'by id' do
+        record = Record.find('z12f-3asm3ngals')
+        expect(record).to be_kind_of Record
+        expect(record.source_id).to be_kind_of String
+      end
+
+      it 'by href' do
+        record = Record.find("#{datastore}/feedbacks/z12f-3asm3ngals")
+        expect(record).to be_kind_of Record
+        expect(record.source_id).to be_kind_of String
+      end
+    end
+
+    context 'endpoint without identifier' do
+      before do
+        class LatestAGB < LHS::Record
+          endpoint 'agbs/latest'
+        end
+      end
+
+      it 'finds a single unique record' do
+        stub_request(:get, 'http://agbs/latest')
+          .to_return(body: { pdf: 'http://local.ch/1.pdf' }.to_json)
+
+        expect(LatestAGB.find.pdf).to eq 'http://local.ch/1.pdf'
+      end
+    end
+
+  end
+
+  it 'raises if empty id' do
+    expect { Record.find('') }.to raise_error LHS::Unprocessable
+  end
+
+  it 'raises if nothing was found' do
+    stub_request(:get, "#{datastore}/feedbacks/not-existing")
+      .to_return(status: 404)
+    expect { Record.find('not-existing') }.to raise_error LHC::NotFound
+  end
+
+  it 'finds unique item by providing parameters' do
+    stub_request(:get, "#{datastore}/content-ads/123/feedbacks/123")
+      .to_return(body: "{}")
+    data = Record.find(campaign_id: '123', id: '123')
+    expect(data._proxy).to be_kind_of LHS::Item
+  end
+
+  it 'returns item in case of backend returning collection' do
+    data = JSON.parse(load_json(:feedbacks))
+    data['items'] = [data['items'].first]
+    stub_request(:get, "#{datastore}/content-ads/123/feedbacks/123")
+      .to_return(body: data.to_json)
+    data = Record.find(campaign_id: '123', id: '123')
+    expect(data._proxy).to be_kind_of LHS::Item
+  end
+
+  it 'fails when multiple items where found by parameters' do
+    stub_request(:get, "#{datastore}/content-ads/123/feedbacks/123")
+      .to_return(body: load_json(:feedbacks))
+    expect(lambda {
+      Record.find(campaign_id: '123', id: '123')
+    }).to raise_error LHC::NotFound
+  end
+
+  it 'fails when no item as found by parameters' do
+    data = JSON.parse(load_json(:feedbacks))
+    data['items'] = []
+    stub_request(:get, "#{datastore}/content-ads/123/feedbacks/123")
+      .to_return(body: data.to_json)
+    expect(lambda {
+      Record.find(campaign_id: '123', id: '123')
+    }).to raise_error LHC::NotFound
+  end
+
+  it 'raises if nothing was found with parameters' do
+    stub_request(:get, "#{datastore}/content-ads/123/feedbacks/123")
+      .to_return(status: 404)
+    expect { Record.find(campaign_id: '123', id: '123') }.to raise_error LHC::NotFound
+  end
+end