record_filter 0.9.12

data/spec/exception_spec.rb

@@ -0,0 +1,208 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe 'raising exceptions' do
+  before do
+    TestModel.extended_models.each { |model| model.last_find = {} }
+  end 
+
+  describe 'on missing associations' do
+    it 'should get AssociationNotFoundException' do
+      lambda {
+        Post.filter do
+          having(:something_that_does_not_exist) do
+            with(:something_bad)
+          end
+        end.inspect
+      }.should raise_error(RecordFilter::AssociationNotFoundException)
+    end
+  end
+
+  describe 'on missing columns' do
+    it 'should get ColumnNotFoundException for with' do
+      lambda {
+        Post.filter do
+          with(:this_is_not_there, 2)
+        end.inspect
+      }.should raise_error(RecordFilter::ColumnNotFoundException)
+    end
+
+    it 'should get ColumnNotFoundException for with.not' do
+      lambda {
+        Post.filter do
+          with(:this_is_not_there).not.equal_to(2)
+        end.inspect
+      }.should raise_error(RecordFilter::ColumnNotFoundException)
+    end
+
+    it 'should not get ColumnNotFoundException for order' do
+      lambda {
+        Post.filter do
+          order('this_is_not_there', :asc)
+        end.inspect
+      }.should_not raise_error(RecordFilter::ColumnNotFoundException)
+    end
+
+    it 'should not get ColumnNotFoundException for group_by' do
+      lambda {
+        Post.filter do
+          group_by(:this_is_not_there)
+        end.inspect
+      }.should_not raise_error(RecordFilter::ColumnNotFoundException)
+    end
+
+    it 'should get AssociationNotFoundException for orders on bad associations' do
+      lambda {
+        Post.filter do
+          order({ :this_is_not_there => :eh }, :asc)
+        end.inspect
+      }.should raise_error(RecordFilter::InvalidJoinException)
+    end
+
+    it 'should raise ColumnNotFoundException for explicit joins on bad column names for the right table' do
+      lambda {
+        Review.filter do
+          join(Feature, :join_type => :left) do
+            on(:reviewable_id => :ftrable_id)
+            on(:reviewable_type => :ftrable_type)
+            with(:priority, 5)
+          end
+        end.inspect
+      }.should raise_error(RecordFilter::ColumnNotFoundException)
+    end
+
+    it 'should raise ColumnNotFoundException for explicit joins on bad column names for the left table' do
+      lambda {
+        Review.filter do
+          join(Feature, :join_type => :inner) do
+            on(:rvwable_id => :featurable_id)
+            on(:rvwable_type => :featurable_type)
+            with(:priority, 5)
+          end
+        end.inspect
+      }.should raise_error(RecordFilter::ColumnNotFoundException)
+    end
+
+    it 'should raise ColumnNotFoundException for explicit joins on bad column names in conditions' do
+      lambda {
+        Review.filter do
+          join(Feature, :join_type => :inner) do
+            on(:reviewable_id).gt(12)
+          end
+        end.inspect
+      }.should raise_error(RecordFilter::ColumnNotFoundException)
+    end
+
+    it 'should raise an ArgumentError if an invalid join type is specified' do
+      lambda {
+        Review.filter do
+          join(Feature, :join_type => :crazy) do
+            on(:reviewable_type => :featurable_type)
+          end
+        end.inspect
+      }.should raise_error(ArgumentError)
+    end
+
+    it 'should raise an InvalidJoinException if no columns are specified for the join' do
+      lambda {
+        Review.filter do
+          join(Feature, :join_type => :inner)
+        end.inspect
+      }.should raise_error(RecordFilter::InvalidJoinException)
+    end
+  end
+
+  describe 'limiting methods within joins and conjunctions' do
+    it 'should not allow calls to limit within joins' do
+      lambda {
+        Post.filter do
+          having(:photo) do
+            limit 2
+          end
+        end
+      }.should raise_error(RecordFilter::InvalidFilterException)
+    end
+
+    it 'should not allow calls to group_by within joins' do
+      lambda {
+        Post.filter do
+          having(:photo) do
+            group_by(:id)
+          end
+        end
+      }.should raise_error(RecordFilter::InvalidFilterException)
+    end
+
+    it 'should not allow calls to order within joins' do
+      lambda {
+        Post.filter do
+          having(:photo) do
+            order :id
+          end
+        end
+      }.should raise_error(RecordFilter::InvalidFilterException)
+    end
+
+    it 'should not allow calls to limit within conjunctions' do
+      lambda {
+        Post.filter do
+          all_of do
+            limit 2
+          end
+        end
+      }.should raise_error(RecordFilter::InvalidFilterException)
+    end
+
+    it 'should not allow calls to order within joins' do
+      lambda {
+        Post.filter do
+          all_of do
+            order :id
+          end
+        end
+      }.should raise_error(RecordFilter::InvalidFilterException)
+    end
+  end
+
+  describe 'limiting calls to on' do
+    it 'should not allow calls to on in the outer scope' do
+      lambda  {
+        Post.filter do
+          on(:a => :b)
+        end
+      }.should raise_error(RecordFilter::InvalidFilterException)
+    end
+  end
+
+  describe 'calling order with an invalid direction' do
+    it 'should raise an InvalidFilterException' do
+      lambda {
+        Post.filter do
+          order(:id, :oops)
+        end
+      }.should raise_error(RecordFilter::InvalidFilterException)
+    end
+  end
+
+  describe 'calling named filters within filters' do
+    it 'should raise an excpetion if the named filter does not exist' do
+      lambda {
+        Post.filter do
+          having(:comments).does_not_exist
+        end
+      }.should raise_error(RecordFilter::NamedFilterNotFoundException)
+    end
+  end
+
+  describe 'creating named filters with the same name as an existing one' do
+    it 'should raise an InvalidFilterNameException' do
+      Post.named_filter(:original) do
+        with(:permalink, 'abc')
+      end
+      lambda {
+        Post.named_filter(:original) do
+          with(:permalink, 'def')
+        end
+      }.should raise_error(RecordFilter::InvalidFilterNameException)
+    end
+  end
+end

data/spec/explicit_join_spec.rb

@@ -0,0 +1,132 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe 'explicit joins' do
+  before do
+    TestModel.extended_models.each { |model| model.last_find = {} }
+  end
+
+  describe 'specifying a simple join' do
+    before do
+      Post.filter do
+        join(Blog, :join_type => :left, :alias => :posts_blogs) do
+          on(:blog_id => :id)
+          with(:name, 'Test Name')
+        end
+      end.inspect
+    end
+
+    it 'should add correct join' do
+      Post.last_find[:joins].should == [%q(LEFT OUTER JOIN "blogs" AS posts_blogs ON "posts".blog_id = posts_blogs.id)]
+    end
+
+    it 'should query against condition on join table' do
+      Post.last_find[:conditions].should == ['posts_blogs.name = ?', 'Test Name']
+    end
+  end
+
+  describe 'specifying a complex join through polymorphic associations' do
+    before do
+      Review.filter do
+        join(Feature, :join_type => :left, :alias => :reviews_features) do
+          on(:reviewable_id => :featurable_id)
+          on(:reviewable_type => :featurable_type)
+          with(:priority, 5)
+        end
+      end.inspect
+    end
+
+    it 'should add correct join' do
+      Review.last_find[:joins].should == [%q(LEFT OUTER JOIN "features" AS reviews_features ON "reviews".reviewable_id = reviews_features.featurable_id AND "reviews".reviewable_type = reviews_features.featurable_type)]
+    end
+
+    it 'should query against condition on join table' do
+      Review.last_find[:conditions].should == ['reviews_features.priority = ?', 5]
+    end
+  end
+
+  describe 'should use values as join parameters instead of columns if given' do
+    before do
+      Review.filter do
+        join(Feature, :join_type => :left) do
+          on(:reviewable_id => :featurable_id)
+          on(:reviewable_type => :featurable_type)
+          on(:featurable_type, 'SomeType')
+          with(:priority, 5)
+        end
+      end.inspect
+    end
+
+    it 'should add correct join' do
+      Review.last_find[:joins].should == [%q(LEFT OUTER JOIN "features" AS reviews__feature ON "reviews".reviewable_id = reviews__feature.featurable_id AND "reviews".reviewable_type = reviews__feature.featurable_type AND (reviews__feature.featurable_type = 'SomeType'))]
+    end
+  end
+
+  describe 'using restrictions on join conditions' do
+    before do
+      Review.filter do
+        join(Feature, :join_type => :left) do
+          on(:featurable_type, nil)
+          on(:featurable_id).gte(12)
+          on(:priority).not(6)
+        end
+      end.inspect
+    end
+
+    it 'should add the correct join' do
+      Review.last_find[:joins].should == [%q(LEFT OUTER JOIN "features" AS reviews__feature ON (reviews__feature.featurable_type IS NULL) AND (reviews__feature.featurable_id >= 12) AND (reviews__feature.priority <> 6))]
+    end
+  end
+
+  describe 'using implicit and explicit joins together with conditions' do
+    before do
+      @blog = Class.new(Blog)
+      @blog.named_filter :somethings do
+        having(:ads) do
+          with(:content, nil)
+        end
+        join(Post, :join_type => :left) do
+          on(:id => :blog_id)
+          join(Comment, :join_type => :inner) do
+            on(:id => :post_id)
+            on(:offensive, true)
+          end
+        end
+        group_by(:id)
+      end
+      @blog.somethings.inspect
+    end
+
+    it 'should produce the correct conditions' do
+      @blog.last_find[:conditions].should == [%q((blogs__ads.content IS NULL))]
+    end
+
+    it 'should produce the correct join' do
+      @blog.last_find[:joins].should == [%q(INNER JOIN "ads" AS blogs__ads ON "blogs".id = blogs__ads.blog_id), %q(LEFT OUTER JOIN "posts" AS blogs__post ON "blogs".id = blogs__post.blog_id), %q(INNER JOIN "comments" AS blogs__post__comment ON blogs__post.id = blogs__post__comment.post_id AND (blogs__post__comment.offensive = 't'))]
+    end
+  end
+
+  describe 'using the same join multiple times' do
+    before do
+      @blog = Class.new(Blog)
+      @blog.named_filter(:things) do
+        join(Post, :join_type => :inner, :alias => 'blogs_posts_1') do
+          on(:id => :blog_id)
+          with(:title, 'ack')
+        end
+        join(Post, :join_type => :inner, :alias => 'blogs_posts_2') do
+          on(:id => :blog_id)
+          with(:title, 'hmm')
+        end
+      end
+      @blog.things.inspect
+    end
+
+    it 'should create the correct join' do
+      @blog.last_find[:joins].should == [%q(INNER JOIN "posts" AS blogs_posts_1 ON "blogs".id = blogs_posts_1.blog_id), %q(INNER JOIN "posts" AS blogs_posts_2 ON "blogs".id = blogs_posts_2.blog_id)] 
+    end
+
+    it 'should create the correct conditions' do
+      @blog.last_find[:conditions].should == [%q((blogs_posts_1.title = ?) AND (blogs_posts_2.title = ?)), 'ack', 'hmm'] 
+    end
+  end
+end