restful_query-rails3 0.4

data/test/test_helper.rb

@@ -0,0 +1,35 @@
+require 'test/unit'
+require 'rubygems'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.expand_path(File.dirname(__FILE__)), '..'))
+require 'lib/restful_query'
+
+
+unless defined?(ActiveRecord)
+  module ActiveRecord
+    class Base
+      class << self
+        attr_accessor :pluralize_table_names
+
+        def protected_attributes
+          []
+        end
+
+        def named_scope(name, options = {})
+        end
+      end
+      self.pluralize_table_names = true
+
+      include RestfulQuery::CanQuery
+    end
+  end
+end
+
+class ClassWithQuery < ActiveRecord::Base
+  can_query
+end
+
+class ClassWithoutQuery < ActiveRecord::Base
+
+end

data/test/test_restful_query_can_query.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestRestfulQueryCanQuery < Test::Unit::TestCase
+
+  context "CanQuery" do
+    context "A class with the can_query macro" do
+      should "can_query?" do
+        assert ClassWithQuery.can_query?
+      end
+    end
+    
+    context "A class without the can_query macro" do
+      should "not can_query?" do
+        assert !ClassWithoutQuery.can_query?
+      end
+    end
+    
+  end
+
+end

data/test/test_restful_query_condition.rb

@@ -0,0 +1,184 @@
+require 'test_helper'
+
+class RestfulQueryConditionTest < Test::Unit::TestCase
+
+  context "Condition" do
+
+    context "initializing" do
+      context "with column, value, operator" do
+        setup do
+          @condition = RestfulQuery::Condition.new('created_at', '1 week ago', '>')
+        end
+
+        should "save column" do
+          assert_equal 'created_at', @condition.column
+        end
+
+        should "save value" do
+          assert_equal '1 week ago', @condition.value
+        end
+
+        should "save operator as string" do
+          assert_equal '>', @condition.operator
+        end
+
+      end
+
+      context "with no operator" do
+        setup do
+          @condition = RestfulQuery::Condition.new('created_at', '1 week ago')
+        end
+
+        should "assume =" do
+          assert_equal '=', @condition.operator
+        end
+
+      end
+
+      context "with an operator as a string" do
+        setup do
+          @condition = RestfulQuery::Condition.new('created_at', '1 week ago', 'gteq')
+        end
+
+        should "translate string to operator" do
+          assert_equal '>=', @condition.operator
+        end
+
+      end
+
+      context "with chronic => true" do
+        setup do
+          @condition = RestfulQuery::Condition.new('created_at', '1 week ago', 'gteq', :chronic => true)
+        end
+
+        should "save option to options" do
+          assert @condition.options[:chronic]
+        end
+
+        should "parse value with chronic" do
+          assert_equal(Chronic.parse('1 week ago').to_s, @condition.value.to_s)
+        end
+      end
+
+      context "with a value of ':nil'" do
+        setup do
+          @condition = RestfulQuery::Condition.new('created_at', ':nil')
+        end
+
+        should "convert value to true nil" do
+          assert_equal(nil, @condition.value)
+        end
+      end
+
+      context "with a value of ':true'" do
+        setup do
+          @condition = RestfulQuery::Condition.new('created_at', ':true')
+        end
+
+        should "convert value to true true" do
+          assert_equal(true, @condition.value)
+        end
+      end
+
+      context "with a value of ':blank'" do
+        setup do
+          @condition = RestfulQuery::Condition.new('created_at', ':blank')
+        end
+
+        should "convert value to true true" do
+          assert_equal('', @condition.value)
+        end
+      end
+
+      context "with the IN operator" do
+        setup do
+          @condition = RestfulQuery::Condition.new('year', '1995,2005,2006', 'in')
+        end
+
+        should "assign the operator" do
+          assert_equal 'IN', @condition.operator
+        end
+
+        should "split values by the delimiter option" do
+          assert_equal ['1995', '2005', '2006'], @condition.value
+        end
+
+        should "include parens in placeholder" do
+          assert_equal ["year IN (?)", ['1995', '2005', '2006']], @condition.to_condition_array
+        end
+
+        context "when the value is already an array" do
+          setup do
+            @condition = RestfulQuery::Condition.new('year', ['1995', '2005', '2006'], 'in')
+          end
+
+          should "not resplit the value" do
+            assert_equal ['1995', '2005', '2006'], @condition.value
+          end
+        end
+      end
+
+      context "with the NOT IN operator" do
+        setup do
+          @condition = RestfulQuery::Condition.new('year', '1995|2005|2006', 'notin', :delimiter => '|')
+        end
+
+        should "assign the operator" do
+          assert_equal 'NOT IN', @condition.operator
+        end
+
+        should "split values by delimiter option" do
+          assert_equal ['1995', '2005', '2006'], @condition.value
+        end
+      end
+    end
+
+
+    context "a Condition" do
+      setup do
+        @condition = RestfulQuery::Condition.new('title', 'Bossman', 'lt')
+      end
+
+      context "with operator = like to condition array" do
+        setup do
+          @condition = RestfulQuery::Condition.new('title', 'Bossman', 'like')
+          @to_condition_array = @condition.to_condition_array
+        end
+
+        should "wrap value with %" do
+          assert_equal "%Bossman%", @to_condition_array[1]
+        end
+
+        should "translate operator to LIKE" do
+          assert_equal("title LIKE ?", @to_condition_array[0])
+        end
+
+      end
+
+      context "to_condition_array" do
+        setup do
+          @to_condition = @condition.to_condition_array
+        end
+
+        should "return array" do
+          assert @to_condition.is_a?(Array)
+        end
+
+        should "have conditional string first" do
+          assert_equal 'title < ?', @to_condition[0]
+        end
+
+        should "have value as [1]" do
+          assert_equal @condition.value, @to_condition[1]
+        end
+      end
+
+      context "to_hash" do
+        should "return hash like params" do
+          assert_equal({'title' => {'lt' => 'Bossman'}}, @condition.to_hash)
+        end
+      end
+    end
+  end
+
+end

data/test/test_restful_query_parser.rb

@@ -0,0 +1,467 @@
+require 'test_helper'
+
+class RestfulQueryParserTest < Test::Unit::TestCase
+
+  context "Parser" do
+    setup do
+      @base_query_hash = {'created_at' => {'gt' => '1 week ago', 'lt' => '1 hour ago'}, 'updated_at' => {'lt' => '1 day ago'}, 'title' => {'eq' => 'Test'}, 'other_time' => {'gt' => 'oct 1'}, 'name' => 'Aaron'}
+    end
+
+    context "from_hash" do
+
+      context "without hash" do
+        setup do
+          @parser = RestfulQuery::Parser.new(nil)
+        end
+
+        should "return Parser object" do
+          assert @parser.is_a?(RestfulQuery::Parser)
+        end
+
+        should "have a blank hash for query hash" do
+          assert_equal({}, @parser.to_query_hash)
+        end
+      end
+
+      context "with a hash of columns and operations" do
+        setup do
+          new_parser_from_hash
+        end
+
+        should "return parser object" do
+          assert @parser.is_a?(RestfulQuery::Parser)
+        end
+
+        should "save hash to query_hash" do
+          assert_equal @base_query_hash, @parser.to_query_hash
+        end
+
+        should "save each condition as a condition object" do
+          assert @parser.conditions.is_a?(Array)
+          assert @parser.conditions.first.is_a?(RestfulQuery::Condition)
+        end
+
+        should "save condition without operator with default operator" do
+          assert @parser.conditions_for(:name)
+          assert @parser.conditions_for(:name).first.is_a?(RestfulQuery::Condition)
+          assert_equal '=', @parser.conditions_for(:name).first.operator
+        end
+
+      end
+
+      context "with exclude columns" do
+        setup do
+          new_parser_from_hash({}, :exclude_columns => [:other_time,'name'])
+        end
+
+        should "return parser object" do
+          assert @parser.is_a?(RestfulQuery::Parser)
+        end
+
+        should "exclude columns from conditions" do
+          assert @parser.conditions_for('created_at')
+          assert_nil @parser.conditions_for('other_time')
+          assert_nil @parser.conditions_for(:name)
+        end
+
+      end
+
+      context "with chronic => true" do
+        setup do
+          new_parser_from_hash({}, :chronic => true)
+        end
+
+        should "return parser object" do
+          assert @parser.is_a?(RestfulQuery::Parser)
+        end
+
+        should "parse created at and updated with chronic" do
+          assert_equal Chronic.parse('1 week ago').to_s, @parser.conditions_for(:created_at).first.value.to_s
+          assert_equal Chronic.parse('1 day ago').to_s, @parser.conditions_for(:updated_at).first.value.to_s
+        end
+
+      end
+
+      context "with chronic => []" do
+        setup do
+          new_parser_from_hash({}, :chronic => [:other_time])
+        end
+
+        should "return parser object" do
+          assert @parser.is_a?(RestfulQuery::Parser)
+        end
+
+        should "parse selected attributes in array with chronic" do
+          assert_equal Chronic.parse('oct 1').to_s, @parser.conditions_for(:other_time).first.value.to_s
+        end
+
+        should "not parse created at/updated at if not specified" do
+          assert_not_equal Chronic.parse('1 week ago').to_s, @parser.conditions_for(:created_at).first.value.to_s
+          assert_not_equal Chronic.parse('1 day ago').to_s, @parser.conditions_for(:updated_at).first.value.to_s
+        end
+      end
+      
+      context "with blank values" do
+        setup do
+          new_parser_from_hash({'isblank' => ''})
+        end
+
+        should "return parser object" do
+          assert @parser.is_a?(RestfulQuery::Parser)
+        end
+
+        should "not include conditions for blank values" do
+          assert @parser.conditions_for('created_at')
+          assert_nil @parser.conditions_for('isblank')
+        end
+      end
+      
+      context "with map_columns" do
+        setup do
+          new_parser_from_hash({'section' => 4, '_sort' => 'category-up'}, {:map_columns => {
+            'section' => 'section_id',
+            'category' => 'category_id'
+          }})
+        end
+        
+        should "return parser object" do
+          assert @parser.is_a?(RestfulQuery::Parser)
+        end
+        
+        should "set the map_columns attribute" do
+          assert @parser.map_columns.is_a?(Hash)
+        end
+        
+        should "map condition column" do
+          assert @parser.conditions_for('section')
+          assert_equal 'section_id', @parser.conditions_for('section').first.column
+        end
+        
+        should "map sort column" do
+          @sort = @parser.sorts.first 
+          assert @sort.is_a?(RestfulQuery::Sort)
+          assert_equal 'ASC', @sort.direction
+          assert_equal 'category_id', @sort.column
+        end
+      end
+
+      context "with sort as a single string" do
+        setup do
+          new_parser_from_hash({'_sort' => 'created_at-up'})
+        end
+
+        should "return parser object" do
+          assert @parser.is_a?(RestfulQuery::Parser)
+        end
+
+        should "parse sort string" do
+          @sort = @parser.sorts.first 
+          assert @sort.is_a?(RestfulQuery::Sort)
+          assert_equal 'ASC', @sort.direction
+          assert_equal 'created_at', @sort.column
+        end
+
+        should "add sort to sorts" do
+          assert @parser.sorts
+          assert_equal 1, @parser.sorts.length
+        end
+
+      end
+
+      context "with sort as an array of strings" do
+        setup do
+          new_parser_from_hash({'_sort' => ['created_at-up','title-desc']})
+        end
+
+        should "return parser object" do
+          assert @parser.is_a?(RestfulQuery::Parser)
+        end
+
+        should "add sorts to sorts" do
+          assert @parser.sorts
+          assert_equal 2, @parser.sorts.length
+          @parser.sorts.each do |sort|
+            assert sort.is_a?(RestfulQuery::Sort)
+          end
+        end
+
+      end
+      
+      context "with a default_sort" do
+        context "with no sorts defined in the query hash" do
+          setup do
+            new_parser_from_hash({}, {:default_sort => 'created_at DESC'})
+          end
+          
+          should "return parser object" do
+            assert @parser.is_a?(RestfulQuery::Parser)
+          end
+        
+          should "have default sort in sorts" do
+            assert @parser.sorts
+            assert_equal 1, @parser.sorts.length
+            assert_equal 'created_at DESC', @parser.sort_sql
+          end
+        end
+        
+        context "with sorts defined in the query hash" do
+          setup do
+            new_parser_from_hash({'_sort' => 'created_at-up'})
+          end
+
+          should "return parser object" do
+            assert @parser.is_a?(RestfulQuery::Parser)
+          end
+          
+          should "have query hash sorts in sorts and not default sort" do
+            assert @parser.sorts
+            assert_equal 1, @parser.sorts.length
+            assert_equal 'created_at ASC', @parser.sort_sql
+          end
+        end
+      end
+    end
+    
+    context "from an array of conditions" do
+      setup do
+        @array_of_conditions = [
+          {'column' => 'created_at', 'operator' => 'gt', 'value' => '1 week ago'}, 
+          {'column' => 'created_at', 'operator' => 'lt', 'value' => '1 hour ago'}, 
+          {'column' => 'updated_at', 'operator' => 'lt', 'value' => '1 day ago'}, 
+          {'column' => 'title', 'operator' => 'eq', 'value' => 'Test'}, 
+          {'column' => 'other_time', 'operator' => 'gt', 'value' => 'oct 1'},
+          {'column'  => 'name', 'value' => 'Aaron'}
+        ]
+        @parser = RestfulQuery::Parser.new(:conditions => @array_of_conditions)
+      end
+      
+      should "return parser object" do
+        assert @parser.is_a?(RestfulQuery::Parser)
+      end
+
+      should "save each condition as a condition object" do
+        assert @parser.conditions.is_a?(Array)
+        assert_equal 6, @parser.conditions.length
+        assert @parser.conditions.first.is_a?(RestfulQuery::Condition)
+      end
+
+      should "save condition without operator with default operator" do
+        assert @parser.conditions_for(:name)
+        assert @parser.conditions_for(:name).first.is_a?(RestfulQuery::Condition)
+        assert_equal '=', @parser.conditions_for(:name).first.operator
+      end
+    
+    end
+
+    context "a loaded parser" do
+      setup do
+        new_parser_from_hash
+      end
+
+      context "conditions" do
+        setup do
+          @conditions = @parser.conditions
+        end
+
+        should "return array of all conditions objects" do
+          assert @conditions.is_a?(Array)
+          @conditions.each do |condition|
+            assert condition.is_a?(RestfulQuery::Condition)
+          end
+        end
+
+        should "include conditions for every attribute" do
+          assert_equal @base_query_hash.keys.length + 1, @conditions.length
+        end
+      end
+
+      context "conditions_for" do
+        should "return nil for columns without conditions" do
+          assert_nil @parser.conditions_for(:blah)
+        end
+
+        should "return array of conditions for column that exists" do
+          @conditions = @parser.conditions_for(:created_at)
+          assert @conditions.is_a?(Array)
+          @conditions.each do |condition|
+            assert condition.is_a?(RestfulQuery::Condition)
+            assert_equal 'created_at', condition.column
+          end
+        end
+
+      end
+
+      context "to conditions array" do
+        setup do
+          @conditions = @parser.to_conditions_array
+        end
+
+        should "return array" do
+          assert @conditions.is_a?(Array)
+        end
+
+        should "first element should be a condition string" do
+          assert @conditions[0].is_a?(String)
+        end
+
+        should "include operators for all querys" do
+          assert_match(/(([a-z_]) (\<|\>|\=|\<\=|\>\=) \? AND)+/,@conditions[0])
+        end
+
+        should "join query hash with AND" do
+          assert_match(/AND/,@conditions[0])
+        end
+
+        should "include values for each conditions" do
+          assert_equal @base_query_hash.keys.length + 2, @conditions.length
+        end
+
+      end
+
+      context "to conditions with :or" do
+        setup do
+          @conditions = @parser.to_conditions_array(:or)
+        end
+
+        should "join query hash with OR" do
+          assert_match(/(([a-z_]) (\<|\>|\=|\<\=|\>\=) \? OR)+/,@conditions[0])
+        end
+      end
+      
+      context "to_query_hash" do
+        context "with no altering" do
+          setup do
+            @query_hash = @parser.to_query_hash
+          end
+          
+          should "return hash" do
+            assert @query_hash.is_a?(Hash)
+          end
+      
+          should "return initial query hash" do
+            assert_equal({'gt' => '1 week ago', 'lt' => '1 hour ago'}, @query_hash['created_at'])
+          end
+        end
+        
+        context "with altered sorts" do
+          setup do
+            @parser.set_sort('title', 'up')
+            @parser.set_sort('created_at', 'down')
+            @query_hash = @parser.to_query_hash
+          end
+          
+          should "include unaltered sort conditions" do
+            assert_equal({'gt' => '1 week ago', 'lt' => '1 hour ago'}, @query_hash['created_at'])
+          end
+          
+          should "include altered sorts" do
+            assert_equal(['title-asc','created_at-desc'], @query_hash['_sort'])
+          end
+        end
+      end
+      
+      context "sorts" do
+        setup do
+          new_parser_from_hash({'_sort' => ['title-down', 'updated_at-asc']})
+          @sorts = @parser.sorts 
+        end
+        
+        should "return an array of sort objects" do
+          assert @sorts
+          assert_equal 2, @sorts.length
+          @sorts.each do |sort|
+            assert sort.is_a?(RestfulQuery::Sort)
+          end
+        end
+        
+        context "sorted_columns" do
+          should "return an array of columns" do
+            @sorted_columns = @parser.sorted_columns
+            assert @sorted_columns.is_a?(Array)
+            assert @sorted_columns.include?('title')
+          end
+        end
+        
+        context "sorted_by?" do
+          should "return true if column is sorted" do
+            assert @parser.sorted_by?('title')
+          end
+          
+          should "return false if column is not sorted" do
+            assert !@parser.sorted_by?('created_at')
+          end
+        end
+        
+        context "sort()" do
+          should "return Sort object if column is sorted" do
+            sort = @parser.sort('title')
+            assert sort.is_a?(RestfulQuery::Sort)
+            assert_equal 'title', sort.column
+          end
+          
+          should "return nil if col" do
+            assert_nil @parser.sort('created_at')
+          end
+        end
+        
+        context "set_sort" do
+          context "with an existing sort" do            
+            setup do
+              @parser.set_sort('title','up')
+            end
+            
+            should "not add new sort" do
+              assert_equal 2, @parser.sorts.length
+            end
+            
+            should "update sort direction" do
+              assert_equal 'ASC', @parser.sort('title').direction
+            end
+          end
+          
+          context "with direction: nil" do
+            setup do
+              @parser.set_sort('title', nil)
+            end
+            
+            should "remove sort" do
+              assert_equal 1, @parser.sorts.length
+              assert !@parser.sorted_by?('title')
+            end
+          end
+          
+          context "with a new sort" do
+            setup do
+              @parser.set_sort('name', 'down')
+            end
+            
+            should "add sort to sorts" do
+              assert_equal 3, @parser.sorts.length
+            end
+            
+            should "set sort direction" do
+              assert_equal 'DESC', @parser.sort('name').direction
+            end
+          end
+          
+        end
+        
+      end
+      
+
+      context "sort_sql" do
+        should "join order with ," do
+          new_parser_from_hash({'_sort' => ['title-down', 'updated_at-asc']})
+          assert_equal 'title DESC, updated_at ASC', @parser.sort_sql
+        end
+      end
+
+    end
+
+  end
+
+  protected
+  def new_parser_from_hash(params = {}, options = {})
+    @parser = RestfulQuery::Parser.new(@base_query_hash.merge(params), options)
+  end
+end