dhs 1.0.0

data/spec/record/includes_warning_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHS::Record do
+  context 'includes warning' do
+    before do
+      class Customer < DHS::Record
+        endpoint 'http://datastore/customers/{id}'
+      end
+    end
+
+    let!(:customer_request) do
+      stub_request(:get, 'http://datastore/customers/1')
+        .to_return(
+          body: {
+            contracts: { href: 'http://datastore/customers/1/contracts' }
+          }.to_json
+        )
+    end
+
+    let!(:contracts_request) do
+      stub_request(:get, 'http://datastore/customers/1/contracts')
+        .to_return(
+          body: {
+            items: 10.times.map do
+              {
+                products: { href: 'http://datastore/products' }
+              }
+            end,
+            limit: 10,
+            offset: 0,
+            total: 33
+          }.to_json
+        )
+    end
+
+    it 'warns if linked data was simply included but is paginated' do
+      expect(lambda {
+        Customer.includes_first_page(:contracts).find(1)
+      }).to output(
+        %r{\[WARNING\] You included `http://datastore/customers/1/contracts`, but this endpoint is paginated. You might want to use `includes_all` instead of `includes` \(https://github.com/DePayFi/dhs#includes_all-for-paginated-endpoints\)\.}
+      ).to_stderr
+    end
+  end
+end

data/spec/record/item_key_spec.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHS::Record do
+  before do
+    class Location < DHS::Record
+      configuration item_key: %i[response location]
+      endpoint 'http://uberall/location'
+      endpoint 'http://uberall/location/{id}'
+    end
+  end
+
+  let(:location_response) do
+    {
+      response: {
+        location: {
+          id: 1
+        }
+      }
+    }.to_json
+  end
+
+  let(:stub_request_by_id) do
+    stub_request(:get, 'http://uberall/location/1')
+      .to_return(body: location_response)
+  end
+
+  let(:stub_request_by_get_parameters) do
+    stub_request(:get, 'http://uberall/location?identifier=1&limit=1')
+      .to_return(body: location_response)
+  end
+
+  it 'uses configured item_key to unwrap response data for find' do
+    stub_request_by_id
+    location = Location.find(1)
+    expect(location.id).to eq 1
+  end
+
+  it 'uses configured item_key to unwrap response data for find_by' do
+    stub_request_by_get_parameters
+    location = Location.find_by(identifier: 1)
+    expect(location.id).to eq 1
+  end
+
+  describe 'Holding on to request object' do
+    let(:account_response) do
+      { id: 1 }.to_json
+    end
+
+    let(:stub_location_by_id) do
+      stub_request(:get, 'http://uberall/location/1')
+        .to_return(headers: { 'X-Custom-Header' => 'rspec' }, body: location_response)
+    end
+
+    let(:stub_account_by_id) do
+      stub_request(:get, 'http://yext/account/1')
+        .to_return(headers: { 'X-Custom-Header' => 'rspec' }, body: account_response)
+    end
+
+    before do
+      class Account < DHS::Record
+        endpoint 'http://yext/account'
+        endpoint 'http://yext/account/{id}'
+      end
+
+      stub_location_by_id
+      stub_account_by_id
+    end
+
+    it 'preserves request object for nested items' do
+      location = Location.find(1)
+      expect(location._request).to be_present
+    end
+
+    it 'preserves request object for unnested items' do
+      account = Account.find(1)
+      expect(account._request).to be_present
+    end
+  end
+end

data/spec/record/items_created_key_configuration_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHS::Record do
+  before do
+    class Business < DHS::Record
+      configuration item_created_key: %i[response business], limit_key: %i[response max], pagination_key: %i[response offset], total_key: %i[response count], pagination_strategy: :offset
+      endpoint 'http://uberall/businesses'
+    end
+  end
+
+  let(:stub_create_business_request) do
+    stub_request(:post, 'http://uberall/businesses')
+      .to_return(body: {
+        status: 'SUCCESS',
+        response: {
+          business: {
+            identifier: 'ABC123',
+            name: 'depay',
+            id: 239650
+          }
+        }
+      }.to_json)
+  end
+
+  it 'uses paths from configuration to access nested values' do
+    stub_create_business_request
+    business = Business.create!(
+      identifier: 'ABC123',
+      name: 'depay'
+    )
+    expect(business.identifier).to eq 'ABC123'
+    expect(business.name).to eq 'depay'
+    expect(business.id).to eq 239650
+  end
+end

data/spec/record/last_spec.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHS::Record do
+  context 'last' do
+    context 'for not paginated endpoints' do
+      before do
+        class Sector < DHS::Record
+          endpoint 'http://services/sectors'
+        end
+
+        stub_request(:get, 'http://services/sectors?limit=1')
+          .to_return(
+            body: [{ number: 1 }, { number: 2 }, { number: 3 }].to_json
+          )
+      end
+
+      it 'returns the last record from the already complete collection' do
+        sector = Sector.last
+        expect(sector).to be_kind_of Sector
+        expect(sector.number).to eq 3
+      end
+    end
+
+    context 'for paginated endpoints' do
+      before do
+        class Place < DHS::Record
+          endpoint 'http://datastore/places'
+        end
+
+        stub_request(:get, 'http://datastore/places?limit=1')
+          .to_return(
+            body: {
+              items: [
+                { id: 'first-1', company_name: 'Localsearch AG' }
+              ],
+              total: 500,
+              limit: 1,
+              offset: 0
+            }.to_json
+          )
+
+        stub_request(:get, 'http://datastore/places?limit=1&offset=499')
+          .to_return(
+            body: {
+              items: [
+                { id: 'last-500', company_name: 'Curious GmbH' }
+              ],
+              total: 500,
+              limit: 1,
+              offset: 0
+            }.to_json
+          )
+      end
+
+      it 'returns the last record from the already complete collection' do
+        place = Place.last
+        expect(place).to be_kind_of Place
+        expect(place.id).to eq 'last-500'
+      end
+    end
+  end
+end

data/spec/record/loading_twice_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHS::Record do
+  context 'build' do
+    let(:datastore) { 'http://depay.fi/v2' }
+
+    it 'is possible to load records twice' do
+      class Feedback < DHS::Record
+        endpoint '{+datastore}/feedbacks'
+      end
+
+      class Feedback < DHS::Record
+        endpoint '{+datastore}/feedbacks'
+      end
+    end
+  end
+end

data/spec/record/mapping_spec.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHS::Record do
+  context 'mapping' do
+    let(:datastore) { 'http://depay.fi/v2' }
+
+    before do
+      DHC.config.placeholder('datastore', datastore)
+      class LocalEntry < DHS::Record
+        endpoint '{+datastore}/local-entries'
+        endpoint '{+datastore}/local-entries/{id}'
+      end
+    end
+
+    it 'maps some attr accessors to another target (proxy)' do
+      class LocalEntry < DHS::Record
+        def name
+          addresses.first.business.identities.first.name
+        end
+      end
+      stub_request(:get, "#{datastore}/local-entries/1")
+        .to_return(status: 200, body: { addresses: [{ business: { identities: [{ name: 'Löwenzorn' }] } }] }.to_json)
+      entry = LocalEntry.find(1)
+      expect(entry.name).to eq 'Löwenzorn'
+    end
+
+    it 'maps for root_item even if that item is nested in a root collection' do
+      class LocalEntry < DHS::Record
+        def name
+          addresses.first.business.identities.first.name
+        end
+      end
+      stub_request(:get, "#{datastore}/local-entries/1?limit=1")
+        .to_return(status: 200, body: { items: [{ addresses: [{ business: { identities: [{ name: 'Löwenzorn' }] } }] }] }.to_json)
+      entry = LocalEntry.find_by(id: 1)
+      expect(entry.name).to eq 'Löwenzorn'
+    end
+
+    it 'return data proxy in case of item or collection' do
+      class LocalEntry < DHS::Record
+        def business
+          addresses.first.business
+        end
+      end
+      stub_request(:get, "#{datastore}/local-entries/1")
+        .to_return(status: 200, body: { addresses: [{ business: { identities: [{ name: 'Löwenzorn' }] } }] }.to_json)
+      entry = LocalEntry.find(1)
+      expect(entry.business).to be_kind_of DHS::Data
+    end
+
+    it 'clones mappings when using include' do
+      class Agb < DHS::Record
+        endpoint '{+datastore}/agbs/active?agb_type=CC_TOU'
+        def pdf_url
+          self['binary_url_pdf_de']
+        end
+      end
+
+      preceding_agb_url = "#{datastore}/agbs/547f0b461c266c4830ea6cea"
+      # initial request
+      stub_request(:get, "#{datastore}/agbs/active?agb_type=CC_TOU&limit=1")
+        .to_return(
+          status: 200,
+          body: {
+            'href' => "#{datastore}/agbs/547f02c61c266c4830ea6ce7",
+            'preceding_agb' => { 'href' => preceding_agb_url },
+            'binary_url_pdf_de' => 'de'
+          }.to_json
+        )
+
+      # includes request
+      stub_request(:get, preceding_agb_url).to_return(
+        status: 200, body: { 'href' => preceding_agb_url }.to_json, headers: {}
+      )
+
+      agb = Agb.includes_first_page(:preceding_agb).first!
+      expect(agb.pdf_url).to be == 'de'
+    end
+
+    it 'makes mappings available even for nested data' do
+      class LocalEntry < DHS::Record
+        def name
+          company_name
+        end
+      end
+
+      class Favorite < DHS::Record
+        endpoint '{+datastore}/favorites'
+        endpoint '{+datastore}/favorites/{id}'
+      end
+      stub_request(:get, "#{datastore}/local-entries/1")
+        .to_return(body: { company_name: 'depay.fi' }.to_json)
+      stub_request(:get, "#{datastore}/favorites/1")
+        .to_return(body: { local_entry: { href: "#{datastore}/local-entries/1" } }.to_json)
+
+      favorite = Favorite.includes_first_page(:local_entry).find(1)
+      expect(favorite.local_entry).to be_kind_of LocalEntry
+      expect(favorite.local_entry.name).to eq 'depay.fi'
+    end
+  end
+end

data/spec/record/model_name_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHS::Record do
+  context 'model_name' do
+    before do
+      class LocalEntry < DHS::Record
+        endpoint '{+datastore}/local-entries'
+      end
+    end
+
+    it 'provides a model name' do
+      expect(LocalEntry.model_name.name).to eq 'LocalEntry'
+    end
+  end
+end

data/spec/record/new_spec.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHS::Record do
+  context 'new' do
+    let(:datastore) { 'http://depay.fi/v2' }
+
+    before do
+      DHC.config.placeholder('datastore', datastore)
+      class Rating < DHS::Record
+        endpoint '{+datastore}/content-ads/{campaign_id}/feedbacks'
+        endpoint '{+datastore}/feedbacks'
+      end
+    end
+
+    it 'builds a new item from scratch (like build)' do
+      feedback = Rating.new recommended: true
+      expect(feedback).to be_kind_of Rating
+      expect(feedback.recommended).to eq true
+      stub_request(:post, 'http://depay.fi/v2/feedbacks')
+        .with(body: '{"recommended":true}')
+      feedback.save
+    end
+
+    it 'builds new items also with keys containing dashes' do
+      feedback = Rating.new('some-key' => [])
+      expect(feedback._raw[:'some-key']).to eq([])
+    end
+
+    context 'initialise records with raw data' do
+      before do
+        class User < DHS::Record
+          endpoint '{+datastore}/users'
+        end
+      end
+
+      it 'allows accessing nested data' do
+        user = User.new({
+          claims: {
+            items: [
+              { method: 'CustomerCenter' }
+            ]
+          }
+        }.to_json)
+        expect(user.claims.first['method']).to eq 'CustomerCenter'
+      end
+    end
+
+    context 'custom setters' do
+      before do
+        class Rating
+          def ratings=(ratings)
+            _raw[:ratings] = ratings.map { |k, v| { name: k, value: v } }
+          end
+        end
+      end
+
+      it 'are used by initializer' do
+        feedback = Rating.new(ratings: { a: 1, b: 2 })
+        expect(feedback.ratings._raw).to eq([{ name: :a, value: 1 }, { name: :b, value: 2 }])
+      end
+
+      it 'can be used directly to change raw data' do
+        feedback = Rating.new(ratings: { a: 1 })
+        feedback.ratings = { z: 3 }
+        expect(feedback.ratings.first.name).to eq :z
+      end
+
+      context 'that do not affect raw data' do
+        before do
+          class Rating
+            attr_accessor :listing
+          end
+        end
+
+        let(:listing) { double('listing') }
+
+        it 'are used by initializer' do
+          feedback = Rating.new(listing: listing)
+          expect(feedback.listing).to eq(listing)
+        end
+
+        it 'do not set raw data' do
+          feedback = Rating.new(listing: listing)
+          expect(feedback._raw[:listing]).to be_nil
+        end
+      end
+
+      context 'and custom getters' do
+        before do
+          class Rating
+            def ratings
+              Hash[_raw[:ratings].map { |r| [r[:name], r[:value]] }]
+            end
+          end
+        end
+
+        it 'uses custom getters to show data for exploration' do
+          feedback = Rating.new(ratings: { a: 1, b: 2 })
+          expect(feedback.ratings).to eq(a: 1, b: 2)
+        end
+      end
+    end
+  end
+end