lhs 6.8.2 → 7.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f5393d4f50916acb89d04bb7aa7e5576c44d3663
-  data.tar.gz: ff323966be871eda309fef270baf401bb66c8b59
+  metadata.gz: aa6cec36b44adf1e4a4ec191be5ddadeade8df99
+  data.tar.gz: 504a4cbb77242734dc54a9545d8871325ff1467b
 SHA512:
-  metadata.gz: 80e80735fb752b92f5f4e3f3545148283a396a322e24f583ce3e1504d106b40b9b89c8b4dfccdac4c6ef3045df6e700a41342827005d3e6659009bb96467e12f
-  data.tar.gz: ff0c3bec571ca7772222b66cee22d652be6927a1c62083959487cb94be1a989024b8296919fd1ef859b96c82625c2a6175f85e97f37bfe3d46c084ea5c7a5f8b
+  metadata.gz: 2980127f21442628806801f96bf5cae65b7fd426a45639b739831e2f9cf06480c2f2fb0d4317b5d7604e6f68703d2306113371ca360be92bcc5ddc497301d90c
+  data.tar.gz: f61ba980791188f4bed6dd59c3f67c9334f77871fa60e5e97c3bba4b2142346ee3b8d799293ec348405cb85b4af8a53353943b932293da5b910512da14a0562f

data/README.md

@@ -538,11 +538,11 @@ or with parameters:
 
 In order to validate LHS::Records before persisting them, you can use the `valid?` (`validate` alias) method.
 
-The specific endpoint has to support validations with the `persist=false` parameter. The endpoint has to be enabled (opt-in) for validations in the service configuration.
+The specific endpoint has to support validations without peristance. An endpoint has to be enabled (opt-in) for validations in the service configuration.
 
 ```ruby
 class User < LHS::Record
-  endpoint ':service/v2/users', validates: true
+  endpoint ':service/v2/users', validates: { params: { persist: false } }
 end
 
 user = User.build(email: 'im not an email address')
@@ -551,12 +551,13 @@ unless user.valid?
 end
 ```
 
-In case endpoints define other parameter names for validation like `publish` you can configure those with passing a string to `validates`:
+The parameters passed to the `validates` endpoint option are used to perform the validation:
 
 ```ruby
-class User < LHS::Record
-  endpoint ':service/v2/users', validates: 'publish'
-end
+  endpoint ':service/v2/users', validates: { params: { persist: false } }  # will add ?persist=false to the request
+  endpoint ':service/v2/users', validates: { params: { publish: false } }  # will add ?publish=false to the request
+  endpoint ':service/v2/users', validates: { params: { validates: true } } # will add ?validates=true to the request
+  endpoint ':service/v2/users', validates: { path: 'validate' }            # will perform a validation via :service/v2/users/validate
 ```
 
 ## Custom validation errors

data/lib/lhs/concerns/item/validation.rb

@@ -8,32 +8,47 @@ class LHS::Item < LHS::Proxy
     def valid?(options = {})
       options ||= {}
       self.errors = nil
-      raise 'No validation endpoint found!' unless validation_endpoint
-      record = LHS::Record.for_url(validation_endpoint.url)
-      validation_params = validation_endpoint.options[:validates] == true ? { persist: false } : { validation_endpoint.options[:validates] => false }
-      params = validation_endpoint.options.fetch(:params, {})
-        .merge(params_from_embeded_href)
-        .merge(validation_params)
-      begin
-        record.request(
-          options.merge(
-            url: validation_endpoint.url,
-            method: :post,
-            params: params,
-            body: _data.to_json,
-            headers: { 'Content-Type' => 'application/json' }
-          )
-        )
-        true
-      rescue LHC::Error => e
-        self.errors = LHS::Errors.new(e.response)
-        false
-      end
+      endpoint = validation_endpoint
+      raise 'No endpoint found to perform validations! See here: https://github.com/local-ch/lhs#validation' unless endpoint
+      record = LHS::Record.for_url(endpoint.url)
+      params = merge_validation_params!(endpoint)
+      url = validation_url(endpoint)
+      run_validation!(record, options, url, params)
+      true
+    rescue LHC::Error => e
+      self.errors = LHS::Errors.new(e.response)
+      false
     end
     alias validate valid?
 
     private
 
+    def validation_url(endpoint)
+      url = endpoint.url
+      action = endpoint.options[:validates][:path].presence
+      url = "#{url}/#{action}" if action.present?
+      url
+    end
+
+    def merge_validation_params!(endpoint)
+      validates_params = endpoint.options[:validates].select { |key, _| key.to_sym != :path }
+      params = endpoint.options.fetch(:params, {}).merge(params_from_embeded_href)
+      params = params.merge(validates_params) if validates_params.is_a?(Hash)
+      params
+    end
+
+    def run_validation!(record, options, url, params)
+      record.request(
+        options.merge(
+          url: url,
+          method: :post,
+          params: params,
+          body: _data.to_json,
+          headers: { 'Content-Type' => 'application/json' }
+        )
+      )
+    end
+
     def validation_endpoint
       endpoint = embeded_endpoint if _data.href # take embeded first
       endpoint ||= _data._record.find_endpoint(_data._raw)

data/lib/lhs/concerns/record/endpoints.rb

@@ -17,6 +17,7 @@ class LHS::Record
         class_attribute :endpoints unless defined? endpoints
         self.endpoints ||= []
         self.endpoints = endpoints.clone
+        validates_deprecation_check!(options)
         endpoint = LHC::Endpoint.new(url, options)
         sanity_check(endpoint)
         endpoints.push(endpoint)
@@ -63,6 +64,14 @@ class LHS::Record
 
       private
 
+      def validates_deprecation_check!(options)
+        return unless options.present?
+        return unless options[:validates].present?
+        return if options[:validates].is_a?(Hash)
+        return if !options[:validates].is_a?(TrueClass) && options[:validates].match(%r{^\/})
+        raise 'Validates with either true or a simple string is deprecated! See here: https://github.com/local-ch/lhs#validation'
+      end
+
       # Finds the best endpoint.
       # The best endpoint is the one where all placeholders are interpolated.
       def find_best_endpoint(params)

data/lib/lhs/version.rb

@@ -1,3 +1,3 @@
 module LHS
-  VERSION = "6.8.2"
+  VERSION = "7.0.0"
 end

data/spec/item/validation_spec.rb

@@ -1,130 +1,113 @@
 require 'rails_helper'
 
 describe LHS::Item do
-  let(:datastore) { 'http://local.ch' }
-
-  let(:validation_parameter) { 'persist' }
-
-  let(:mock_validation) do
-    successful_validation
+  let(:user) do
+    User.build(email: 'steve@local.ch')
   end
 
-  let(:successful_validation) do
-    stub_request(:post, "#{datastore}/v2/users?#{validation_parameter}=false").to_return(body: '{}')
+  let(:record) do
+    Record.build(number: '123456')
   end
 
-  before(:each) do
-    mock_validation
+  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 'custom validation parameter' do
-    let(:validation_parameter) { 'publish' }
-
+  context 'passing validation parameters' do
     let(:user) do
       User.build(email: 'steve@local.ch')
     end
 
-    before(:each) do
-      LHC.config.placeholder('datastore', datastore)
+    it 'validates {publish: false}' do
       class User < LHS::Record
-        endpoint ':datastore/v2/users', validates: 'publish'
+        endpoint 'http://datastore/v2/users', validates: { params: { publish: false } }
       end
-    end
-
-    it 'validates' do
+      stub_request(:post, "http://datastore/v2/users?publish=false").to_return(body: {}.to_json)
       expect(user.valid?).to eq true
     end
-  end
 
-  context 'default parameter' do
-    before(:each) do
-      LHC.config.placeholder('datastore', datastore)
+    it 'validates {persist: false}' do
       class User < LHS::Record
-        endpoint ':datastore/v2/users', validates: true
+        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
 
-    let(:failing_validation) do
-      stub_request(:post, "#{datastore}/v2/users?persist=false")
-        .to_return(
-          status: 400,
-          body: {
-            field_errors: [{ code: "UNSUPPORTED_PROPERTY_VALUE", "path" => ["email"] }]
-          }.to_json
-        )
-    end
-
-    context 'valid data' do
-      let(:user) do
-        User.build(email: 'steve@local.ch')
-      end
-
-      it 'validates' do
-        expect(user.valid?).to eq true
-      end
-
-      it 'turns to be invalid if validating on changed, invalid data' do
-        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
+    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
 
-    context 'invalid data' do
-      let(:user) do
-        User.build(email: 'im not an email address')
-      end
-
-      let(:mock_validation) do
-        failing_validation
+    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
 
-      it 'does not validate and provides error messages' do
-        expect(user.valid?).to eq false
-        expect(user.errors[:email]).to be
-      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
 
-      it 'resets errors when revalidating' do
-        expect(user.valid?).to eq false
-        user.email = 'steve@local.ch'
-        successful_validation
-        expect(user.valid?).to eq true
-        expect(user.errors).to be_nil
+    before(:each) do
+      class User < LHS::Record
+        endpoint 'http://datastore/v2/users', validates: { params: { persist: false } }
       end
     end
 
-    context 'endpoint does not support validations' do
-      before(:each) do
-        class Favorite < LHS::Record
-          endpoint ':datastore/v2/favorites'
-        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
+    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
+    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).to be_nil
     end
   end
 
-  context 'pick right endpoint' do
+  context 'endpoint does not support validations' do
     before(:each) do
-      class Record < LHS::Record
-        endpoint 'http://datastore/v2/records'
-        endpoint 'http://datastore/v2/records/:id', validates: true
+      class Favorite < LHS::Record
+        endpoint ':datastore/v2/favorites'
       end
-      stub_request(:get, "http://datastore/v2/records/1")
-        .to_return(body: { href: 'http://datastore/v2/records/1' }.to_json)
-      stub_request(:post, "http://datastore/v2/records/1?persist=false")
-        .to_return(body: {}.to_json)
     end
 
-    it 'takes the right endpoint for validation' do
-      record = Record.find(1)
-      record.valid?
+    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
 end

data/spec/record/options_spec.rb

@@ -8,11 +8,11 @@ describe LHS::Record do
   before(:each) do
     LHC.config.placeholder('datastore', datastore)
     class Record < LHS::Record
-      endpoint ':datastore/records', validates: true
+      endpoint ':datastore/records', validates: { persist: false }
     end
   end
 
-  let(:options) { { auth: { bearer: '123' }, validates: true } }
+  let(:options) { { auth: { bearer: '123' }, validates: { persist: false } } }
   let(:params) { { name: 'Steve' } }
 
   context 'options' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lhs
 version: !ruby/object:Gem::Version
-  version: 6.8.2
+  version: 7.0.0
 platform: ruby
 authors:
 - https://github.com/local-ch/lhs/graphs/contributors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-10 00:00:00.000000000 Z
+date: 2016-11-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lhc