dhs 1.0.0

data/spec/record/all_spec.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHS::Record do
+  context 'all' do
+    before do
+      class Record < DHS::Record
+        endpoint 'http://datastore/feedbacks'
+      end
+    end
+
+    it 'is querying endpoint without pagination when using all' do
+      stub_request(:get, 'http://datastore/feedbacks?limit=100').to_return(body: { items: 300.times.map { { foo: 'bar' } }, total: 300 }.to_json)
+      records = Record.all
+      expect(records).to be_kind_of Record
+      expect(records.size).to eq(300)
+    end
+
+    context 'is chainable with where and works like where' do
+      let(:total) { 22 }
+      let(:limit) { 10 }
+      let!(:first_page_request) do
+        stub_request(:get, 'http://datastore/feedbacks?color=blue&limit=100')
+          .to_return(body: { items: 10.times.map { { foo: 'bar' } }, total: total, limit: limit, offset: 0 }.to_json)
+      end
+      let!(:second_page_request) do
+        stub_request(:get, "http://datastore/feedbacks?color=blue&limit=#{limit}&offset=10")
+          .to_return(body: { items: 10.times.map { { foo: 'bar' } }, total: total, limit: limit, offset: 10 }.to_json)
+      end
+      let!(:third_page_request) do
+        stub_request(:get, "http://datastore/feedbacks?color=blue&limit=#{limit}&offset=20")
+          .to_return(body: { items: 2.times.map { { foo: 'bar' } }, total: total, limit: limit, offset: 20 }.to_json)
+      end
+
+      it 'fetches all remote objects' do
+        records = Record.where(color: 'blue').all
+        expect(records.length).to eq total
+        expect(first_page_request).to have_been_requested.times(1)
+        expect(second_page_request).to have_been_requested.times(1)
+        expect(third_page_request).to have_been_requested.times(1)
+        records = Record.all.where(color: 'blue')
+        expect(records.length).to eq total
+        expect(first_page_request).to have_been_requested.times(2)
+        expect(second_page_request).to have_been_requested.times(2)
+        expect(third_page_request).to have_been_requested.times(2)
+        records = Record.all(color: 'blue')
+        expect(records.length).to eq total
+        expect(first_page_request).to have_been_requested.times(3)
+        expect(second_page_request).to have_been_requested.times(3)
+        expect(third_page_request).to have_been_requested.times(3)
+      end
+
+      it 'works in combination with include and includes' do
+        records = Record.includes_first_page(:product).includes(:options).all(color: 'blue')
+        expect(records.length).to eq total
+        expect(first_page_request).to have_been_requested.times(1)
+        expect(second_page_request).to have_been_requested.times(1)
+        expect(third_page_request).to have_been_requested.times(1)
+      end
+    end
+  end
+
+  context 'all without current page indicator' do
+    before do
+      class Category < DHS::Record
+        configuration(
+          items_key: %i(response results),
+          limit_key: :max,
+          pagination_key: :offset,
+          pagination_strategy: :offset
+        )
+
+        endpoint 'http://store/categories'
+      end
+    end
+
+    def stub_batch(url, items = 10)
+      stub_request(:get, url)
+        .to_return(
+          body: {
+            response: {
+              results: items.times.map { { name: 'category' } }
+            }
+          }.to_json
+        )
+    end
+
+    it 'is able to fetch all remote objects without any current page indicator by simply increasing the offset until response is empty with a limit' do
+      stub_batch('http://store/categories?language=en&max=10&offset=0')
+      stub_batch('http://store/categories?language=en&max=10&offset=10')
+      stub_batch('http://store/categories?language=en&max=10&offset=20')
+      stub_batch('http://store/categories?language=en&max=10&offset=30', 0)
+      records = Category.limit(10).all(language: 'en').fetch
+      expect(records.length).to eq 30
+    end
+
+    it 'is able to fetch all remote objects without any current page indicator by simply increasing the offset until response is empty' do
+      stub_batch('http://store/categories?language=en&max=100', 100)
+      stub_batch('http://store/categories?language=en&max=100&offset=100', 100)
+      stub_batch('http://store/categories?language=en&max=100&offset=200', 100)
+      stub_batch('http://store/categories?language=en&max=100&offset=300', 0)
+      records = Category.all(language: 'en').fetch
+      expect(records.length).to eq 300
+    end
+
+    it 'outputs a warning, if all is requested, but endpoint does not implement pagination meta data' do
+      stub_batch('http://store/categories?language=en&max=100', 100)
+      stub_batch('http://store/categories?language=en&max=100&offset=100', 100)
+      stub_batch('http://store/categories?language=en&max=100&offset=200', 100)
+      stub_batch('http://store/categories?language=en&max=100&offset=300', 0)
+      expect(-> { Category.all(language: 'en').fetch }).to output(
+        %r{\[Warning\] "all" has been requested, but endpoint does not provide pagination meta data. If you just want to fetch the first response, use "where" or "fetch".}
+      ).to_stderr
+    end
+
+    context 'with record set to not paginated' do
+      before do
+        class Record < DHS::Record
+          configuration paginated: false
+          endpoint 'http://datastore/records'
+        end
+      end
+
+      it 'just fetches the first response' do
+        stub_request(:get, 'http://datastore/records')
+          .to_return(body: [{ name: 'Steve' }].to_json)
+        records = Record.all
+        expect(records.first.name).to eq 'Steve'
+      end
+    end
+  end
+end

data/spec/record/attribute_assignment_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHS::Record do
+  before do
+    class LocalEntry < DHS::Record
+      endpoint '{+datastore}/local-entries'
+    end
+  end
+
+  context '#assign_attributes' do
+    it 'sets the attributes' do
+      entry = LocalEntry.new
+      entry.assign_attributes(company_name: 'depay')
+      expect(entry.company_name).to eq 'depay'
+    end
+  end
+
+  context 'when not a hash was passed' do
+    it 'raises an error' do
+      entry = LocalEntry.new
+      expect do
+        entry.assign_attributes([:company_name, 'depay'])
+      end.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/record/build_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHS::Record do
+  context 'build' 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'
+        endpoint '{+datastore}/feedbacks'
+      end
+    end
+
+    it 'builds a new item from scratch' do
+      feedback = Feedback.build recommended: true
+      expect(feedback).to be_kind_of Feedback
+      expect(feedback.recommended).to eq true
+      stub_request(:post, 'http://depay.fi/v2/feedbacks')
+        .with(body: '{"recommended":true}')
+      feedback.save
+    end
+  end
+end

data/spec/record/cast_nested_data_spec.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHS::Record do
+  context 'cast nested data' do
+    let(:stub_customer_request) do
+      stub_request(:get, 'https://datastore/customers?limit=1')
+        .to_return(
+          body: {
+            items: [
+              {
+                href: 'https://datastore/customers/12',
+                address: {
+                  href: 'https://datastore/addresses/3'
+                },
+                contracts: [
+                  {
+                    href: 'https://datastore/contracts/2'
+                  }
+                ]
+              }
+            ]
+          }.to_json
+        )
+    end
+
+    before do
+      class Customer < DHS::Record
+        endpoint 'https://datastore/customers'
+        endpoint 'https://datastore/customers/{id}'
+      end
+
+      class Contract < DHS::Record
+        endpoint 'https://datastore/contracts'
+        endpoint 'https://datastore/contracts/{id}'
+      end
+
+      class Address < DHS::Record
+        endpoint 'https://datastore/addresses'
+        endpoint 'https://datastore/addresses/{id}', headers: { 'Authorization' => 'Bearer 123' }
+      end
+      stub_customer_request
+    end
+
+    it 'casts nested data properly' do
+      customer = Customer.first
+      expect(customer).to be_kind_of Customer
+      expect(customer.address).to be_kind_of Address
+      expect(customer.contracts.first).to be_kind_of Contract
+    end
+
+    context 'interact with nested resouce remotely' do
+      let(:address_request_stub) do
+        stub_request(:post, 'https://datastore/addresses/3')
+          .with(
+            body: {
+              href: 'https://datastore/addresses/3',
+              zip: 8050
+            }.to_json,
+            headers: {
+              'Authorization': 'Bearer 123'
+            }
+          )
+          .to_return(status: 201)
+      end
+
+      before do
+        address_request_stub
+      end
+
+      it 'applies casted records endpoint options to requests made to the nested resource' do
+        customer = Customer.first
+        address = customer.address
+        address.zip = 8050
+        address.save
+      end
+    end
+  end
+end

data/spec/record/compact_spec.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHS::Record do
+  before do
+    class Place < DHS::Record
+      endpoint 'http://datastore/places/{id}'
+      endpoint 'http://datastore/users/{user_id}/places/{id}'
+
+      def display_name
+        "*#{name}*"
+      end
+    end
+
+    class User < DHS::Record
+      endpoint 'http://datastore/users/{id}'
+    end
+
+    stub_request(:get, 'http://datastore/users/123')
+      .to_return(status: 200, body: {
+        href: 'http://datastore/users/123',
+        places: { href: 'http://datastore/users/123/places' }
+      }.to_json)
+
+    stub_request(:get, 'http://datastore/users/123/places?limit=100')
+      .to_return(status: 200, body: {
+        href: 'http://datastore/users/123/places?offset=0&limit=100',
+        items: [
+          {
+            href: 'http://datastore/users/123/places/789'
+          }, {
+            href: 'http://datastore/users/123/places/790'
+          }
+        ],
+        total: 2,
+        offset: 0,
+        limit: 10
+      }.to_json)
+
+    stub_request(:get, 'http://datastore/users/123/places/789')
+      .to_return(
+        body: {
+          href: 'http://datastore/users/123/places/789?limit=100',
+          name: 'Mc Donalds'
+        }.to_json
+      )
+
+    stub_request(:get, 'http://datastore/users/123/places/790')
+      .to_return(
+        status: 404,
+        body: {
+          status: 404,
+          message: 'The requested resource does not exist.'
+        }.to_json
+      )
+  end
+
+  let(:places) do
+    User
+      .includes(:places)
+      .references(places: { ignore: DHC::NotFound })
+      .find('123')
+      .places
+  end
+
+  context '.compact' do
+    it 'does NOT return an internal data type, but the Record class' do
+      expect(places.compact.class).to eq User
+    end
+
+    it 'removes linked resouces which could not get fetched' do
+      expect(places.compact.length).to eq 1
+      expect(places.length).not_to eq 1 # leaves the original intact
+    end
+  end
+
+  context 'record casting' do
+    let(:expected_display_name) { '*Mc Donalds*' }
+
+    it 'finds the right record class' do
+      expect(places.first.display_name).to eq expected_display_name
+      expect(places.compact.map(&:display_name)).to eq [expected_display_name]
+    end
+  end
+
+  context '.compact!' do
+    it 'removes linked resouces which could not get fetched' do
+      expect(places.compact!.length).to eq 1
+      expect(places.length).to eq 1 # and changes the original intact
+    end
+  end
+end

data/spec/record/create_spec.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe DHS::Record do
+  context 'create' 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'
+        endpoint '{+datastore}/feedbacks'
+      end
+    end
+
+    let(:object) do
+      {
+        recommended: true,
+        source_id: 'aaa'
+      }
+    end
+
+    it 'creates new record on the backend' do
+      stub_request(:post, "#{datastore}/feedbacks")
+        .with(body: object.to_json)
+        .to_return(status: 200, body: object.to_json)
+      record = Feedback.create(object)
+      expect(record).to be_kind_of Feedback
+      expect(record.recommended).to eq true
+      expect(record.errors.messages).to eq({})
+      expect(record.errors.message).to eq nil
+    end
+
+    it 'uses proper endpoint when creating data' do
+      stub_request(:post, "#{datastore}/content-ads/12345/feedbacks")
+        .with(body: object.to_json)
+        .to_return(status: 200, body: object.to_json)
+      Feedback.create(object.merge(campaign_id: '12345'))
+    end
+
+    it 'merges backend response object with object' do
+      body = object.merge(additional_key: 1)
+      stub_request(:post, "#{datastore}/content-ads/12345/feedbacks")
+        .with(body: object.to_json)
+        .to_return(status: 200, body: body.to_json)
+      data = Feedback.create(object.merge(campaign_id: '12345'))
+      expect(data.additional_key).to eq 1
+    end
+
+    context 'creation errors' do
+      let(:creation_error) do
+        {
+          'status' => 400,
+          'fields' => [
+            {
+              'name' => 'ratings',
+              'details' => [{ 'code' => 'REQUIRED_PROPERTY_VALUE' }]
+            }, {
+              'name' => 'recommended',
+              'details' => [{ 'code' => 'REQUIRED_PROPERTY_VALUE' }]
+            }
+          ]
+        }
+      end
+
+      it 'provides errors accessor on the record when creation failed using create' do
+        stub_request(:post, "#{datastore}/content-ads/12345/feedbacks")
+          .to_return(status: 400, body: creation_error.to_json)
+        feedback = Feedback.create(object.merge(campaign_id: '12345'))
+        expect(feedback.errors).to be_kind_of DHS::Problems::Errors
+      end
+
+      it 'raises an exception when creation failed using create!' do
+        stub_request(:post, "#{datastore}/content-ads/12345/feedbacks")
+          .to_return(status: 400, body: creation_error.to_json)
+        expect(lambda {
+          Feedback.create!(object.merge(campaign_id: '12345'))
+        }).to raise_error(DHC::Error)
+      end
+    end
+
+    context 'custom setters' do
+      before do
+        class Feedback
+          def ratings=(ratings)
+            _raw[:ratings] = ratings.map { |k, v| { name: k.to_s, value: v } }
+          end
+        end
+
+        stub_request(:post, "#{datastore}/feedbacks")
+          .with(body: { ratings: converted_ratings }.to_json)
+          .to_return(status: 200, body: { ratings: converted_ratings }.to_json)
+      end
+
+      let(:ratings) do
+        {
+          a: 1,
+          b: 2
+        }
+      end
+
+      let(:converted_ratings) do
+        [
+          { name: 'a', value: 1 },
+          { name: 'b', value: 2 }
+        ]
+      end
+
+      it 'are used by create' do
+        feedback = Feedback.create(ratings: ratings)
+        expect(feedback.ratings._raw).to eq(converted_ratings)
+      end
+
+      it 'can be used directly to change raw data' do
+        feedback = Feedback.create(ratings: ratings)
+        feedback.ratings = { z: 3 }
+        expect(feedback.ratings.first.name).to eq 'z'
+      end
+
+      context 'and custom getters' do
+        before do
+          class Feedback
+            def ratings
+              Hash[_raw[:ratings].map { |r| [r[:name].to_sym, r[:value]] }]
+            end
+          end
+        end
+
+        it 'uses custom getters to show data for exploration' do
+          feedback = Feedback.create(ratings: ratings)
+          expect(feedback.ratings).to eq(ratings)
+        end
+      end
+    end
+
+    context 'location header' do
+      before do
+        class ContactPerson < DHS::Record
+          endpoint 'http://datastore/contact_persons'
+        end
+      end
+
+      let(:location)   { 'http://datastore/contact_persons/1' }
+      let(:created_at) { '2017-12-21' }
+      let(:name)       { 'Sebastian' }
+
+      it 'Loads the data from the "Location" header after creation' do
+        stub_request(:post, 'http://datastore/contact_persons')
+          .to_return(status: 204, headers: { Location: location })
+        stub_request(:get, 'http://datastore/contact_persons/1')
+          .to_return(body: { href: location, name: name, created_at: created_at }.to_json)
+        contact_person = ContactPerson.create!(name: name)
+        expect(contact_person.href).to eq location
+        expect(contact_person.created_at).to eq Date.parse(created_at)
+        expect(contact_person.name).to eq name
+      end
+    end
+  end
+end