decisiv-grouped_scope 0.5.1.1

data/test/grouped_scope/has_many_association_test.rb

@@ -0,0 +1,157 @@
+require File.dirname(__FILE__) + '/../helper'
+
+class GroupedScope::HasManyAssociationTest < GroupedScope::TestCase
+  
+  def setup
+    setup_environment
+  end
+  
+  
+  context 'For an Employee' do
+    
+    setup do 
+      @employee = Factory(:employee)
+    end
+    
+    should 'scope existing association to owner' do
+      assert_sql(/employee_id = #{@employee.id}/) do
+        @employee.reports(true)
+      end
+    end
+    
+    should 'scope group association to group' do
+      assert_sql(/employee_id IN \(#{@employee.id}\)/) do
+        @employee.group.reports(true)
+      end
+    end
+    
+    context 'for counting sql' do
+      
+      setup do
+        @e1 = Factory(:employee_with_reports, :group_id => 1)
+        @e2 = Factory(:employee_with_reports, :group_id => 1)
+      end
+      
+      should 'scope count sql to owner' do
+        assert_sql(/SELECT count\(\*\)/,/employee_id = #{@e1.id}/) do
+          @e1.reports(true).count
+        end
+      end
+      
+      should 'scope count sql to group' do
+        assert_sql(/SELECT count\(\*\)/,/employee_id IN \(#{@e1.id},#{@e2.id}\)/) do
+          @e1.group.reports(true).count
+        end
+      end
+      
+      should 'have a group count equal to sum of seperate owner counts' do
+        assert_equal @e1.reports(true).count + @e2.reports(true).count, @e2.group.reports(true).count
+      end
+      
+    end
+    
+    context 'training association extensions' do
+    
+      setup do
+        @e1 = Factory(:employee_with_urgent_reports, :group_id => 1)
+        @e2 = Factory(:employee, :group_id => 1)
+        @urgent_reports = @e1.reports.select(&:urgent_title?)
+      end
+      
+      should 'find urgent report via normal ungrouped association' do
+        assert_same_elements @urgent_reports, @e1.reports(true).urgent
+      end
+      
+      should 'find urgent report via grouped reflection' do
+        assert_same_elements @urgent_reports, @e2.group.reports(true).urgent
+      end
+      
+      should 'use assoc extension SQL along with group reflection' do
+        assert_sql(select_from_reports, where_for_groups, where_for_urgent_title) do
+          @e2.group.reports.urgent
+        end
+      end
+    
+    end
+    
+    context 'training named scopes' do
+      
+      setup do
+        @e1 = Factory(:employee_with_urgent_reports, :group_id => 1)
+        @e2 = Factory(:employee, :group_id => 1)
+        @urgent_titles = @e1.reports.select(&:urgent_title?)
+        @urgent_bodys = @e1.reports.select(&:urgent_body?)
+      end
+      
+      should 'find urgent reports via normal named scopes by normal owner' do
+        assert_same_elements @urgent_titles, @e1.reports(true).with_urgent_title
+        assert_same_elements @urgent_bodys, @e1.reports(true).with_urgent_body
+      end
+      
+      should 'find urgent reports via group reflection by group member' do
+        assert_same_elements @urgent_titles, @e2.group.reports(true).with_urgent_title
+        assert_same_elements @urgent_bodys, @e2.group.reports(true).with_urgent_body
+      end
+      
+      should 'use named scope SQL along with group reflection' do
+        assert_sql(select_from_reports, where_for_groups, where_for_urgent_body, where_for_urgent_title) do
+          @e2.group.reports.with_urgent_title.with_urgent_body.inspect
+        end
+      end
+      
+      context 'with will paginate' do
+        
+        should 'use group reflection, named scope, and paginate SQL' do
+          where_ends_with_limits = /WHERE.*LIMIT 2 OFFSET 0/
+          assert_sql(select_from_reports, where_for_groups, where_for_urgent_body, where_for_urgent_title, where_ends_with_limits) do
+            @e2.group.reports.with_urgent_title.with_urgent_body.paginate(:page=>1,:per_page=>2)
+          end
+        end
+        
+      end
+      
+    end
+    
+  end
+  
+  context 'For a LegacyEmployee' do
+  
+    setup do
+      @employee = Factory(:legacy_employee)
+    end
+  
+    should 'scope existing association to owner' do
+      assert_sql(/"?legacy_reports"?.email = '#{@employee.id}'/) do
+        @employee.reports(true)
+      end
+    end
+    
+    should 'scope group association to group' do
+      assert_sql(/"?legacy_reports"?.email IN \('#{@employee.id}'\)/) do
+        @employee.group.reports(true)
+      end
+    end
+    
+  end
+  
+  
+  protected
+  
+  def select_from_reports
+    /SELECT \* FROM "?reports"?/
+  end
+  
+  def where_for_groups
+    /WHERE.*"?reports"?.employee_id IN \(2,3\)/
+  end
+  
+  def where_for_urgent_body
+    /WHERE.*body LIKE '%URGENT%'/
+  end
+  
+  def where_for_urgent_title
+    /WHERE.*"?reports"?."?title"? = 'URGENT'/
+  end
+  
+  
+end

data/test/grouped_scope/has_many_through_association_test.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/../helper'
+
+class GroupedScope::HasManyThroughAssociationTest < GroupedScope::TestCase
+  
+  def setup
+    setup_environment
+    @e1 = Factory(:employee, :group_id => 1)
+    @e1.departments << Department.hr << Department.finance
+    @e2 = Factory(:employee, :group_id => 1)
+    @e2.departments << Department.it
+    @all_group_departments = [Department.hr, Department.it, Department.finance]
+  end
+  
+  
+  context 'For default association' do
+
+    should 'scope to owner' do
+      assert_sql(/employee_id = #{@e1.id}/) do
+        @e1.departments(true)
+      end
+    end
+    
+    should 'scope count to owner' do
+      assert_sql(/employee_id = #{@e1.id}/) do
+        @e1.departments(true).count
+      end
+    end
+    
+  end
+  
+  context 'For grouped association' do
+
+    should 'scope to group' do
+      assert_sql(/employee_id IN \(#{@e1.id},#{@e2.id}\)/) do
+        @e2.group.departments(true)
+      end
+    end
+    
+    should 'scope count to group' do
+      assert_sql(/employee_id IN \(#{@e1.id},#{@e2.id}\)/) do
+        @e1.group.departments(true).count
+      end
+    end
+    
+    should 'have a group count equal to sum of seperate owner counts' do
+      assert_equal @e1.departments(true).count + @e2.departments(true).count, @e2.group.departments(true).count
+    end
+    
+  end
+  
+  
+  
+end

data/test/grouped_scope/self_grouping_test.rb

@@ -0,0 +1,147 @@
+require File.dirname(__FILE__) + '/../helper'
+
+class GroupedScope::SelfGrouppingTest < GroupedScope::TestCase
+  
+  def setup
+    setup_environment
+  end
+  
+  context 'General behavior' do
+    
+    setup do
+      @employee = Factory(:employee)
+    end
+    
+    should 'return an array' do
+      assert_instance_of Array, @employee.group
+    end
+    
+    should 'return #ids array' do
+      assert_equal [@employee.id], @employee.group.ids
+    end
+    
+    should 'return #quoted_ids string for use in sql statments' do
+      assert_equal "#{@employee.id}", @employee.group.quoted_ids
+    end
+    
+    should 'respond true to grouped associations' do
+      assert @employee.group.respond_to?(:reports)
+    end
+    
+    should 'raise a GroupedScope::NoGroupIdError exception for objects with no group_id schema' do
+      assert_does_not_contain FooBar.column_names, 'group_id'
+      assert_raise(GroupedScope::NoGroupIdError) { GroupedScope::SelfGroupping.new(FooBar.new) }
+    end
+    
+    should 'return correct attribute_condition for GroupedScope::SelfGroupping object' do
+      assert_sql(/"?group_id"? IN \(#{@employee.id}\)/) do
+        Employee.find :all, :conditions => {:group_id => @employee.group}
+      end
+    end
+    
+    context 'for Array delegates' do
+
+      should 'respond to first/last' do
+        [:first,:last].each do |method|
+          assert @employee.group.respond_to?(method), "Should respond to #{method.inspect}"
+        end
+      end
+      
+      should 'respond to each' do
+        assert @employee.group.respond_to?(:each)
+        @employee.group.each do |employee|
+          assert_instance_of Employee, employee
+        end
+      end
+      
+    end
+    
+  end
+  
+  context 'Calling #group' do
+    
+    should 'return an array' do
+      assert_instance_of Array, Factory(:employee).group
+    end
+    
+    context 'with a NIL group_id' do
+      
+      setup do
+        @employee = Factory(:employee)
+      end
+      
+      should 'return a collection of one' do
+        assert_equal 1, @employee.group.size
+      end
+      
+      should 'include self in group' do
+        assert_contains @employee.group, @employee
+      end
+      
+    end
+    
+    context 'with a set group_id' do
+      
+      setup do
+        @employee = Factory(:employee, :group_id => 1)
+      end
+      
+      should 'return a collection of one' do
+        assert_equal 1, @employee.group.size
+      end
+      
+      should 'include self in group' do
+        assert_contains @employee.group, @employee
+      end
+      
+    end
+    
+    context 'with different groups available' do
+      
+      setup do
+        @e1 = Factory(:employee_with_reports, :group_id => 1)
+        @e2 = Factory(:employee, :group_id => 1)
+        @e3 = Factory(:employee_with_reports, :group_id => 2)
+        @e4 = Factory(:employee, :group_id => 2)
+      end
+      
+      should 'return a collection of group members' do
+        assert_equal 2, @e1.group.size
+      end
+      
+      should 'include all group members' do
+        assert_same_elements [@e1,@e2], @e1.group
+      end
+      
+      should 'allow member to find grouped associations of other member' do
+        assert_same_elements @e1.reports, @e2.group.reports
+      end
+      
+      should 'allow proxy owner to define all grouped which ignores group_id schema' do
+        @e2.stubs(:all_grouped?).returns(true)
+        assert_same_elements [@e1,@e2,@e3,@e4], @e2.group
+        assert_same_elements @e1.reports + @e3.reports, @e2.group.reports
+      end
+      
+    end
+    
+    context 'with different groups in legacy schema' do
+      
+      setup do
+        @e1 = Factory(:legacy_employee_with_reports, :group_id => 1)
+        @e2 = Factory(:legacy_employee, :group_id => 1)
+        @e3 = Factory(:legacy_employee_with_reports, :group_id => 2)
+        @e4 = Factory(:legacy_employee, :group_id => 2)
+      end
+      
+      should 'honor legacy reports association options like class_name and foreign_key' do
+        @e2.group.reports.all? { |r| r.is_a?(LegacyReport) }
+      end
+      
+    end
+    
+    
+  end
+  
+  
+end

data/test/helper.rb

@@ -0,0 +1,108 @@
+require File.join(File.dirname(__FILE__),'lib/boot') unless defined?(ActiveRecord)
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+require 'factory_girl'
+require 'lib/test_case'
+require 'grouped_scope'
+
+class GroupedScope::TestCase
+  
+  def setup_environment(options={})
+    options.reverse_merge! :group_column => :group_id
+    setup_database(options)
+    Department.create! :name => 'IT'
+    Department.create! :name => 'Human Resources'
+    Department.create! :name => 'Finance'
+  end
+  
+  protected
+  
+  def setup_database(options)
+    ActiveRecord::Base.class_eval do
+      silence do
+        connection.create_table :employees, :force => true do |t|
+          t.column :name,         :string
+          t.column :email,        :string
+          t.column options[:group_column],  :integer
+        end
+        connection.create_table :reports, :force => true do |t|
+          t.column :title,        :string
+          t.column :body,         :string
+          t.column :employee_id,  :integer
+        end
+        connection.create_table :departments, :force => true do |t|
+          t.column :name,         :string
+        end
+        connection.create_table :department_memberships, :force => true do |t|
+          t.column :employee_id,    :integer
+          t.column :department_id,  :integer
+          t.column :meta_info,      :string
+        end
+        connection.create_table :legacy_employees, :force => true, :id => false do |t|
+          t.column :name,         :string
+          t.column :email,        :string
+          t.column options[:group_column],  :integer
+        end
+        connection.create_table :legacy_reports, :force => true do |t|
+          t.column :title,        :string
+          t.column :body,         :string
+          t.column :email,        :string
+        end
+        connection.create_table :foo_bars, :force => true do |t|
+          t.column :foo,          :string
+          t.column :bar,          :string
+        end
+      end
+    end
+  end
+  
+end
+
+class Employee < ActiveRecord::Base
+  has_many :reports do ; def urgent ; find(:all,:conditions => {:title => 'URGENT'}) ; end ; end
+  has_many :taxonomies, :as => :classable
+  has_many :department_memberships
+  has_many :departments, :through => :department_memberships
+  grouped_scope :reports, :departments
+end
+
+class Report < ActiveRecord::Base
+  named_scope :with_urgent_title, :conditions => {:title => 'URGENT'}
+  named_scope :with_urgent_body, :conditions => "body LIKE '%URGENT%'"
+  belongs_to :employee
+  def urgent_title? ; self[:title] == 'URGENT' ; end
+  def urgent_body? ; self[:body] =~ /URGENT/ ; end
+end
+
+class Department < ActiveRecord::Base
+  named_scope :it, :conditions => {:name => 'IT'}
+  named_scope :hr, :conditions => {:name => 'Human Resources'}
+  named_scope :finance, :conditions => {:name => 'Finance'}
+  has_many :department_memberships
+  has_many :employees, :through => :department_memberships
+end
+
+class DepartmentMembership < ActiveRecord::Base
+  belongs_to :employee
+  belongs_to :department
+end
+
+class LegacyEmployee < ActiveRecord::Base
+  set_primary_key :email
+  has_many :reports, :class_name => 'LegacyReport', :foreign_key => 'email'
+  grouped_scope :reports
+  alias_method :email=, :id=
+end
+
+class LegacyReport < ActiveRecord::Base
+  belongs_to :employee, :class_name => 'LegacyEmployee', :foreign_key => 'email'
+end
+
+class FooBar < ActiveRecord::Base
+  has_many :reports
+  grouped_scope :reports
+end
+
+
+

data/test/lib/boot.rb

@@ -0,0 +1,32 @@
+require 'rubygems'
+
+plugin_root     = File.expand_path(File.join(File.dirname(__FILE__),'..'))
+framework_root  = ["#{plugin_root}/rails", "#{plugin_root}/../../rails"].detect { |p| File.directory? p }
+rails_version   = ENV['RAILS_VERSION']
+rails_version   = nil if rails_version && rails_version == ''
+
+['.','lib','test'].each do |plugin_lib|
+  load_path = File.expand_path("#{plugin_root}/#{plugin_lib}")
+  $LOAD_PATH.unshift(load_path) unless $LOAD_PATH.include?(load_path)
+end
+
+if rails_version.nil? && framework_root
+  puts "Found framework root: #{framework_root}"
+  $:.unshift "#{framework_root}/activesupport/lib", "#{framework_root}/activerecord/lib"
+else
+  puts "Using rails#{" #{rails_version}" if rails_version} from gems"
+  if rails_version
+    gem 'rails', rails_version
+  else
+    gem 'activerecord'
+  end
+end
+
+require 'active_record'
+require 'active_support'
+
+gem 'mislav-will_paginate', '2.3.4'
+require 'will_paginate'
+WillPaginate.enable_activerecord
+require 'named_scope'
+

data/test/lib/core_ext.rb

@@ -0,0 +1,20 @@
+
+unless Hash.instance_methods.include? 'except'
+  
+  Hash.class_eval do
+    
+    # Returns a new hash without the given keys.
+    def except(*keys)
+      rejected = Set.new(respond_to?(:convert_key) ? keys.map { |key| convert_key(key) } : keys)
+      reject { |key,| rejected.include?(key) }
+    end
+ 
+    # Replaces the hash without only the given keys.
+    def except!(*keys)
+      replace(except(*keys))
+    end
+    
+  end
+  
+end
+

data/test/lib/named_scope/core_ext.rb

@@ -0,0 +1,82 @@
+
+unless Hash.instance_methods.include? 'except'
+  Hash.class_eval do
+    
+    # Returns a new hash without the given keys.
+    def except(*keys)
+      rejected = Set.new(respond_to?(:convert_key) ? keys.map { |key| convert_key(key) } : keys)
+      reject { |key,| rejected.include?(key) }
+    end
+ 
+    # Replaces the hash without only the given keys.
+    def except!(*keys)
+      replace(except(*keys))
+    end
+    
+  end
+end
+
+class ActiveRecord::Base
+  class << self
+    
+    def first(*args)
+      find(:first, *args)
+    end
+
+    def last(*args)
+      find(:last, *args)
+    end
+
+    def all(*args)
+      find(:all, *args)
+    end
+    
+    private
+    
+    def find_last(options)
+      order = options[:order]
+      if order
+        order = reverse_sql_order(order)
+      elsif !scoped?(:find, :order)
+        order = "#{table_name}.#{primary_key} DESC"
+      end
+      if scoped?(:find, :order)
+        scoped_order = reverse_sql_order(scope(:find, :order))
+        scoped_methods.select { |s| s[:find].update(:order => scoped_order) }
+      end
+      find_initial(options.merge({ :order => order }))
+    end
+    
+    def reverse_sql_order(order_query)
+      reversed_query = order_query.split(/,/).each { |s|
+        if s.match(/\s(asc|ASC)$/)
+          s.gsub!(/\s(asc|ASC)$/, ' DESC')
+        elsif s.match(/\s(desc|DESC)$/)
+          s.gsub!(/\s(desc|DESC)$/, ' ASC')
+        elsif !s.match(/\s(asc|ASC|desc|DESC)$/)
+          s.concat(' DESC')
+        end
+      }.join(',')
+    end
+    
+  end
+end
+
+ActiveRecord::Associations::AssociationCollection.class_eval do
+  
+  def last(*args)
+    if fetch_first_or_last_using_find? args
+      find(:last, *args)
+    else
+      load_target unless loaded?
+      @target.last(*args)
+    end
+  end
+  
+  private
+  
+  def fetch_first_or_last_using_find?(args)
+    args.first.kind_of?(Hash) || !(loaded? || @owner.new_record? || @reflection.options[:finder_sql] || !@target.blank? || args.first.kind_of?(Integer))
+  end
+  
+end