praxis 2.0.pre.2 → 2.0.pre.3

data/spec/praxis/extensions/field_selection/support/spec_resources_sequel.rb

@@ -0,0 +1,106 @@
+require 'sequel'
+
+require 'praxis/mapper/sequel_compat'
+
+
+# Creates a new in-memory DB, and the necessary tables (and mini-seeds) for the sequel models in this file
+def create_and_seed_tables
+    sequeldb = Sequel.sqlite 
+    # sequeldb.loggers = [Logger.new($stdout)] # Uncomment to see sequel logs
+
+    sequeldb.create_table! :sequel_simple_models do
+      primary_key :id
+      String :simple_name
+      Integer :parent_id
+      String :parent_uuid
+      Integer :other_model_id
+      String :added_column
+  end
+    sequeldb.create_table! :sequel_other_models do
+      primary_key :id
+    end
+    sequeldb.create_table! :sequel_parent_models do
+      primary_key :id
+      String :uuid
+    end
+    sequeldb.create_table! :sequel_tag_models do
+      primary_key :id
+      String :tag_name
+    end
+    sequeldb.create_table! :sequel_simple_models_sequel_tag_models do
+      Integer :sequel_simple_model_id
+      Integer :tag_id
+    end
+
+    sequeldb[:sequel_parent_models] << { id: 1 , uuid: 'deadbeef1'}
+    sequeldb[:sequel_parent_models] << { id: 2 , uuid: 'deadbeef2'}
+    
+    sequeldb[:sequel_other_models] << { id: 11 }
+    sequeldb[:sequel_other_models] << { id: 22 }
+
+    sequeldb[:sequel_tag_models] << { id: 1 , tag_name: 'blue' }
+    sequeldb[:sequel_tag_models] << { id: 2 , tag_name: 'red' }
+
+    # Simple model 1 is tagged as blue and red
+    sequeldb[:sequel_simple_models_sequel_tag_models] << { sequel_simple_model_id: 1, tag_id: 1 }
+    sequeldb[:sequel_simple_models_sequel_tag_models] << { sequel_simple_model_id: 1, tag_id: 2 }
+    # Simple model 2 is tagged as red
+    sequeldb[:sequel_simple_models_sequel_tag_models] << { sequel_simple_model_id: 2, tag_id: 2 }
+
+    # It's weird to have a parent id and parent uuid (which points to different actual parents)
+    # But it allows us to check pointing to both PKs and not PK columns
+    sequeldb[:sequel_simple_models] << { id: 1 , simple_name: 'Simple1', parent_id: 1, other_model_id: 11, parent_uuid: 'deadbeef1'}
+    sequeldb[:sequel_simple_models] << { id: 2 , simple_name: 'Simple2', parent_id: 2, other_model_id: 22, parent_uuid: 'deadbeef1'}
+end
+
+create_and_seed_tables
+
+class SequelSimpleModel < Sequel::Model
+  include Praxis::Mapper::SequelCompat
+
+  many_to_one :parent, class: 'SequelParentModel'
+  many_to_one :other_model, class: 'SequelOtherModel'
+  many_to_many :tags, class: 'SequelTagModel'
+end
+
+class SequelOtherModel < Sequel::Model
+  include Praxis::Mapper::SequelCompat
+end
+
+class SequelParentModel < Sequel::Model
+  include Praxis::Mapper::SequelCompat
+  one_to_many :children, class: 'SequelSimpleModel', primary_key: :uuid, key: :parent_uuid
+end
+
+class SequelTagModel < Sequel::Model
+  include Praxis::Mapper::SequelCompat
+end
+
+
+# A set of resource classes for use in specs
+class SequelBaseResource < Praxis::Mapper::Resource
+end
+
+class SequelOtherResource < SequelBaseResource
+  model SequelOtherModel
+
+  property :display_name, dependencies: [:name]
+end
+
+class SequelParentResource < SequelBaseResource
+  model SequelParentModel
+end
+
+class SequelTagResource < SequelBaseResource
+  model SequelTagModel
+end
+
+class SequelSimpleResource < SequelBaseResource
+  model SequelSimpleModel
+
+  # Forces to add an extra column (added_column)...and yet another (parent_id) that will serve
+  # to check that if that's already automatically added due to an association, it won't interfere or duplicate
+  property :parent, dependencies: [:parent, :added_column, :parent_id]
+
+  property :name, dependencies: [:simple_name]
+end

data/spec/praxis/mapper/selector_generator_spec.rb

@@ -1,301 +1,293 @@
-# require 'spec_helper'
+require 'spec_helper'
 
-# describe Praxis::Mapper::SelectorGenerator do
-#   let(:properties) { {} }
-#   let(:resource) { BlogResource }
-#   subject(:generator) {Praxis::Mapper::SelectorGenerator.new }
 
-#   before do
-#     generator.add(resource,properties)
-#   end
+describe Praxis::Mapper::SelectorGenerator do
+  let(:resource) { SimpleResource }
+  subject(:generator) {described_class.new }
 
-#   let(:expected_selectors) { {} }
+  context '#add' do
+    let(:resource) { SimpleResource }
+    shared_examples 'a proper selector' do
+      it { expect(generator.add(resource, fields).dump).to be_deep_equal selectors }
+    end
+    
+    context 'basic combos' do
+      context 'direct column fields' do
+        let(:fields) { {id: true, foobar: true} }
+        let(:selectors) do 
+          {
+            model: SimpleModel,
+            columns: [:id, :foobar]
+          } 
+        end
+        it_behaves_like 'a proper selector'
+      end
 
-#   context 'for a simple field' do
-#     let(:properties) { {id: true} }
-#     let(:expected_selectors) do
-#       {
-#         BlogModel => {
-#           select: Set.new([:id]),
-#           track: Set.new()
-#         }
-#       }
-#     end
+      context 'aliased column fields' do
+        let(:fields) { {id: true, name: true} }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:id, :simple_name]
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
 
-#     it 'generates the correct set of selectors' do
-#       generator.selectors.should eq expected_selectors
-#     end
-#   end
+      context 'pure associations without recursion' do
+        let(:fields) { {other_model: true} }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:other_model_id], # FK of the other_model association
+            tracks: {
+              other_model: { 
+                columns: [:id], # joining key for the association
+                model: OtherModel 
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
 
-#   context 'for a simple property' do
-#     let(:properties) { {display_name: true} }
-#     let(:expected_selectors) do
-#       {
-#         BlogModel => {
-#           select: Set.new([:name]),
-#           track: Set.new()
-#         }
-#       }
-#     end
-#     it 'generates the correct set of selectors' do
-#       generator.selectors.should eq expected_selectors
-#     end
-#   end
+      context 'aliased associations without recursion' do
+        let(:fields) { {other_resource: true} }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:other_model_id], # FK of the other_model association
+            tracks: {
+              other_model: { 
+                columns: [:id], # joining key for the association
+                model: OtherModel 
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
+      context 'aliased associations without recursion (that map to columns and other associations)' do
+        let(:fields) { {aliased_method: true} }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:column1, :other_model_id], # other_model_id => because of the association
+            tracks: {
+              other_model: { 
+                columns: [:id], # joining key for the association
+                model: OtherModel 
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
 
-#   context 'for an association' do
-#     let(:properties) { {owner: true} }
-#     let(:expected_selectors) do
-#       {
-#         BlogModel => {
-#           select: Set.new([:owner_id]),
-#           track: Set.new([:owner])
-#         }
-#       }
-#     end
-#     it 'generates the correct set of selectors' do
-#       generator.selectors.should eq expected_selectors
-#     end
+      context 'redefined associations that add some extra columns (would need both the underlying association AND the columns in place)' do
+        let(:fields) { {parent: true} }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:parent_id, :added_column],
+            tracks: {
+              parent: { 
+                columns: [:id],
+                model: ParentModel
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
 
-#     context 'that is many_to_many' do
-#       let(:properties) { {commented_posts: true} }
-#       let(:resource) { UserResource }
-#       let(:expected_selectors) do
-#         {
-#           CommentModel => {
-#             select: Set.new([:author_id, :post_id]),
-#             track: Set.new([:post])
-#           },
-#           UserModel => {
-#             select: Set.new([]),
-#             track: Set.new([:comments])
-#           }
-#         }
-#       end
-#       it 'generates the correct set of selectors' do
-#         generator.selectors.should eq expected_selectors
-#       end
-#     end
+      context 'a simple property that requires all fields' do
+        let(:fields) { {everything: true} }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:*],
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
 
-#     context 'that is many_to_many without a :through option' do
-#       let(:properties) { {other_commented_posts: { id: true} } }
-#       let(:resource) { UserResource }
-#       let(:expected_selectors) do
-#         {
-#           PostModel => {
-#             select: Set.new([:id]),
-#             track: Set.new([])
-#           },
-#           UserModel => {
-#             select: Set.new([]),
-#             track: Set.new([:other_commented_posts])
-#           }
-#         }
-#       end
-#       it 'generates the correct set of selectors' do
-#         generator.selectors.should eq expected_selectors
-#       end
-#     end
+      context 'a simple property that requires itself' do
+        let(:fields) { {circular_dep: true} }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:circular_dep, :column1], #allows to "expand" the dependency into itself + others
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
 
+      context 'a simple property without dependencies' do
+        let(:fields) { {no_deps: true} }
+        let(:selectors) do
+          {
+            model: SimpleModel
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
 
-#     context 'that uses a composite key' do
-#       let(:properties) { {composite_model: {id: true, type: true} } }
-#       let(:resource) { OtherResource }
-#       let(:expected_selectors) do
-#         {
-#           OtherModel => {
-#             select: Set.new([:composite_id,:composite_type]),
-#             track: Set.new([:composite_model])
-#           },
-#           CompositeIdModel => {
-#             select: Set.new([:id,:type]),
-#             track: Set.new
-#           }
-#         }
-#       end
-#       it 'generates the correct set of selectors' do
-#         generator.selectors.should eq expected_selectors
-#       end
-#     end
-#   end
+    end
 
-#   context 'for a property that specifies a field from an association' do
-#     let(:properties) { {owner_email: true} }
-#     let(:expected_selectors) do
-#       {
-#         BlogModel => {
-#           select: Set.new([:owner_id]),
-#           track: Set.new([:owner])
-#         },
-#         UserModel => {
-#           select: Set.new([:email]),
-#           track: Set.new()
-#         }
-#       }
-#     end
+    context 'nested tracking' do
+      context 'pure associations follow the nested fields' do
+        let(:fields) do
+          { 
+            other_model: {
+              id: true
+            }
+          }
+        end
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:other_model_id],
+            tracks: {
+              other_model: {
+                model: OtherModel,
+                columns: [:id]
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
 
-#     it 'generates the correct set of selectors' do
-#       generator.selectors.should eq expected_selectors
-#     end
-#   end
+      context 'Aliased resources disregard any nested fields...' do
+        let(:fields) do
+          {
+            other_resource: {
+              id: true
+            }
+          }
+        end
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:other_model_id],
+            tracks: {
+              other_model: {
+                model: OtherModel,
+                columns: [:id]
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
+    end
 
-#   context 'for a simple property that requires all fields' do
-#     let(:properties) { {everything: true} }
-#     let(:expected_selectors) do
-#       {
-#         BlogModel => {
-#           select: true,
-#           track: Set.new()
-#         }
-#       }
-#     end
-#     it 'generates the correct set of selectors' do
-#       generator.selectors.should eq expected_selectors
-#     end
-#   end
+    context 'string associations' do
+      context 'that specify a direct existing colum in the target dependency' do
+        let(:fields) { { direct_other_name: true } }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:other_model_id],
+            tracks: {
+              other_model: {
+                model: OtherModel,
+                columns: [:id, :name]
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
 
-#   context 'for property that uses an associated property' do
-#     let(:properties) { {owner_full_name: true} }
-#     let(:expected_selectors) do
-#       {
-#         BlogModel => {
-#           select: Set.new([:owner_id]),
-#           track: Set.new([:owner])
-#         },
-#         UserModel => {
-#           select: Set.new([:first_name, :last_name]),
-#           track: Set.new()
-#         }
-#       }
-#     end
-#     it 'generates the correct set of selectors' do
-#       generator.selectors.should eq expected_selectors
-#     end
-#   end
+      context 'that specify an aliased property in the target dependency' do
+        let(:fields) { { aliased_other_name: true } }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:other_model_id],
+            tracks: {
+              other_model: {
+                model: OtherModel,
+                columns: [:id, :name]
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
 
+      context 'for a property that requires all fields from an association' do
+        let(:fields) { {everything_from_parent: true} }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:parent_id],
+            tracks: {
+              parent: { 
+                model: ParentModel,
+                columns: [:*]
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
+    end
 
-#   context 'for a property that requires all fields from an association' do
-#     let(:properties) { {everything_from_owner: true} }
-#     let(:expected_selectors) do
-#       {
-#         BlogModel => {
-#           select: Set.new([:owner_id]),
-#           track: Set.new([:owner])
-#         },
-#         UserModel => {
-#           select: true,
-#           track: Set.new()
-#         }
-#       }
-#     end
-#     it 'generates the correct set of selectors' do
-#       generator.selectors.should eq expected_selectors
-#     end
-#   end
+    context 'required extra select fields due to associations' do
+      context 'many_to_one' do
+        let(:fields) { {other_model: true} }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:other_model_id], # FK of the other_model association
+            tracks: {
+              other_model: { 
+                columns: [:id],
+                model: OtherModel 
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
+      context 'one_to_many' do
+        let(:resource) { ParentResource }
+        let(:fields) { {simple_children: true} }
+        let(:selectors) do
+          {
+            model: ParentModel,
+            columns: [:id], # No FKs in the source model for one_to_many
+            tracks: {
+              simple_children: { 
+                columns: [:parent_id],
+                model: SimpleModel 
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end      
+      context 'many_to_many' do
+        let(:resource) { OtherResource }
+        let(:fields) { {simple_models: true} }
+        let(:selectors) do
+          {
+            model: OtherModel,
+            columns: [:id], #join key in the source model for many_to_many (where the middle table points to)
+            tracks: {
+              simple_models: { 
+                columns: [:id], #join key in the target model for many_to_many (where the middle table points to)
+                model: SimpleModel
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end      
 
-#   context 'using a property that specifies a :through option' do
-#     let(:properties) { {recent_posts: {author: {full_name: true}}} }
-#     let(:resource) { UserResource }
-#     let(:expected_selectors) do
-#       {
-#         PostModel => {
-#           select: Set.new([:author_id, :created_at]),
-#           track: Set.new([:author])
-#         },
-#         UserModel => {
-#           select: Set.new([:first_name, :last_name]),
-#           track: Set.new([:posts])
-#         }
-#       }
-#     end
-#     it 'generates the correct set of selectors' do
-#       generator.selectors.should eq expected_selectors
-#     end
-#   end
-
-#   context 'with a property with a circular definition (ie, includes its own field)' do
-#     let(:resource) { PostResource }
-
-#     let(:properties) { {id: true, slug: true} }
-#     let(:expected_selectors) do
-#       {
-#         PostModel => {
-#           select: Set.new([:id, :slug, :title]),
-#           track: Set.new
-#         }
-#       }
-#     end
-#     it 'generates the correct set of selectors' do
-#       generator.selectors.should eq expected_selectors
-#     end
-#   end
-
-#   context 'with a property without the :through option' do
-#     let(:resource) { UserResource }
-#     let(:properties) { {blogs_summary: {size: true}} }
-#     let(:expected_selectors) do
-#      {
-#        BlogModel => {
-#          select: Set.new([:owner_id]),
-#          track: Set.new()
-#        },
-#        UserModel => {
-#          select: Set.new([:id]),
-#          track: Set.new([:blogs])
-#        }
-#      }
-#     end
-#     it 'ignores any subsequent fields when generating selectors' do
-#       generator.selectors.should eq expected_selectors
-#     end
-#   end
-
-#   context 'for a property with no dependencies' do
-#     let(:properties) { {id: true, kind: true} }
-#     let(:expected_selectors) do
-#       {
-#         BlogModel => {
-#           select: Set.new([:id]),
-#           track: Set.new()
-#         }
-#       }
-#     end
-#     it 'generates the correct set of selectors' do
-#       generator.selectors.should eq expected_selectors
-#     end
-#   end
-
-#   context 'with large set of properties' do
-
-#     let(:properties) do
-#       {
-#         display_name: true,
-#         owner: {
-#           id: true,
-#           full_name: true,
-#           blogs_summary: {href: true, size: true},
-#           main_blog: {id: true},
-#         },
-#         administrator: {id: true, full_name: true}
-#       }
-#     end
-
-#     let(:expected_selectors) do
-#       {
-#         BlogModel=> {
-#           select: Set.new([:id, :name, :owner_id, :administrator_id]),
-#           track: Set.new([:owner, :administrator])
-#         },
-#         UserModel=> {
-#           select: Set.new([:id, :first_name, :last_name, :main_blog_id]),
-#           track: Set.new([:blogs, :main_blog])
-#         }
-#       }
-#     end
-
-#     it 'generates the correct set of selectors' do
-#       generator.selectors.should eq(expected_selectors)
-#     end
-
-#   end
-
-# end
+    end
+  end
+end