praxis 2.0.pre.4 → 2.0.pre.9

data/spec/praxis/extensions/attribute_filtering/filter_tree_node_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+require 'praxis/extensions/attribute_filtering'
+
+describe Praxis::Extensions::AttributeFiltering::FilterTreeNode do
+
+  let(:filters) do
+    [
+      {name: 'one', specs: { op: '>', value: 1}},
+      {name: 'one', specs: { op: '<', value: 10}},
+      {name: 'rel1.a1', specs: { op: '=', value: 1}},
+      {name: 'rel1.a2', specs: { op: '=', value: 2}},
+      {name: 'rel1.rel2.b1', specs: { op: '=', value: 11}},
+      {name: 'rel1.rel2.b2', specs: { op: '=', value: 12}}
+    ]
+  end
+  context 'initialization' do
+    subject { described_class.new(filters) }
+    it 'holds the top conditions and the child in a TreeNode' do
+      expect(subject.path).to eq([])
+      expect(subject.conditions.size).to eq(2)
+      expect(subject.children.keys).to eq(['rel1'])
+      expect(subject.children['rel1']).to be_kind_of(described_class)
+    end
+
+    it 'recursively holds the conditions and the children of their children in a TreeNode' do
+      rel1 = subject.children['rel1']
+      expect(rel1.path).to eq(['rel1'])
+      expect(rel1.conditions.size).to eq(2)
+      expect(rel1.children.keys).to eq(['rel2'])
+      expect(rel1.children['rel2']).to be_kind_of(described_class)
+
+      rel1rel2 = rel1.children['rel2']
+      expect(rel1rel2.path).to eq(['rel1','rel2'])
+      expect(rel1rel2.conditions.size).to eq(2)
+      expect(rel1rel2.children.keys).to be_empty
+    end
+  end
+end

data/spec/praxis/extensions/attribute_filtering/filtering_params_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+
+require 'praxis/extensions/attribute_filtering'
+
+describe Praxis::Extensions::AttributeFiltering::FilteringParams do
+
+  context '.load' do
+    subject { described_class.load(filters_string) }
+    context 'parses for operator' do
+      described_class::AVAILABLE_OPERATORS.each do |op|
+        it "#{op}" do
+          str = "thename#{op}thevalue"
+          parsed = [{ name: :thename, op: op, value: 'thevalue'}]
+          expect(described_class.load(str).parsed_array).to eq(parsed)
+        end
+      end
+    end
+    context 'with all operators at once' do
+      let(:filters_string) { 'one=1&two!=2&three>=3&four<=4&five<5&six>6&seven!&eight!!'}
+      it do
+        expect(subject.parsed_array).to eq([
+          { name: :one, op: '=', value: '1'},
+          { name: :two, op: '!=', value: '2'},
+          { name: :three, op: '>=', value: '3'},
+          { name: :four, op: '<=', value: '4'},
+          { name: :five, op: '<', value: '5'},
+          { name: :six, op: '>', value: '6'},
+          { name: :seven, op: '!', value: nil},
+          { name: :eight, op: '!!', value: nil},          
+        ])
+      end
+    end
+
+    context 'with an associated MediaType' do
+      let(:params_for_post_media_type) do
+        # Note wrap the filter_params (.for) type in an attribute (which then we discard), so it will 
+        # construct it propertly by applying the block. Seems easier than creating the type alone, and 
+        # then manually apply the block
+        Attributor::Attribute.new(described_class.for(Post)) do
+          filter 'id', using: ['=', '!=', '!']
+        end.type
+      end
+
+      context 'with a single value' do
+        let(:str) { 'id=1' }
+        it 'coerces its value to the associated mediatype attribute type' do
+          parsed = params_for_post_media_type.load(str).parsed_array
+          expect(parsed.first).to eq(:name=>:id, :op=>"=", :value=>1)
+          expect(Post.attributes[:id].type.valid_type?(parsed.first[:value])).to be_truthy
+        end
+      end
+
+      context 'with multimatch' do
+        let(:str) { 'id=1,2,3' }
+        it 'coerces ALL csv values to the associated mediatype attribute type' do
+          parsed = params_for_post_media_type.load(str).parsed_array
+          expect(parsed.first).to eq(:name=>:id, :op=>"=", :value=>[1, 2, 3])
+          parsed.first[:value].each do |val|
+            expect(Post.attributes[:id].type.valid_type?(val)).to be_truthy
+          end
+        end
+      end
+
+      context 'with a single value that is null' do
+        let(:str) { 'id!' }
+        it 'properly loads it as null' do
+          parsed = params_for_post_media_type.load(str).parsed_array
+          expect(parsed.first).to eq(:name=>:id, :op=>"!", :value=>nil)
+        end
+      end
+    end
+
+  end
+
+  context '.validate' do
+    let(:filtering_params_type) do
+      # Note wrap the filter_params (.for) type in an attribute (which then we discard), so it will 
+      # construct it propertly by applying the block. Seems easier than creating the type alone, and 
+      # then manually apply the block
+      Attributor::Attribute.new(described_class.for(Post)) do
+        filter 'id', using: ['=', '!=']
+        filter 'title', using: ['=', '!='], fuzzy: true
+        filter 'content', using: ['=', '!=']
+      end.type
+    end
+    let(:loaded_params) { filtering_params_type.load(filters_string) }
+    subject { loaded_params.validate(filters_string) }
+
+    context 'errors' do
+      context 'given attributes that do not exist in the type' do
+        let(:filters_string) { 'NotAnExistingAttribute=Foobar*'}
+        it 'raises an error' do
+          expect{subject}.to raise_error(/NotAnExistingAttribute.*does not exist/)
+        end
+      end
+
+      context 'given unallowed attributes' do
+        let(:filters_string) { 'href=Foobar*'}
+        it 'raises an error' do
+          expect(subject).to_not be_empty
+          matches_error = subject.any? {|err| err =~ /Filtering by href is not allowed/}
+          expect(matches_error).to be_truthy
+        end
+      end
+
+      context 'given unallowed operator' do
+        let(:filters_string) { 'title>Foobar*'}
+        it 'raises an error' do
+          expect(subject).to_not be_empty
+          expect(subject.first).to match(/Operator > not allowed for filter title/)
+        end
+      end
+    end
+    context 'fuzzy matches' do
+      context 'when allowed' do
+        context 'given a fuzzy string' do
+          let(:filters_string) { 'title=IAmAString*'}
+          it 'validates properly' do
+            expect(subject).to be_empty
+          end
+        end
+      end
+      context 'when NOT allowed' do
+        context 'given a fuzzy string' do
+          let(:filters_string) { 'content=IAmAString*'}
+          it 'errors out' do
+            expect(subject).to_not be_empty
+            expect(subject.first).to match(/Fuzzy matching for content is not allowed/)
+          end
+        end
+        context 'given a non-fuzzy string' do
+          let(:filters_string) { 'content=IAmAString'}
+          it 'validates properly' do
+            expect(subject).to be_empty
+          end
+        end
+      end
+    end
+  end
+end

data/spec/praxis/extensions/field_expansion_spec.rb

@@ -47,15 +47,10 @@ describe Praxis::Extensions::FieldExpansion do
 
       context 'and no fields provided' do
         it 'returns the fields for the default view' do
-          expect(expansion).to eq({id: true, name: true, links: [true]})
+          expect(expansion).to eq({id: true, name: true})
         end
 
-        context 'and a view' do
-          let(:view) { :link }
-          it 'expands the fields on the view' do
-            expect(expansion).to eq({id: true, name: true, href: true})
-          end
-        end
+        pending 'and a view'
       end
 
       context 'with a set of fields provided' do
@@ -65,15 +60,7 @@ describe Praxis::Extensions::FieldExpansion do
           expect(expansion).to eq expected
         end
 
-        context 'and a view' do
-          let(:view) { :link }
-          let(:fields) { 'id,href' }
-
-          it 'returns the subset of fields that exist for the view' do
-            expected = {id: true, href: true }
-            expect(expansion).to eq expected
-          end
-        end
+        pending 'and a view'
       end
     end
 
@@ -81,15 +68,10 @@ describe Praxis::Extensions::FieldExpansion do
       let(:test_attributes) { {view: true}  }
 
       it 'returns the fields for the default view' do
-        expect(expansion).to eq({id: true, name: true, links: [true]})
+        expect(expansion).to eq({id: true, name: true})
       end
 
-      context 'and a view' do
-        let(:view) { :link }
-        it 'expands the fields on the view' do
-          expect(expansion).to eq({id: true, name: true, href: true})
-        end
-      end
+      pending 'and a view'
     end
 
 
@@ -98,7 +80,7 @@ describe Praxis::Extensions::FieldExpansion do
       let(:fields){ nil }
       let(:view){ nil }
       it 'ignores incoming parameters and expands for the default view' do
-        expect(expansion).to eq({id: true, name: true, links: [true]})
+        expect(expansion).to eq({id: true, name: true})
       end
     end
   end

data/spec/praxis/extensions/field_selection/active_record_query_selector_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-require_relative 'support/spec_resources_active_model.rb'
+require_relative '../support/spec_resources_active_model.rb'
 
 describe Praxis::Extensions::FieldSelection::ActiveRecordQuerySelector do
   let(:selector_fields) do
@@ -30,8 +30,9 @@ describe Praxis::Extensions::FieldSelection::ActiveRecordQuerySelector do
     ]
   end
   let(:selector_node) { Praxis::Mapper::SelectorGenerator.new.add(ActiveBookResource,selector_fields)  }
+  let(:debug){ false }
 
-  subject(:selector) {described_class.new(query: query, selectors: selector_node) }
+  subject(:selector) {described_class.new(query: query, selectors: selector_node, debug: debug) }
   context '#generate with a mocked' do
     let(:query) { double("Query") }
     it 'calls the select columns for the top level, and includes the right association hashes' do      
@@ -49,12 +50,15 @@ describe Praxis::Extensions::FieldSelection::ActiveRecordQuerySelector do
       expect(subject).to_not receive(:explain_query)
       subject.generate
     end 
-    it 'calls the explain debug method if enabled' do
-      expect(query).to receive(:select).and_return(query)
-      expect(query).to receive(:includes).and_return(query)
-      expect(subject).to receive(:explain_query)
-      subject.generate(debug: true)      
-    end 
+    context 'when debug is enabled' do
+      let(:debug){ true }
+      it 'calls the explain method' do
+        expect(query).to receive(:select).and_return(query)
+        expect(query).to receive(:includes).and_return(query)
+        expect(subject).to receive(:explain_query)
+        subject.generate
+      end
+    end
   end
 
   context '#generate with a real AR model' do
@@ -79,14 +83,14 @@ describe Praxis::Extensions::FieldSelection::ActiveRecordQuerySelector do
       expect(includes_hash).to match(expected_includes)
       # Also, make AR do the actual query to make sure everything is wired up correctly
       result = final_query.to_a
-      expect(result.size).to be 2
+      expect(result.size).to be > 2 # We are using 2 but we've seeded more
       book1 = result[0]
       book2 = result[1]
       expect(book1.author.id).to eq 11
       expect(book1.author.books.size).to eq 1
       expect(book1.author.books.map(&:simple_name)).to eq(['Book1'])
       expect(book1.category.name).to eq 'cat1'
-      expect(book1.tags.map(&:name)).to match_array(['blue','red'])
+      expect(book1.tags.map(&:name)).to match_array(['blue','red','green'])
 
       expect(book2.author.id).to eq 22
       expect(book2.author.books.size).to eq 1
@@ -98,7 +102,7 @@ describe Praxis::Extensions::FieldSelection::ActiveRecordQuerySelector do
     it 'calls the explain debug method if enabled' do
       suppress_output do
         # Actually make it run all the way...but suppressing the output
-        subject.generate(debug: true)
+        subject.generate
       end
     end 
   end

data/spec/praxis/extensions/field_selection/sequel_query_selector_spec.rb

@@ -37,7 +37,7 @@ describe Praxis::Extensions::FieldSelection::SequelQuerySelector do
   # Pay the price for creating and connecting only in this spec instead in spec helper
   # this way all other specs do not need to be slower and it's a better TDD experience
 
-  require_relative 'support/spec_resources_sequel.rb'
+  require_relative '../support/spec_resources_sequel.rb'
   
   let(:selector_fields) do
     { 
@@ -65,9 +65,10 @@ describe Praxis::Extensions::FieldSelection::SequelQuerySelector do
   end
 
   let(:selector_node) { Praxis::Mapper::SelectorGenerator.new.add(SequelSimpleResource,selector_fields)  }
-  subject {described_class.new(query: query, selectors: selector_node) }
+  subject {described_class.new(query: query, selectors: selector_node, debug: debug) }
 
   context 'generate' do
+    let(:debug) { false }
     context 'using the real models and DB' do
       let(:query) { SequelSimpleModel }
 
@@ -109,7 +110,7 @@ describe Praxis::Extensions::FieldSelection::SequelQuerySelector do
       it 'calls the explain debug method if enabled' do
         suppress_output do
           # Actually make it run all the way...but suppressing the output
-          subject.generate(debug: true)
+          subject.generate
         end
       end 
     end

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

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+require_relative '../support/spec_resources_active_model.rb'
+require 'praxis/extensions/pagination'
+
+class Book < Praxis::MediaType
+  attributes do
+    attribute :id, Integer
+    attribute :simple_name, String
+    attribute :category_uuid, String
+  end
+end
+Book.finalize!
+BookPaginationParamsAttribute = Attributor::Attribute.new(Praxis::Types::PaginationParams.for(Book)) do
+  max_items 3
+  page_size 2
+  #   disallow :paging
+  default by: :id  
+end
+
+BookOrderingParamsAttribute = Attributor::Attribute.new(Praxis::Types::OrderingParams.for(Book)) do
+  enforce_for :all
+end
+
+describe Praxis::Extensions::Pagination::ActiveRecordPaginationHandler do
+  shared_examples 'sorts_the_same' do |op, expected|
+    let(:order_params) { BookOrderingParamsAttribute.load(op) }
+    it do
+      loaded_ids = subject.all.map(&:id)
+      expected_ids = expected.all.map(&:id)
+      expect(loaded_ids).to eq(expected_ids)
+    end
+  end
+
+  shared_examples 'paginates_the_same' do |par, expected|
+    let(:paginator_params) { BookPaginationParamsAttribute.load(par) }
+    it do
+      loaded_ids = subject.all.map(&:id)
+      expected_ids = expected.all.map(&:id)
+      expect(loaded_ids).to eq(expected_ids)
+    end
+  end
+
+  let(:query) { ActiveBook }
+  let(:table) { ActiveBook.table_name }
+  let(:paginator_params) { nil }
+  let(:order_params) { nil }
+  let(:pagination) do
+    Praxis::Extensions::Pagination::PaginationStruct.new(paginator_params, order_params)
+  end
+
+  
+  context '.paginate' do
+    subject {described_class.paginate(query, pagination) }
+    
+    context 'empty struct' do
+      let(:paginator_params) { nil }
+
+      it 'does not change the query with an empty struct' do
+        expect(subject).to be(query)
+      end
+    end
+
+    context 'page-based' do
+      it_behaves_like 'paginates_the_same', 'page=1,items=3',
+        ::ActiveBook.limit(3)
+      it_behaves_like 'paginates_the_same', 'page=2,items=3',
+        ::ActiveBook.offset(3).limit(3)
+    end
+
+    context 'page-based with defaults' do
+      it_behaves_like 'paginates_the_same', '',
+        ::ActiveBook.offset(0).limit(2)
+      it_behaves_like 'paginates_the_same', 'page=2',
+        ::ActiveBook.offset(2).limit(2)
+    end
+
+    context 'cursor-based' do
+      it_behaves_like 'paginates_the_same', 'by=id,items=3',
+        ::ActiveBook.limit(3).order(id: :asc)
+      it_behaves_like 'paginates_the_same', 'by=id,from=1000,items=3',
+        ::ActiveBook.where("id > 1000").limit(3).order(id: :asc)
+      it_behaves_like 'paginates_the_same', 'by=simple_name,from=Book1000,items=3',
+        ::ActiveBook.where("simple_name > 'Book1000'").limit(3).order(simple_name: :asc)
+    end
+
+    context 'cursor-based with defaults' do
+      it_behaves_like 'paginates_the_same', '',
+        ::ActiveBook.limit(2).order(id: :asc)
+      it_behaves_like 'paginates_the_same', 'by=id,from=1000',
+        ::ActiveBook.where("id > 1000").limit(2).order(id: :asc)
+    end
+
+    context 'including order' do
+      let(:order_params) { BookOrderingParamsAttribute.load(op_string) }
+
+      context 'when compatible with cursor' do
+        let(:op_string){ 'id'}
+        # Compatible cursor field
+        it_behaves_like 'paginates_the_same', 'by=id,items=3',
+          ::ActiveBook.limit(3).order(id: :asc)
+      end
+  
+      context 'when incompatible with cursor' do
+        let(:op_string){ 'id'}
+        let(:paginator_params) { BookPaginationParamsAttribute.load('by=simple_name,items=3') }
+        it do          
+          expect{subject.all}.to raise_error(described_class::PaginationException, /is incompatible with pagination/)
+        end
+      end
+    end
+  end
+
+  context '.order' do  
+    subject {described_class.order(query, pagination.order) }
+    
+    it 'does not change the query with an empty struct' do
+      expect(subject).to be(query)
+    end
+
+    it_behaves_like 'sorts_the_same', 'simple_name', 
+      ::ActiveBook.order(simple_name: :asc)
+    it_behaves_like 'sorts_the_same', '-simple_name', 
+      ::ActiveBook.order(simple_name: :desc)
+    it_behaves_like 'sorts_the_same', '-simple_name,id', 
+      ::ActiveBook.order(simple_name: :desc, id: :asc)        
+    it_behaves_like 'sorts_the_same', '-simple_name,-id', 
+      ::ActiveBook.order(simple_name: :desc, id: :desc)
+  end
+end