praxis 2.0.pre.3 → 2.0.pre.8

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

data/spec/praxis/mapper/selector_generator_spec.rb

@@ -181,6 +181,38 @@ describe Praxis::Mapper::SelectorGenerator do
         end
         it_behaves_like 'a proper selector'
       end
+
+      context 'merging multiple tracks with the same name within a node' do
+        let(:fields) do
+          { # Both everything_from_parent and parent will track the underlying 'parent' assoc
+            # ...and the final respective fields and tracks will need to be merged together.
+            # columns will be merged by just *, and tracks will merge true with simple children
+            everything_from_parent: true,
+            parent: {
+              simple_children: true
+            }
+          }
+        end
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:parent_id, :added_column],
+            tracks: {
+              parent: {
+                model: ParentModel,
+                columns: [:*],
+                tracks: {
+                  simple_children: {
+                    model: SimpleModel,
+                    columns: [:parent_id]
+                  }
+                }
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
     end
 
     context 'string associations' do

data/spec/praxis/media_type_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
 describe Praxis::MediaType do
-  let(:owner_resource) { instance_double(Person, id: 100, name: /[:name:]/.gen, href: '/', links: ['one','two']) }
-  let(:manager_resource) { instance_double(Person, id: 101, name: /[:name:]/.gen, href: '/', links: []) }
-  let(:custodian_resource) { instance_double(Person, id: 102, name: /[:name:]/.gen, href: '/', links: []) }
+  let(:owner_resource) { instance_double(Person, id: 100, name: /[:name:]/.gen, href: '/') }
+  let(:manager_resource) { instance_double(Person, id: 101, name: /[:name:]/.gen, href: '/') }
+  let(:custodian_resource) { instance_double(Person, id: 102, name: /[:name:]/.gen, href: '/') }
   let(:residents_summary_resource) do
     instance_double(Person::CollectionSummary, href: "/people", size: 2)
   end
@@ -27,15 +27,6 @@ describe Praxis::MediaType do
     its(:id)    { should eq(1) }
     its(:name)  { should eq('Home') }
     its(:owner) { should be_instance_of(Person) }
-
-    context 'links' do
-      it 'respects using' do
-        expect(address.links.super).to be_kind_of(Person)
-        expect(address.links.super.object).to be(resource.manager)
-        expect(address.links.caretaker.object).to be(resource.custodian)
-      end
-
-    end
   end
 
 
@@ -62,36 +53,6 @@ describe Praxis::MediaType do
 
     its(:description) { should be_kind_of(String) }
 
-    context 'links' do
-      context 'with a custom links attribute' do
-        subject(:person) { Person.new(owner_resource) }
-
-        its(:links)  { should be_kind_of(Array) }
-        its(:links)  { should eq(owner_resource.links) }
-      end
-
-      context 'using the links DSL' do
-        subject(:address) { Address.new(resource) }
-        its(:links)  { should be_kind_of(Address::Links) }
-
-        it 'inherits types appropriately' do
-          links_attribute = Address::Links.attributes
-          expect(links_attribute[:owner].type).to be(Person)
-          expect(links_attribute[:super].type).to be(Person)
-          expect(links_attribute[:caretaker].type).to be(Person)
-        end
-
-        context 'loading returned values' do
-          subject(:residents) { address.links.residents }
-          let(:residents_summary_resource) do
-            {href: "/people", size: 2}
-          end
-
-          its(:href) { should eq('/people') }
-          its(:size) { should eq(2) }
-        end
-      end
-    end
   end
 
   context "rendering" do
@@ -102,43 +63,8 @@ describe Praxis::MediaType do
     its([:owner]) { should eq(Person.dump(owner_resource, view: :default)) }
     its([:fields]) { should eq(address.fields.dump ) }
 
-    context 'links' do
-      subject(:links) { output[:links] }
-
-      its([:owner]) { should eq(Person.dump(owner_resource, view: :link)) }
-      its([:super]) { should eq(Person.dump(manager_resource, view: :link)) }
-
-      context 'for a collection summary' do
-        let(:volume) { Volume.example }
-        let(:snapshots_summary) { volume.snapshots_summary }
-        let(:output) { volume.render(view: :default) }
-        subject { links[:snapshots] }
-
-        its([:name]) { should eq(snapshots_summary.name) }
-        its([:size]) { should eq(snapshots_summary.size) }
-        its([:href]) { should eq(snapshots_summary.href) }
-      end
-    end
-
-
-  end
-
-  context '.example' do
-    subject(:example) { Address.example }
-
-    its('links.owner') { should be(example.owner) }
-    its('links.super') { should be(example.object.manager) }
-
-    it 'does not respond to non-top-level attributes from links' do
-      expect { example.super }.to raise_error(NoMethodError)
-    end
-
-    it 'responds to non-top-level attributes from links on its inner Struct' do
-      expect(example.links.super).to be(example.object.manager)
-    end
   end
 
-
   context 'describing' do
 
     subject(:described){ Address.describe }
@@ -161,10 +87,10 @@ describe Praxis::MediaType do
     its([:name]) { should eq(Address.name) }
     its([:identifier]) { should eq(Address.identifier.to_s) }
     it 'should include the defined views' do
-      expect( subject[:views].keys ).to match_array([:default, :master, :link])
+      expect( subject[:views].keys ).to match_array([:default, :master])
     end
     it 'should include the defined attributes' do
-      expect( subject[:attributes].keys ).to match_array([:id, :name, :owner, :custodian, :residents, :residents_summary, :links, :fields])
+      expect( subject[:attributes].keys ).to match_array([:id, :name, :owner, :custodian, :residents, :residents_summary, :fields])
     end
   end
 
@@ -182,56 +108,6 @@ describe Praxis::MediaType do
 
     subject(:output) { field_resolver.resolve(User,fields) }
 
-
-    it 'merges link stuff in properly' do
-      expect(output).to_not have_key(:links)
-      expect(output).to have_key(:primary_blog)
-
-      expect(output[:primary_blog]).to eq({href: true})
-    end
-
-    it 'resolves link aliases (from link ... using:)' do
-      expect(output).to have_key(:posts_summary)
-      expect(output[:posts_summary]).to eq({href: true})
-    end
-
-    context 'merging top-level attributes with those from links' do
-      let(:user_view) { User.views[:extended] }
-
-      subject(:primary_blog_output) { output[:primary_blog] }
-      it 'merges them' do
-        expected = {
-          href: true,
-          id: true,
-          name: true,
-          description: true
-        }
-        expect(primary_blog_output).to eq(expected)
-      end
-    end
-
-    context 'deep-merging fields' do
-      let(:fields) do
-        {
-          primary_blog: {
-            owner: { first: true, last: true }
-          },
-          links: {
-            primary_blog: {
-              owner: { href: true }
-            }
-          }
-        }
-      end
-
-      it 'does a deep-merge for sub-attributes' do
-        expected = {
-          owner: {first: true, last: true, href: true}
-        }
-        expect(output[:primary_blog]).to eq(expected)
-      end
-    end
-
     context 'resolving collections' do
       let(:fields) { {:id=>true, :posts=>[{:href=>true}]}}
       it 'strips arrays from the incoming fields' do