lhs 24.0.0

data/spec/record/attribute_assignment_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  before do
+    class LocalEntry < LHS::Record
+      endpoint '{+datastore}/local-entries'
+    end
+  end
+
+  context '#assign_attributes' do
+    it 'sets the attributes' do
+      entry = LocalEntry.new
+      entry.assign_attributes(company_name: 'localsearch')
+      expect(entry.company_name).to eq 'localsearch'
+    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, 'localsearch'])
+      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 LHS::Record do
+  context 'build' do
+    let(:datastore) { 'http://local.ch/v2' }
+
+    before do
+      LHC.config.placeholder('datastore', datastore)
+      class Feedback < LHS::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://local.ch/v2/feedbacks')
+        .with(body: "{\"recommended\":true}")
+      feedback.save
+    end
+  end
+end

data/spec/record/cast_nested_data_spec.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::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 < LHS::Record
+        endpoint 'https://datastore/customers'
+        endpoint 'https://datastore/customers/{id}'
+      end
+      class Contract < LHS::Record
+        endpoint 'https://datastore/contracts'
+        endpoint 'https://datastore/contracts/{id}'
+      end
+      class Address < LHS::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/create_spec.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  context 'create' do
+    let(:datastore) { 'http://local.ch/v2' }
+
+    before do
+      LHC.config.placeholder('datastore', datastore)
+      class Feedback < LHS::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 LHS::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(LHC::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 < LHS::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

data/spec/record/creation_failed_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  context 'creation failed' do
+    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
+
+    let(:error_message) { "ratings must be set when review or name or review_title is set | The property value is required; it cannot be null, empty, or blank." }
+
+    let(:creation_error) do
+      {
+        "status" => 400,
+        "message" => error_message,
+        "fields" => [
+          {
+            "name" => "ratings",
+            "details" => [{ "code" => "REQUIRED_PROPERTY_VALUE" }]
+          }, {
+            "name" => "recommended",
+            "details" => [{ "code" => "REQUIRED_PROPERTY_VALUE" }]
+          }
+        ]
+      }
+    end
+
+    it 'provides errors when creation failed' do
+      stub_request(:post, "#{datastore}/feedbacks")
+        .to_return(status: 400, body: creation_error.to_json)
+      record = Record.create(name: 'Steve')
+      expect(record).to be_kind_of Record
+      expect(record.errors).to be_present
+      expect(record.name).to eq 'Steve'
+      expect(record.errors.include?(:ratings)).to eq true
+      expect(record.errors.include?(:recommended)).to eq true
+      expect(record.errors[:ratings]).to eq ['REQUIRED_PROPERTY_VALUE']
+      expect(record.errors.messages).to eq('ratings' => ["REQUIRED_PROPERTY_VALUE"], 'recommended' => ["REQUIRED_PROPERTY_VALUE"])
+      expect(record.errors.message).to eq error_message
+    end
+
+    it 'doesnt fail when no fields are provided by the backend' do
+      stub_request(:post, "#{datastore}/feedbacks")
+        .to_return(status: 400, body: {}.to_json)
+      Record.create(name: 'Steve')
+    end
+  end
+end

data/spec/record/custom_setters_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  context 'custom setters' do
+
+    context 'assigning values directly to other attributes' do
+
+      before do
+        Object.send(:remove_const, :Booking) # make sure there is no other booking from previous tests around
+        class Booking < LHS::Record
+          endpoint 'https://bookings'
+
+          def appointment_attributes=(params)
+            self.appointments = params.map { |item| item[:id] }
+          end
+        end
+      end
+
+      it 'allows to change raw in custom setters' do
+        booking = Booking.new(appointment_attributes: [{ id: 1 }])
+        expect(booking.appointments.to_a).to eq [1]
+      end
+    end
+
+    context 'assign values directly by using square brackets' do
+
+      before do
+        class Booking < LHS::Record
+          endpoint 'https://bookings'
+
+          def appointment_attributes=(params)
+            self[:appointments] = params.map { |item| item[:id] }
+          end
+        end
+      end
+
+      it 'allows to change raw in custom setters' do
+        booking = Booking.new(appointment_attributes: [{ id: 1 }])
+        expect(booking.appointments.to_a).to eq [1]
+      end
+    end
+  end
+end

data/spec/record/definitions_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  context 'definitions' do
+    let(:datastore) { 'http://local.ch/v2' }
+
+    before do
+      LHC.config.placeholder('datastore', datastore)
+      class LocalEntry < LHS::Record
+        endpoint '{+datastore}/local-entries'
+        endpoint '{+datastore}/local-entries/{id}'
+      end
+    end
+
+    it 'allows mappings in all functions/defitions' do
+      class LocalEntry < LHS::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
+  end
+end

data/spec/record/destroy_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  context 'destroy' do
+    before do
+      class Record < LHS::Record
+        endpoint 'http://datastore/history'
+        endpoint 'http://datastore/history/{id}'
+      end
+    end
+
+    let(:entry) { { what: 'Cafe', where: 'Zurich' } }
+
+    it 'allows to destroy by parameters directly' do
+      stub_request(:delete, "http://datastore/history?what=Cafe&where=Zurich")
+        .to_return(body: [entry].to_json)
+      deleted_entries = Record.destroy(what: 'Cafe', where: 'Zurich')
+      expect(deleted_entries.first.to_h).to eq entry
+    end
+
+    it 'allows to destroy by id' do
+      stub_request(:delete, "http://datastore/history/1")
+        .to_return(body: entry.to_json)
+      deleted_entry = Record.destroy(1)
+      expect(deleted_entry.to_h).to eq entry
+    end
+
+    it 'chains' do
+      stub_request(:delete, "http://datastore/history/1")
+        .with(headers: { 'Authorization' => 'Bearer 123' })
+        .to_return(body: entry.to_json)
+      deleted_entry = Record.options(headers: { 'Authorization' => 'Bearer 123' }).destroy(1)
+      expect(deleted_entry.to_h).to eq entry
+    end
+  end
+end