praxis 2.0.pre.33 → 2.0.pre.34

data/lib/praxis/handlers/xml_sample.rb

@@ -48,7 +48,7 @@ module Praxis
 
         case type
         when nil
-          if (node.children.size == 1 && node.child.text?) || node.children.size.zero?
+          if (node.children.size == 1 && node.child.text?) || node.children.empty?
             # leaf text node
             node.content
           else

data/lib/praxis/mapper/resource.rb

@@ -93,7 +93,7 @@ module Praxis
       # The `as:` can be used for properties that correspond to an underlying association of a different name. With this, the selector generator, is able to
       # follow and pass any incoming nested fields when necessary (as opposed to only add dependencies and discard nested fields)
       # No dependencies are allowed to be defined if `as:` is used (as the dependencies should be defined at the final aliased property)
-      def self.property(name, dependencies: nil, as: nil) # rubocop:disable Naming/MethodParameterName
+      def self.property(name, dependencies: nil, as: nil)
         raise "Error defining property '#{name}' in #{self}. Property names must be symbols, not strings." unless name.is_a? Symbol
 
         h = { dependencies: dependencies }

data/lib/praxis/mapper/selector_generator.rb

@@ -47,7 +47,7 @@ module Praxis
         end
 
         def dig(...)
-          @fields.dig(...) # rubocop:disable Style/SingleArgumentDig
+          @fields.dig(...)
         end
 
         def [](*path)

data/lib/praxis/multipart/parser.rb

@@ -168,7 +168,7 @@ module Praxis
         # Save the read body part.
         body << @buf.slice!(0, @buf.size - (@boundary_size + 4)) if head && (@boundary_size + 4 < @buf.size)
 
-        content = @io.read(@content_length && BUFSIZE >= @content_length ? @content_length : BUFSIZE)
+        content = @io.read(@content_length && @content_length <= BUFSIZE ? @content_length : BUFSIZE)
         raise EOFError, 'bad content body' if content.nil? || content.empty?
 
         @buf << content

data/lib/praxis/types/splattable_string_array.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Praxis
+  module Types
+    class SplattableStringArray < Attributor::Collection
+      # Make a type, to allow to load the value, as s single string, if it isn't a numerable
+      # This way we can do displayable: 'foobar' , or displayable: ['one', 'two']
+      def self.decode_string(value, _context)
+        Array(value)
+      end
+    end
+  end
+end

data/lib/praxis/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Praxis
-  VERSION = '2.0.pre.33'
+  VERSION = '2.0.pre.34'
 end

data/lib/praxis.rb

@@ -52,7 +52,6 @@ module Praxis
   autoload :BlueprintAttributeGroup, 'praxis/blueprint_attribute_group'
   autoload :FieldExpander, 'praxis/field_expander'
   autoload :Renderer, 'praxis/renderer'
-
   autoload :Notifications, 'praxis/notifications'
   autoload :MiddlewareApp, 'praxis/middleware_app'
 
@@ -67,6 +66,7 @@ module Praxis
     autoload :FuzzyHash, 'praxis/types/fuzzy_hash'
     autoload :MediaTypeCommon, 'praxis/types/media_type_common'
     autoload :MultipartArray, 'praxis/types/multipart_array'
+    autoload :SplattableStringArray, 'praxis/types/splattable_string_array'
   end
 
   autoload :MediaType, 'praxis/media_type'

data/praxis.gemspec

@@ -23,16 +23,16 @@ Gem::Specification.new do |spec|
   spec.executables << 'praxis'
 
   spec.add_dependency 'activesupport', '>= 3'
-  spec.add_dependency 'attributor', '>= 7.0'
+  spec.add_dependency 'attributor', '>= 7.1'
   spec.add_dependency 'mime', '~> 0'
   spec.add_dependency 'mustermann', '>=1.1'
   spec.add_dependency 'rack', '>= 1'
   spec.add_dependency 'terminal-table', '~> 1.4'
   spec.add_dependency 'thor'
 
+  spec.add_development_dependency 'appraisal'
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake', '>= 12.3.3'
-  spec.add_development_dependency "appraisal"
 
   if RUBY_PLATFORM !~ /java/
     spec.add_development_dependency 'pry'
@@ -42,7 +42,7 @@ Gem::Specification.new do |spec|
   else
     spec.add_development_dependency 'jdbc-sqlite3'
   end
-  spec.add_development_dependency 'coveralls'
+  spec.add_development_dependency 'coveralls_reborn', '~> 0.27.0'
   spec.add_development_dependency 'fuubar', '~> 2'
   spec.add_development_dependency 'guard', '~> 2'
   spec.add_development_dependency 'guard-bundler', '~> 2'

data/spec/functional_library_spec.rb

@@ -132,6 +132,38 @@ describe 'Functional specs for books with connected DB' do
           end
         end
       end
+
+      context 'with protected attributes' do
+        let(:fields_q) { 'id,special,multi' }
+        before do
+          expect(::Book.attributes[:special].options[:displayable]).to eq(['special#read'])
+          expect(::Book.attributes[:multi].options[:displayable]).to eq(['special#read', 'normal#read'])
+        end
+        context 'using the API' do
+          context 'when the user has the privilege for an attribute' do
+            before { allow(::BaseClass).to receive(:current_user_privs).and_return(['special#read']) }
+            it 'renders it' do
+              expect(parsed_response.keys).to include(:special)
+              expect(parsed_response.keys).to_not include(:multi)
+            end
+          end
+
+          context 'when the user does not have the privilege' do
+            before { allow(::BaseClass).to receive(:current_user_privs).and_return(['anotherpriv!']) }
+            it 'does not render it' do
+              expect(parsed_response.keys).to_not include(:special)
+              expect(parsed_response.keys).to_not include(:multi)
+            end
+          end
+
+          context 'when the user has multiple privilege for multiple attributes' do
+            before { allow(::BaseClass).to receive(:current_user_privs).and_return(['special#read', 'normal#read']) }
+            it 'renders both' do
+              expect(parsed_response.keys).to include(:special, :multi)
+            end
+          end
+        end
+      end
     end
   end
 
@@ -139,8 +171,9 @@ describe 'Functional specs for books with connected DB' do
     let(:filters_q) { '' }
     let(:fields_q) { '' }
     let(:order_q) { '' }
+    let(:pagination_q) { '' }
     subject do
-      get '/api/authors', api_version: '1.0', fields: fields_q, filters: filters_q, order: order_q
+      get '/api/authors', api_version: '1.0', fields: fields_q, filters: filters_q, order: order_q, pagination: pagination_q
     end
 
     context 'all authors' do
@@ -148,37 +181,67 @@ describe 'Functional specs for books with connected DB' do
       let(:base_query) do
         ActiveAuthor.joins(books: :author).where('active_books.simple_name LIKE ?', 'book%').where('authors_active_books.id > ?', 0)
       end
-      it 'is successful' do
-        expect(subject).to be_successful
-        expect(subject.headers['Content-Type']).to eq('application/vnd.acme.author; type=collection')
+      context 'using any filters/order/pagination attributes works, since they have been defined empty in the block definition' do
+        it 'is successful' do
+          expect(subject).to be_successful
+          expect(subject.headers['Content-Type']).to eq('application/vnd.acme.author; type=collection')
 
-        expect(parsed_response.size).to eq base_query.count
-      end
-      context 'ordering' do
-        context 'using direct attributes' do
-          let(:order_q) { '-name,id' }
-          it { expect(subject).to be_successful }
+          expect(parsed_response.size).to eq base_query.count
         end
-        context 'using nested attributes' do
-          let(:order_q) { '-name,books.name' }
-          it 'is successful' do
-            expect(subject).to be_successful
-            ids = base_query.order('active_authors.name DESC', 'active_books.simple_name DESC').pluck(:id)
-
-            expect(parsed_response.map { |book| book[:id] }).to eq ids
+        context 'ordering' do
+          context 'using direct attributes' do
+            let(:order_q) { '-name,id' }
+            it { expect(subject).to be_successful }
+          end
+          context 'using nested attributes' do
+            let(:order_q) { '-name,books.name' }
+            it 'is successful' do
+              expect(subject).to be_successful
+              ids = base_query.order('active_authors.name DESC', 'active_books.simple_name DESC').pluck(:id)
+
+              expect(parsed_response.map { |book| book[:id] }).to eq ids
+            end
           end
         end
-      end
-      context 'filtering and sorting' do
-        context 'using the same tables, including the base query one' do
-          let(:order_q) { '-name,books.name' }
-          let(:filters_q) { 'books.name!' }
-          let(:fields_q) { 'id,books{name}' }
-          it 'is successful' do
-            expect(subject).to be_successful
-            ids = base_query.order('active_authors.name DESC', 'active_books.simple_name DESC').pluck(:id)
-
-            expect(parsed_response.map { |book| book[:id] }).to eq ids
+        context 'filtering and sorting' do
+          context 'using the same tables, including the base query one' do
+            let(:order_q) { '-name,books.author.name' }
+            let(:filters_q) { 'books.name!' }
+            let(:fields_q) { 'id,books{name}' }
+            it 'is successful' do
+              expect(subject).to be_successful
+              ids = base_query.order('active_authors.name DESC', 'active_books.simple_name DESC').pluck(:id)
+
+              expect(parsed_response.map { |book| book[:id] }).to eq ids
+            end
+          end
+        end
+        context 'with page-based pagination' do
+          context 'using the same tables, including the base query one' do
+            let(:order_q) { '-name,books.author.name' }
+            let(:filters_q) { 'books.name!' }
+            let(:fields_q) { 'id,books{name}' }
+            let(:pagination_q) { 'page=1,items=2' }
+            it 'is successful' do
+              expect(subject).to be_successful
+              ids = base_query.order('active_authors.name DESC', 'active_books.simple_name DESC').limit(2).pluck(:id)
+
+              expect(parsed_response.map { |book| book[:id] }).to eq ids
+            end
+          end
+        end
+        context 'with cursor-based pagination' do
+          context 'using the same tables, including the base query one' do
+            let(:order_q) { '-name,books.author.name' }
+            let(:filters_q) { 'books.name!' }
+            let(:fields_q) { 'id,books{name}' }
+            let(:pagination_q) { 'by=name,items=2' }
+            it 'is successful' do
+              expect(subject).to be_successful
+              ids = base_query.order('active_authors.name DESC', 'active_books.simple_name DESC').limit(2).pluck(:id)
+
+              expect(parsed_response.map { |book| book[:id] }).to eq ids
+            end
           end
         end
       end

data/spec/praxis/application_spec.rb

@@ -98,11 +98,16 @@ describe Praxis::Application do
   end
 
   describe '#inspect' do
-    let(:klass) { Class.new(Praxis::Application) }
+    let(:klass) do
+      Class.new(Praxis::Application) do
+        def self.to_s
+          'SomeApplication'
+        end
+      end
+    end
     subject { klass.instance }
 
     it 'includes name, object ID and root' do
-      SomeApplication = klass # de-anonymize class name
       klass.instance.instance_variable_set(:@root, '/tmp')
       expect(subject.inspect).to match(%r{#<SomeApplication#[0-9]+ @root=/tmp>})
     end

data/spec/praxis/blueprint_spec.rb

@@ -21,7 +21,7 @@ describe Praxis::Blueprint do
     #          - Fail. Cannot determine type
     #   1.2) if it has a block
     #     1.2.1) with an reference with an attr with the same name
-    #          - We assume you're re/defining a new Struct (or Struct[]), and we will incorporate the reference type 
+    #          - We assume you're re/defining a new Struct (or Struct[]), and we will incorporate the reference type
     #           for the matching name in case you are indeed redefining a subset of the attributes, so you can enjoy inheritance
     #     1.2.2) without a ref (or the ref does not have same attribute name)
     #          - defaulted to Struct (if you meant Collection.of(Struct) things would fail later somehow)
@@ -33,20 +33,20 @@ describe Praxis::Blueprint do
     #   2.2) if it has a block
     #     - Same as above: use type and options provided, ignore ref if there is one (with or without matching attribute name).
 
-    let(:mytype) do 
+    let(:mytype) do
       Praxis::Blueprint.finalize!
-      Class.new(Praxis::Blueprint, &myblock).tap{|c| c._finalize!}
+      Class.new(Praxis::Blueprint, &myblock).tap(&:_finalize!)
     end
     context 'with no explicit type specified' do
       context 'without a block (if it is a leaf)' do
         context 'that has a reference with an attribute with the same name' do
-          let(:myblock) { 
-            Proc.new do
+          let(:myblock) do
+            proc do
               attributes reference: PersonBlueprint do
                 attribute :age, required: true, min: 42
               end
             end
-          }
+          end
           it 'uses type from reference' do
             expect(mytype.attributes).to have_key(:age)
             expect(mytype.attributes[:age].type).to eq(PersonBlueprint.attributes[:age].type)
@@ -57,42 +57,42 @@ describe Praxis::Blueprint do
           end
         end
         context 'with a reference, but that does not have a matching attribute name' do
-          let(:myblock) { 
-            Proc.new do
+          let(:myblock) do
+            proc do
               attributes reference: AddressBlueprint do
                 attribute :age
               end
             end
-          }
+          end
           it 'fails resolving' do
-            expect{mytype.attributes}.to raise_error(/Type for attribute with name: age could not be determined./)
+            expect { mytype.attributes }.to raise_error(/Type for attribute with name: age could not be determined./)
           end
         end
         context 'without a reference' do
-          let(:myblock) { 
-            Proc.new do
+          let(:myblock) do
+            proc do
               attributes do
                 attribute :age
               end
             end
-          }
+          end
           it 'fails resolving' do
-            expect{mytype.attributes}.to raise_error(/Type for attribute with name: age could not be determined./)
+            expect { mytype.attributes }.to raise_error(/Type for attribute with name: age could not be determined./)
           end
         end
       end
       context 'with block (if it is NOT a leaf)' do
         context 'that has a reference with an attribute with the same name' do
           context 'which is not a collection type' do
-            let(:myblock) { 
-              Proc.new do
+            let(:myblock) do
+              proc do
                 attributes reference: PersonBlueprint do
-                  attribute :age , description: 'I am fully redefining' do
+                  attribute :age, description: 'I am fully redefining' do
                     attribute :foobar, Integer, min: 42
                   end
                 end
               end
-            }
+            end
             it 'picks Struct, and makes sure to pass the reference of the attribute along' do
               expect(mytype.attributes).to have_key(:age)
               age_attribute = mytype.attributes[:age]
@@ -101,23 +101,23 @@ describe Praxis::Blueprint do
               # does NOT brings any ref options (except the right reference)
               expect(age_attribute.options).to include(description: 'I am fully redefining')
               # Yes, there is no way we can ever use an Integer when we're defining a Struct...but if the parent was a Struct, we would
-              expect(age_attribute.options).to include(reference: Attributor::Integer) 
+              expect(age_attribute.options).to include(reference: Attributor::Integer)
               # And the nested attribute is correctly resolved as well, and ensures options are there
               expect(age_attribute.type.attributes[:foobar].type).to eq(Attributor::Integer)
               expect(age_attribute.type.attributes[:foobar].options).to eq(min: 42)
             end
           end
           context 'which is a collection type' do
-            let(:myblock) { 
-              Proc.new do
+            let(:myblock) do
+              proc do
                 attributes reference: PersonBlueprint do
-                  attribute :prior_addresses , description: 'I am fully redefining' do
+                  attribute :prior_addresses, description: 'I am fully redefining' do
                     attribute :street, required: true
                     attribute :new_attribute, String, default: 'foo'
                   end
                 end
               end
-            }
+            end
             it 'picks Struct, and makes sure to pass the reference of the attribute along' do
               expect(mytype.attributes).to have_key(:prior_addresses)
               prior_addresses_attribute = mytype.attributes[:prior_addresses]
@@ -127,7 +127,7 @@ describe Praxis::Blueprint do
               # does NOT brings any ref options (except the right reference)
               expect(prior_addresses_attribute.options).to include(description: 'I am fully redefining')
               # Yes, there is no way we can ever use an Integer when we're defining a Struct...but if the parent was a Struct, we would
-              expect(prior_addresses_attribute.options).to include(reference: PersonBlueprint.attributes[:prior_addresses].type.member_type) 
+              expect(prior_addresses_attribute.options).to include(reference: PersonBlueprint.attributes[:prior_addresses].type.member_type)
               # And the nested attributes are correctly resolved as well, and ensures options are there
               street_options_from_ref = PersonBlueprint.attributes[:prior_addresses].type.member_type.attributes[:street].options
               expect(prior_addresses_attribute.type.member_type.attributes[:street].type).to eq(Attributor::String)
@@ -138,20 +138,20 @@ describe Praxis::Blueprint do
             end
           end
           context 'in the unlikely case that the reference type has an anonymous Struct (or collection of)' do
-            let(:myblock) { 
-              Proc.new do
+            let(:myblock) do
+              proc do
                 attributes reference: PersonBlueprint do
                   attribute :funny_attribute, description: 'Funny business' do
                     attribute :foobar, Integer, min: 42
                   end
                 end
               end
-            }
+            end
             it 'correctly inherits it (same result as defaulting to Struct) and brings in the reference' do
               expect(mytype.attributes).to have_key(:funny_attribute)
               # Resolves to Struct, and brings (and merges) the ref options with the attribute's
               expect(mytype.attributes[:funny_attribute].type).to be < Attributor::Struct
-              merged_options = {reference: PersonBlueprint.attributes[:funny_attribute].type}.merge(description: 'Funny business')
+              merged_options = { reference: PersonBlueprint.attributes[:funny_attribute].type }.merge(description: 'Funny business')
               expect(mytype.attributes[:funny_attribute].options).to include(merged_options)
               # And the nested attribute is correctly resolved as well, and ensures options are there
               expect(mytype.attributes[:funny_attribute].type.attributes[:foobar].type).to eq(Attributor::Integer)
@@ -160,21 +160,21 @@ describe Praxis::Blueprint do
           end
         end
         context 'with a reference, but that does not have a matching attribute name' do
-          let(:myblock) { 
-            Proc.new do
+          let(:myblock) do
+            proc do
               attributes reference: AddressBlueprint do
                 attribute :age, description: 'I am redefining' do
                   attribute :foobar, Integer, min: 42
                 end
               end
             end
-          }
+          end
           it 'correctly defaults to Struct uses only the local options (same exact as if it had no reference)' do
             expect(mytype.attributes).to have_key(:age)
             age_attribute = mytype.attributes[:age]
             # Resolves to Struct
             expect(age_attribute.type).to be < Attributor::Struct
-            # does NOT brings any ref options 
+            # does NOT brings any ref options
             expect(age_attribute.options).to  eq(description: 'I am redefining')
             # And the nested attribute is correctly resolved as well, and ensures options are there
             expect(age_attribute.type.attributes[:foobar].type).to eq(Attributor::Integer)
@@ -182,21 +182,21 @@ describe Praxis::Blueprint do
           end
         end
         context 'without a reference' do
-          let(:myblock) { 
-            Proc.new do
+          let(:myblock) do
+            proc do
               attributes do
                 attribute :age, description: 'I am redefining' do
                   attribute :foobar, Integer, min: 42
                 end
               end
             end
-          }
+          end
           it 'correctly defaults to Struct uses only the local options' do
             expect(mytype.attributes).to have_key(:age)
             age_attribute = mytype.attributes[:age]
             # Resolves to Struct
             expect(age_attribute.type).to be < Attributor::Struct
-            # does NOT brings any ref options 
+            # does NOT brings any ref options
             expect(age_attribute.options).to  eq(description: 'I am redefining')
             # And the nested attribute is correctly resolved as well, and ensures options are there
             expect(age_attribute.type.attributes[:foobar].type).to eq(Attributor::Integer)
@@ -207,43 +207,43 @@ describe Praxis::Blueprint do
     end
     context 'with an explicit type specified' do
       context 'without a reference' do
-        let(:myblock) { 
-          Proc.new do
+        let(:myblock) do
+          proc do
             attributes do
               attribute :age, String, description: 'I am a String now'
             end
           end
-        }
+        end
         it 'always uses the provided type and local options specified' do
           expect(mytype.attributes).to have_key(:age)
           age_attribute = mytype.attributes[:age]
           # Resolves to String
           expect(age_attribute.type).to eq(Attributor::String)
           # copies local options
-          expect(age_attribute.options).to  eq(description: 'I am a String now')
+          expect(age_attribute.options).to eq(description: 'I am a String now')
         end
       end
       context 'with a reference' do
-        let(:myblock) { 
-          Proc.new do
+        let(:myblock) do
+          proc do
             attributes reference: PersonBlueprint do
               attribute :age, String, description: 'I am a String now'
             end
           end
-        }
+        end
         it 'always uses the provided type and local options specified (same as if it had no reference)' do
           expect(mytype.attributes).to have_key(:age)
           age_attribute = mytype.attributes[:age]
           # Resolves to String
           expect(age_attribute.type).to eq(Attributor::String)
           # copies local options
-          expect(age_attribute.options).to  eq(description: 'I am a String now')
+          expect(age_attribute.options).to eq(description: 'I am a String now')
         end
       end
 
       context 'with a reference, which can further percolate down' do
-        let(:myblock) { 
-          Proc.new do
+        let(:myblock) do
+          proc do
             attributes reference: PersonBlueprint do
               attribute :age, String, description: 'I am a String now'
               attribute :address, Struct, description: 'Address subset' do
@@ -252,13 +252,13 @@ describe Praxis::Blueprint do
               attribute :tags
             end
           end
-        }
-        
+        end
+
         it 'brings the child reference for address so we can redefine it' do
-          expect(mytype.attributes.keys).to eq([:age, :address, :tags])
+          expect(mytype.attributes.keys).to eq(%i[age address tags])
           age_attribute = mytype.attributes[:age]
           expect(age_attribute.type).to eq(Attributor::String)
-          expect(age_attribute.options).to  eq(description: 'I am a String now')
+          expect(age_attribute.options).to eq(description: 'I am a String now')
 
           address_attribute = mytype.attributes[:address]
           expect(address_attribute.type).to be < Attributor::Struct
@@ -273,7 +273,7 @@ describe Praxis::Blueprint do
           expect(street_attribute.options).to include(required: true)
           # And brings in other options from the inherited street attribute
           expect(street_attribute.options).to include(description: 'The street')
-        
+
           # It also properly resolves the direct tags attribute from the reference, pointing to the same type
           tags_attribute = mytype.attributes[:tags]
           expect(tags_attribute.type).to eq PersonBlueprint.attributes[:tags].type
@@ -441,7 +441,7 @@ describe Praxis::Blueprint do
     end
 
     context 'with a valid nested blueprint' do
-      let(:hash) { { name: 'bob', myself: { name: 'PseudoBob'}} }
+      let(:hash) { { name: 'bob', myself: { name: 'PseudoBob' } } }
 
       it { should be_empty }
     end
@@ -454,14 +454,12 @@ describe Praxis::Blueprint do
     end
 
     context 'with an invalid nested blueprint' do
-      let(:hash) { { name: 'bob', myself: { name: 'PseudoBob', address: { state: 'ME' }}} }
+      let(:hash) { { name: 'bob', myself: { name: 'PseudoBob', address: { state: 'ME' } } } }
 
       it { should have(1).item }
       its(:first) { should =~ /Attribute \$.myself.address.state/ }
-
     end
 
-
     context 'for objects of the wrong type' do
       it 'raises an error' do
         expect do

data/spec/praxis/controller_spec.rb

@@ -23,6 +23,10 @@ describe Praxis::Controller do
       def index; end
 
       def show; end
+
+      def self.to_s
+        'SomeController'
+      end
     end
   end
 
@@ -34,7 +38,6 @@ describe Praxis::Controller do
 
   describe '#inspect' do
     it 'includes name, object ID and request' do
-      SomeController = subject # de-anonymize class name
       expect(subject.new('eioio').inspect).to match(
         /#<SomeController#[0-9]+ @request="eioio">/
       )

data/spec/praxis/extensions/field_expansion_spec.rb

@@ -35,8 +35,8 @@ describe Praxis::Extensions::FieldExpansion do
 
   let(:test_attributes) {}
   let(:test_params) { double('test_params', attributes: test_attributes) }
-
-  subject(:expansion) { test_instance.expanded_fields(request, media_type) }
+  let(:expansion_filter) { nil }
+  subject(:expansion) { test_instance.expanded_fields(request, media_type, expansion_filter) }
 
   context '#expanded_fields' do
     context 'with fields and view params defined' do

data/spec/praxis/extensions/pagination/ordering_params_spec.rb

@@ -62,8 +62,6 @@ describe Praxis::Extensions::Pagination::OrderingParams do
       it 'enforces only first components' do
         # It allows non-defined field in second position
         expect(order_attr.load('name,recent_posts.title').validate).to be_empty
-        # It does not allow non-defined field in first position
-        expect(order_attr.load('recent_posts.title,name').validate).to_not be_empty
       end
     end
   end