lhs 24.0.0

data/spec/item/validation_spec.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Item do
+  let(:user) do
+    User.build(email: 'steve@local.ch')
+  end
+
+  let(:record) do
+    Record.build(number: '123456')
+  end
+
+  context 'deprecation warning for old syntax' do
+    it 'throws errors when using validates with the old syntax' do
+      expect(lambda do
+        class User < LHS::Record
+          endpoint 'http://datastore/v2/users', validates: true
+        end
+      end).to raise_error 'Validates with either true or a simple string is deprecated! See here: https://github.com/local-ch/lhs#validation'
+      expect(lambda do
+        class Record < LHS::Record
+          endpoint 'http://datastore/v2/records', validates: 'publish'
+        end
+      end).to raise_error 'Validates with either true or a simple string is deprecated! See here: https://github.com/local-ch/lhs#validation'
+    end
+  end
+
+  context 'passing validation parameters' do
+    let(:user) do
+      User.build(email: 'steve@local.ch')
+    end
+
+    it 'validates {publish: false}' do
+      class User < LHS::Record
+        endpoint 'http://datastore/v2/users', validates: { params: { publish: false } }
+      end
+      stub_request(:post, "http://datastore/v2/users?publish=false").to_return(body: {}.to_json)
+      expect(user.valid?).to eq true
+    end
+
+    it 'validates {persist: false}' do
+      class User < LHS::Record
+        endpoint 'http://datastore/v2/users', validates: { params: { persist: false } }
+      end
+      stub_request(:post, "http://datastore/v2/users?persist=false").to_return(body: {}.to_json)
+      expect(user.valid?).to eq true
+    end
+
+    it 'validates {validates: true}' do
+      class User < LHS::Record
+        endpoint 'http://datastore/v2/users', validates: { params: { validates: true } }
+      end
+      stub_request(:post, "http://datastore/v2/users?validates=true").to_return(body: {}.to_json)
+      expect(user.valid?).to eq true
+    end
+
+    it 'validates /validate' do
+      class User < LHS::Record
+        endpoint 'http://datastore/v2/users', validates: { path: 'validate' }
+      end
+      stub_request(:post, "http://datastore/v2/users/validate").to_return(body: {}.to_json)
+      expect(user.valid?).to eq true
+    end
+  end
+
+  context 'errors object' do
+    let(:validation_errors) { { field_errors: [{ code: "UNSUPPORTED_PROPERTY_VALUE", "path" => ["email"] }] } }
+    let(:successful_validation) do
+      stub_request(:post, "http://datastore/v2/users?persist=false").to_return(body: {}.to_json)
+    end
+    let(:failing_validation) do
+      stub_request(:post, "http://datastore/v2/users?persist=false")
+        .to_return(status: 400, body: validation_errors.to_json)
+    end
+
+    before do
+      class User < LHS::Record
+        endpoint 'http://datastore/v2/users', validates: { params: { persist: false } }
+      end
+    end
+
+    it 'provides validation errors through the error object' do
+      successful_validation
+      expect(user.valid?).to eq true
+      user.email = 'not a valid email'
+      failing_validation
+      expect(user.valid?).to eq false
+      expect(user.errors[:email]).to be_present
+    end
+
+    it 'gets reset when revalidation' do
+      failing_validation
+      expect(user.valid?).to eq false
+      user.email = 'steve@local.ch'
+      successful_validation
+      expect(user.valid?).to eq true
+      expect(user.errors.messages).to be_empty
+    end
+  end
+
+  context 'endpoint does not support validations' do
+    before do
+      class Favorite < LHS::Record
+        endpoint '{+datastore}/v2/favorites'
+      end
+    end
+
+    it 'fails when trying to use an endpoint for validations that does not support it' do
+      expect(lambda do
+        Favorite.build.valid?
+      end).to raise_error('Endpoint does not support validations!')
+    end
+  end
+
+  context 'generate validation url from locally passed params' do
+    before do
+      class User < LHS::Record
+        endpoint 'http://datastore/v2/users/{user_id}', validates: { params: { persist: false } }
+      end
+    end
+
+    it 'takes local params when generating validation url' do
+      stub_request(:post, "http://datastore/v2/users/2?persist=false")
+        .to_return(status: 201)
+      expect(
+        user.valid?(params: { user_id: 2 })
+      ).to eq true
+    end
+  end
+end

data/spec/item/warning_codes_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Item do
+  context 'error codes' do
+    before do
+      I18n.reload!
+      I18n.backend.store_translations(:en, YAML.safe_load(translation)) if translation.present?
+      class Record < LHS::Record
+        endpoint 'http://datastore/records'
+      end
+    end
+
+    let(:translation) do
+      %q{
+        lhs:
+          warnings:
+            fallback_message: 'This value is problematic'
+      }
+    end
+
+    it 'provides error codes along side with translated messages' do
+      stub_request(:post, 'http://datastore/records')
+        .to_return(body: {
+          field_warnings: [{
+            code: 'UNSUPPORTED_PROPERTY_VALUE',
+            path: ['gender'],
+            message: 'The property value is unsupported.'
+          }, {
+            code: 'INCOMPLETE_PROPERTY_VALUE',
+            path: ['gender'],
+            message: 'The property value is incomplete. It misses some data'
+          }, {
+            code: 'INCOMPLETE_PROPERTY_VALUE',
+            path: ['contract', 'entry_id'],
+            message: 'The property value is incomplete. It misses some data'
+          }]
+        }.to_json)
+      record = Record.create
+      expect(record.warnings.messages['gender']).to eq(
+        ['This value is problematic', 'This value is problematic']
+      )
+      expect(record.warnings.codes['gender']).to eq(
+        ['UNSUPPORTED_PROPERTY_VALUE', 'INCOMPLETE_PROPERTY_VALUE']
+      )
+      expect(record.warnings.messages['contract.entry_id']).to eq(
+        ['This value is problematic']
+      )
+      expect(record.warnings.codes['contract.entry_id']).to eq(
+        ['INCOMPLETE_PROPERTY_VALUE']
+      )
+    end
+  end
+end

data/spec/item/warnings_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Item do
+
+  before do
+    class Presence < LHS::Record
+      endpoint 'http://opm/presence'
+    end
+
+    I18n.reload!
+    I18n.backend.store_translations(:en, YAML.safe_load(%q{
+      lhs:
+        warnings:
+          records:
+            presence:
+              will_be_resized: 'The photos will be resized'
+    }))
+  end
+
+  it 'provides warnings together with validation errors' do
+    stub_request(:post, "http://opm/presence?synchronize=false")
+      .to_return(
+        body: {
+          field_warnings: [{
+            code: 'WILL_BE_RESIZED',
+            path: ['place', 'photos', 0],
+            message: 'The image will be resized.'
+          }],
+          place: {
+            href: 'http://storage/places/1',
+            photos: [{
+              href: 'http://bin.staticlocal.ch/123',
+              width: 10,
+              height: 10
+            }]
+          }
+        }.to_json
+      )
+    presence = Presence.options(params: { synchronize: false }).create(
+      place: { href: 'http://storage/places/1' }
+    )
+    expect(presence.warnings.any?).to eq true
+    expect(presence.place.warnings.any?).to eq true
+    expect(presence.place.photos.warnings.any?).to eq true
+    expect(presence.place.photos[0].warnings.any?).to eq true
+    expect(presence.place.photos[0].warnings.messages.first).to eq(
+      'The photos will be resized'
+    )
+  end
+end

data/spec/option_blocks/ensure_reset_between_requests_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe 'Option Blocks', type: :request do
+  let!(:first_request) do
+    stub_request(:get, "http://datastore/v2/records?request=first")
+      .to_return(status: 200)
+  end
+
+  let!(:second_request) do
+    stub_request(:get, "http://datastore/v2/records?request=second")
+      .to_return(status: 200)
+  end
+
+  it 'always ensures option blocks are always reset for new requests',
+  dummy_models: true, reset_before: true do
+    get '/option_blocks/first'
+    expect(first_request).to have_been_made.once
+    get '/option_blocks/second'
+    expect(second_request).to have_been_made.once
+  end
+end

data/spec/option_blocks/main_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::OptionBlocks do
+  let(:status) { 200 }
+
+  before do
+    class Record < LHS::Record
+      endpoint 'http://records'
+    end
+
+    stub_request(:get, 'http://records/?id=1234')
+      .with(headers: { 'Tracking-Id' => 1 })
+      .to_return(status: status)
+  end
+
+  it 'allows to apply options to all requests made within a certain block' do
+    LHS.options(headers: { 'Tracking-Id': 1 }) do
+      Record.find(1234)
+    end
+  end
+
+  it 'ensures that option blocks are reset after the block has been executed' do
+    expect(LHS::OptionBlocks::CurrentOptionBlock.options).to eq nil
+    LHS.options(headers: { 'Tracking-Id': 1 }) do
+      Record.find(1234)
+    end
+    expect(LHS::OptionBlocks::CurrentOptionBlock.options).to eq nil
+  end
+
+  context 'failing request' do
+    let(:status) { 400 }
+
+    it 'ensures that option blocks are reset when an exception occures in the block' do
+      expect(LHS::OptionBlocks::CurrentOptionBlock.options).to eq nil
+      LHS.options(headers: { 'Tracking-Id': 1 }) do
+        begin
+          Record.find(1234)
+        rescue LHC::Error
+        end
+      end
+      expect(LHS::OptionBlocks::CurrentOptionBlock.options).to eq nil
+    end
+  end
+
+  context 'parallel requests' do
+
+    it 'does not fail merging option blocks for parallel requests' do
+      LHS.options(headers: { 'Tracking-Id': 1 }) do
+        Record.find(1234, 1234)
+      end
+    end
+  end
+end

data/spec/pagination/link/current_page_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  let(:data_hash) do
+    { items: 98.times.map { { foo: 'bar' } }, limit: 10, next: { href: 'http://example.com/users?from_user_id=100&limit=100' } }
+  end
+
+  let(:data) do
+    LHS::Data.new(data_hash, nil, Record)
+  end
+
+  let(:pagination) { LHS::Pagination::Link.new(data) }
+
+  it 'responds to parallel?' do
+    expect(pagination.current_page).to be nil
+  end
+end

data/spec/pagination/link/pages_left_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  let(:next_parameter) do
+    { next: { href: 'http://example.com/users?from_user_id=100&limit=100' } }
+  end
+  let(:data_hash) { { items: 98.times.map { { foo: 'bar' } }, limit: 10 }.merge(next_parameter) }
+
+  let(:data) do
+    LHS::Data.new(data_hash, nil, Record)
+  end
+
+  let(:pagination) { LHS::Pagination::Link.new(data) }
+
+  it 'responds to pages_left' do
+    expect(pagination.pages_left).to eq(1)
+  end
+
+  it 'responds to pages_left?' do
+    expect(pagination.pages_left?).to be true
+  end
+
+  context 'when there is no next' do
+    let(:next_parameter) { {} }
+
+    it 'responds to pages_left' do
+      expect(pagination.pages_left).to eq(0)
+    end
+
+    it 'responds to pages_left?' do
+      expect(pagination.pages_left?).to be false
+    end
+  end
+end

data/spec/pagination/link/parallel_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe LHS::Record do
+  let(:data_hash) do
+    { items: 98.times.map { { foo: 'bar' } }, limit: 10, next: { href: 'http://example.com/users?from_user_id=100&limit=100' } }
+  end
+
+  let(:data) do
+    LHS::Data.new(data_hash, nil, Record)
+  end
+
+  let(:pagination) { LHS::Pagination::Link.new(data) }
+
+  it 'responds to parallel?' do
+    expect(pagination.parallel?).to be false
+  end
+end

data/spec/pagination/link/total_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+require 'webrick'
+
+describe LHS::Record do
+
+  before do
+    class User < LHS::Record
+      endpoint 'http://example.com/users'
+      configuration(
+        limit_key: 'limit',
+        items_key: 'items',
+        pagination_strategy: 'link'
+      )
+    end
+  end
+
+  context 'explicit pagination parameters for retrieving pages' do
+    it 'uses explicit parameters when retrieving pages' do
+      stub_request(:get, "http://example.com/users?limit=100")
+        .to_return(body: {
+          items: 100.times.map { |_| { name: WEBrick::Utils.random_string(10) } },
+          limit: 100,
+          next: { href: 'http://example.com/users?from_user_id=100&limit=100' }
+        }.to_json)
+
+      stub_request(:get, 'http://example.com/users?from_user_id=100&limit=100')
+        .to_return(body: {
+          items: 3.times.map { |_| { name: WEBrick::Utils.random_string(10) } },
+          limit: 100,
+          next: { href: 'http://example.com/users?from_user_id=200&limit=100' }
+        }.to_json)
+
+      stub_request(:get, 'http://example.com/users?from_user_id=200&limit=100')
+        .to_return(body: {
+          items: [],
+          limit: 100
+        }.to_json)
+
+      users = User.all.fetch
+      expect(users.total).to eq 103
+      expect(users.count).to eq 103
+    end
+  end
+end