praxis 2.0.pre.1 → 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

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+require_relative '../support/spec_resources_active_model.rb'
+
+describe Praxis::Extensions::FieldSelection::ActiveRecordQuerySelector do
+  let(:selector_fields) do
+    { 
+      name: true,
+      author: {
+        id: true,
+        books: true
+      },
+      category: {
+        name: true,
+        books: true
+      },
+      tags: {
+        name: true
+      }
+    }
+  end
+  let(:expected_select_from_to_query) do
+    # The columns to select from the top Simple model
+    [
+      :simple_name, # from the :name alias
+      :author_id, # the FK needed for the author association
+      :added_column, # from the extra column defined in the parent property
+      :category_uuid, # the FK needed for the cateory association
+      :id # We always load the primary keys
+    ]
+  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, 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      
+      expect(query).to receive(:select).with(*expected_select_from_to_query).and_return(query)
+      expected_includes = {
+        author: {
+          books: {}
+        },
+        category: {
+          books: {}
+        },
+        tags: {}
+      }
+      expect(query).to receive(:includes).with(expected_includes).and_return(query)
+      expect(subject).to_not receive(:explain_query)
+      subject.generate
+    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
+    let(:query) { ActiveBook }
+
+    it 'calls the select columns for the top level, and includes the right association hashes' do
+      expected_includes = {
+        author: {
+          books: {}
+        },
+        category: {
+          books: {}
+        },
+        tags: {}
+      }
+      #expect(query).to receive(:includes).with(expected_includes).and_return(query)
+      expect(subject).to_not receive(:explain_query)
+      final_query = subject.generate
+      expect(final_query.select_values).to match_array(expected_select_from_to_query)
+      # Our query selector always uses a single hash tree from the top, not an array of things
+      includes_hash = final_query.includes_values.first
+      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 # 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','green'])
+
+      expect(book2.author.id).to eq 22
+      expect(book2.author.books.size).to eq 1
+      expect(book2.author.books.map(&:simple_name)).to eq(['Book2'])
+      expect(book2.category.name).to eq 'cat2'
+      expect(book2.tags.map(&:name)).to match_array(['red'])
+    end
+
+    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
+      end
+    end 
+  end
+
+end

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

@@ -0,0 +1,148 @@
+require 'spec_helper'
+require 'sequel'
+
+require 'praxis/extensions/field_selection/sequel_query_selector'
+
+
+describe Praxis::Extensions::FieldSelection::SequelQuerySelector do
+  class Q
+    attr_reader :object, :cols
+    def initialize
+      @object = {}
+      @cols = []
+    end
+    def eager(hash)
+      raise "we are only calling eager one at a time!" if hash.keys.size > 1
+      name = hash.keys.first
+      # Actually call the incoming proc with an instance of Q, to collect the further select/eager calls
+      @object[name] = hash[name].call(Q.new)
+      self
+    end
+    def select(*names)
+      @cols += names.map(&:column)
+      self
+    end
+    def dump
+      eagers = @object.each_with_object({}) do |(name, val), hash|
+        hash[name] = val.dump
+      end
+      {
+        columns: @cols,
+        eagers: eagers
+      }
+    end
+  end
+
+
+  # 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'
+  
+  let(:selector_fields) do
+    { 
+      name: true,
+      other_model: {
+        id: true
+      },
+      parent: {
+        children: true
+      },
+      tags: {
+        tag_name: true
+      }
+    }
+  end
+  let(:expected_select_from_to_query) do
+    # The columns to select from the top Simple model
+    [
+      :simple_name, # from the :name alias
+      :added_column, # from the extra column defined in the parent property
+      :id, # We always load the primary keys
+      :other_model_id, # the FK needed for the other_model association
+      :parent_id # the FK needed for the parent association
+    ]
+  end
+
+  let(:selector_node) { Praxis::Mapper::SelectorGenerator.new.add(SequelSimpleResource,selector_fields)  }
+  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 }
+
+      it 'calls the select columns for the top level, and includes the right association hashes' do      
+        ds = subject.generate
+        opts = ds.opts
+        # Top model is our simplemodel
+        expect(opts[:model]).to be(SequelSimpleModel)
+        selected_column_names = opts[:select].map(&:column)
+        expect(selected_column_names).to match_array(expected_select_from_to_query)
+        # 2 Eager loaded associations as well
+        expect(opts[:eager].keys).to match_array([:other_model, :parent, :tags])
+        # We can not introspect those eagers, as they are procs...but at least validate they are
+        expect(opts[:eager][:other_model]).to be_a Proc
+        expect(opts[:eager][:parent]).to be_a Proc
+        
+        # Also, let's make sure the query actually works by making Sequel attempt to retrieve it and finding the right things.
+        result = ds.all
+        # 2 simple models
+        expect(result.size).to be 2 
+        # First simple model points to other_model 11 and parent 1
+        simple_one = result.find{|i| i.id == 1}
+        expect(simple_one.other_model.id).to be 11
+        expect(simple_one.parent.id).to be 1
+        # also, its' parent in turn has 2 children (1 and 2) linked by its parent_uuid
+        expect(simple_one.parent.children.map(&:id)).to match_array([1,2])
+        # Has the blue and red tags
+        expect(simple_one.tags.map(&:tag_name)).to match_array(['blue','red'])
+
+        # second simple model points to other_model 22 and parent 2
+        simple_two = result.find{|i| i.id == 2}
+        expect(simple_two.other_model.id).to be 22
+        expect(simple_two.parent.id).to be 2
+        # also, its' parent in turn has no children (as no simple models point to it by uuid)
+        expect(simple_two.parent.children.map(&:id)).to be_empty
+        # Also has the red tag
+        expect(simple_two.tags.map(&:tag_name)).to match_array(['red'])
+      end
+      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
+        end
+      end 
+    end
+    context 'just mocking the query' do
+      let(:query) { Q.new }
+
+      it 'creates the right recursive lambdas for the eager loading' do      
+        
+        ds = subject.generate
+        result = ds.dump
+        expect(result[:columns]).to match_array(expected_select_from_to_query)
+        # 2 eager loads
+        expect(result[:eagers].keys).to match_array([:other_model, :parent, :tags])
+        # 1 - other model
+        other_model_eagers = result[:eagers][:other_model]
+        expect(other_model_eagers[:columns]).to match_array([:id])
+
+        # 2 - parent association
+        parent_eagers = result[:eagers][:parent]
+        expect(parent_eagers[:columns]).to match_array([:id,:uuid]) # uuid is necessary for the "children" assoc
+        expect(parent_eagers[:eagers].keys).to match_array([:children])
+        # 2.1 - children association off of the parent
+        parent_children_eagers = parent_eagers[:eagers][:children]
+        expect(parent_children_eagers[:columns]).to match_array([:id,:parent_uuid]) # parent_uuid is required for the assoc
+        expect(parent_children_eagers[:eagers]).to be_empty
+
+        # 3 - tags association
+        tags_eagers = result[:eagers][:tags]
+        expect(tags_eagers[:columns]).to match_array([:id, :tag_name]) # uuid is necessary for the "children" assoc
+        expect(tags_eagers[:eagers].keys).to be_empty
+        
+      end
+    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