praxis 2.0.pre.5 → 2.0.pre.6

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,34 @@
+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
+  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

data/spec/praxis/extensions/{field_selection/support → support}/spec_resources_active_model.rb

@@ -36,6 +36,7 @@ def create_tables
       create_table :active_taggings do |table|
         table.column :book_id, :integer
         table.column :tag_id, :integer
+        table.column :label, :string, null: true
       end
     end
   end
@@ -48,8 +49,12 @@ class ActiveBook < ActiveRecord::Base
 
   belongs_to :category, class_name: 'ActiveCategory', foreign_key: :category_uuid, primary_key: :uuid
   belongs_to :author, class_name: 'ActiveAuthor'
+
   has_many :taggings, class_name: 'ActiveTagging', foreign_key: :book_id
+  has_many :primary_taggings, lambda { where(label: 'primary')}, class_name: 'ActiveTagging', foreign_key: :book_id
+
   has_many :tags, class_name: 'ActiveTag', through: :taggings
+  has_many :primary_tags, class_name: 'ActiveTag', through: :primary_taggings, source: :tag
 end
 
 class ActiveAuthor < ActiveRecord::Base
@@ -64,6 +69,8 @@ end
 
 class ActiveTag < ActiveRecord::Base
   include Praxis::Mapper::ActiveModelCompat
+  has_many :taggings, class_name: 'ActiveTagging', foreign_key: :tag_id
+  has_many :books, class_name: 'ActiveBook', through: :taggings, source: :book
 end
 
 class ActiveTagging < ActiveRecord::Base
@@ -94,6 +101,26 @@ end
 class ActiveBookResource < ActiveBaseResource
   model ActiveBook
 
+  filters_mapping(
+    id: :id,
+    category_uuid: :category_uuid,
+    'fake_nested.name': 'simple_name',
+    'name': 'simple_name',
+    'name_is_not': lambda do |spec| # Silly way to use a proc, but good enough for testing
+      { name: :simple_name, value: spec[:value] , op: '!=' } # Can be an array for multiple conditions as well
+      end,
+    'author.id': 'author.id',
+    'author.name': 'author.name',
+    'taggings.label': 'taggings.label',
+    'taggings.tag_id': 'taggings.tag_id',
+    'taggings.tag.taggings.tag_id': 'taggings.tag.taggings.tag_id',
+    'tags.name': 'tags.name',
+    'primary_tags.name': 'primary_tags.name',
+    'category.name': 'category.name',
+    'category.books.name': 'category.books.simple_name',
+    'category.books.taggings.tag_id': 'category.books.taggings.tag_id',
+    'category.books.taggings.label': 'category.books.taggings.label',
+  )
   # Forces to add an extra column (added_column)...and yet another (author_id) that will serve
   # to check that if that's already automatically added due to an association, it won't interfere or duplicate
   property :author, dependencies: [:author, :added_column, :author_id]
@@ -108,23 +135,39 @@ def seed_data
   
   author1 = ActiveAuthor.create(  id: 11, name: 'author1' )
   author2 = ActiveAuthor.create(  id: 22, name: 'author2' )
+  author3 = ActiveAuthor.create(  id: 33, name: nil )
   
   tag_blue = ActiveTag.create(id: 1 , name: 'blue' )
   tag_red = ActiveTag.create(id: 2 , name: 'red' )
+  tag_green = ActiveTag.create(id: 3 , name: 'green' )
 
   book1 = ActiveBook.create( id: 1 , simple_name: 'Book1', category_uuid: 'deadbeef1')
   book1.author = author1
   book1.category = cat1
   book1.save
-  ActiveTagging.create(book: book1, tag: tag_blue)
+  ActiveTagging.create(book: book1, tag: tag_blue, label: 'primary')
   ActiveTagging.create(book: book1, tag: tag_red)
+  ActiveTagging.create(book: book1, tag: tag_green, label: 'primary')
   
 
   book2 = ActiveBook.create( id: 2 , simple_name: 'Book2', category_uuid: 'deadbeef1')
   book2.author = author2
   book2.category = cat2
   book2.save
-  ActiveTagging.create(book: book2, tag: tag_red)
+  ActiveTagging.create(book: book2, tag: tag_red, label: 'primary')
+
+  book3 = ActiveBook.create( id: 3 , simple_name: 'Book3', category_uuid: 'deadbeef1')
+  book3.author = author3
+  book3.save
+  ActiveTagging.create(book: book3, tag: tag_red, label: 'primary')
+
+  # More stuff
+
+  10.times do |i|
+    bid = 1000+i
+    ActiveBook.create( id: bid , simple_name: "Book#{bid}")
+  end
+
 end
 
 seed_data