amrita2 2.0.0 → 2.0.1

data/sample/depot/vendor/plugins/will_paginate/test/fixtures/company.rb

@@ -0,0 +1,9 @@
+class Company < ActiveRecord::Base
+  attr_protected :rating
+  set_sequence_name :companies_nonstd_seq
+
+  validates_presence_of :name
+  def validate
+    errors.add('rating', 'rating should not be 2') if rating == 2
+  end  
+end

data/sample/depot/vendor/plugins/will_paginate/test/fixtures/developer.rb

@@ -0,0 +1,11 @@
+class Developer < User
+  has_and_belongs_to_many :projects, :include => :topics, :order => 'projects.name'
+
+  def self.with_poor_ones(&block)
+    with_scope :find => { :conditions => ['salary <= ?', 80000], :order => 'salary' } do
+      yield
+    end
+  end
+
+  def self.per_page() 10 end
+end

data/sample/depot/vendor/plugins/will_paginate/test/fixtures/project.rb

@@ -0,0 +1,15 @@
+class Project < ActiveRecord::Base
+  has_and_belongs_to_many :developers, :uniq => true
+  
+  has_many :topics
+    # :finder_sql  => 'SELECT * FROM topics WHERE (topics.project_id = #{id})',
+    # :counter_sql => 'SELECT COUNT(*) FROM topics WHERE (topics.project_id = #{id})'
+  
+  has_many :replies, :through => :topics do
+    def find_recent(params = {})
+      with_scope :find => { :conditions => ['replies.created_at > ?', 15.minutes.ago] } do
+        find :all, params
+      end
+    end
+  end
+end

data/sample/depot/vendor/plugins/will_paginate/test/fixtures/reply.rb

@@ -0,0 +1,5 @@
+class Reply < ActiveRecord::Base
+  belongs_to :topic, :include => [:replies]
+  
+  validates_presence_of :content
+end

data/sample/depot/vendor/plugins/will_paginate/test/fixtures/schema.rb

@@ -0,0 +1,38 @@
+ActiveRecord::Schema.define do
+
+  create_table "developers_projects", :id => false, :force => true do |t|
+    t.column "developer_id", :integer,                :null => false
+    t.column "project_id",   :integer,                :null => false
+    t.column "joined_on",    :date
+    t.column "access_level", :integer, :default => 1
+  end
+
+  create_table "projects", :force => true do |t|
+    t.column "name", :text
+  end
+
+  create_table "replies", :force => true do |t|
+    t.column "content",    :text
+    t.column "created_at", :datetime
+    t.column "updated_at", :datetime
+    t.column "topic_id",   :integer
+  end
+
+  create_table "topics", :force => true do |t|
+    t.column "project_id", :integer
+    t.column "title",      :string
+    t.column "subtitle",   :string
+    t.column "content",    :text
+    t.column "created_at", :datetime
+    t.column "updated_at", :datetime
+  end
+
+  create_table "users", :force => true do |t|
+    t.column "name",       :text
+    t.column "salary",     :integer,  :default => 70000
+    t.column "created_at", :datetime
+    t.column "updated_at", :datetime
+    t.column "type",       :text
+  end
+
+end

data/sample/depot/vendor/plugins/will_paginate/test/fixtures/topic.rb

@@ -0,0 +1,4 @@
+class Topic < ActiveRecord::Base
+  has_many :replies, :dependent => :destroy, :order => 'replies.created_at DESC'
+  belongs_to :project
+end

data/sample/depot/vendor/plugins/will_paginate/test/fixtures/user.rb

@@ -0,0 +1,2 @@
+class User < ActiveRecord::Base
+end

data/sample/depot/vendor/plugins/will_paginate/test/helper.rb

@@ -0,0 +1,25 @@
+require 'test/unit'
+require 'rubygems'
+
+# gem install redgreen for colored test output
+begin require 'redgreen'; rescue LoadError; end
+
+require File.join(File.dirname(__FILE__), 'boot') unless defined?(ActiveRecord)
+
+class Test::Unit::TestCase
+  protected
+  def assert_respond_to_all object, methods
+    methods.each do |method|
+      [method.to_s, method.to_sym].each { |m| assert_respond_to object, m }
+    end
+  end
+end
+
+# Wrap tests that use Mocha and skip if unavailable.
+def uses_mocha(test_name)
+  require 'mocha' unless Object.const_defined?(:Mocha)
+  yield
+rescue LoadError => load_error
+  raise unless load_error.message =~ /mocha/i
+  $stderr.puts "Skipping #{test_name} tests. `gem install mocha` and try again."
+end

data/sample/depot/vendor/plugins/will_paginate/test/lib/activerecord_test_case.rb

@@ -0,0 +1,23 @@
+require File.join(File.dirname(__FILE__), 'activerecord_test_connector')
+
+class ActiveRecordTestCase < Test::Unit::TestCase
+  # Set our fixture path
+  if ActiveRecordTestConnector.able_to_connect
+    self.fixture_path = File.join(File.dirname(__FILE__), '..', 'fixtures')
+    self.use_transactional_fixtures = false
+  end
+
+  def self.fixtures(*args)
+    super if ActiveRecordTestConnector.connected
+  end
+
+  def run(*args)
+    super if ActiveRecordTestConnector.connected
+  end
+
+  # Default so Test::Unit::TestCase doesn't complain
+  def test_truth
+  end
+end
+
+ActiveRecordTestConnector.setup

data/sample/depot/vendor/plugins/will_paginate/test/lib/activerecord_test_connector.rb

@@ -0,0 +1,67 @@
+require 'active_record'
+require 'active_record/version'
+require 'active_record/fixtures'
+
+class ActiveRecordTestConnector
+  cattr_accessor :able_to_connect
+  cattr_accessor :connected
+
+  # Set our defaults
+  self.connected = false
+  self.able_to_connect = true
+
+  def self.setup
+    unless self.connected || !self.able_to_connect
+      setup_connection
+      load_schema
+      # require_fixture_models
+      Dependencies.load_paths.unshift(File.dirname(__FILE__) + "/../fixtures")
+      self.connected = true
+    end
+  rescue Exception => e  # errors from ActiveRecord setup
+    $stderr.puts "\nSkipping ActiveRecord assertion tests: #{e}"
+    #$stderr.puts "  #{e.backtrace.join("\n  ")}\n"
+    self.able_to_connect = false
+  end
+
+  private
+
+  def self.setup_connection
+    if Object.const_defined?(:ActiveRecord)
+      defaults = { :database => ':memory:' }
+      ActiveRecord::Base.logger = Logger.new STDOUT if $0 == 'irb'
+      
+      begin
+        options = defaults.merge :adapter => 'sqlite3', :timeout => 500
+        ActiveRecord::Base.establish_connection(options)
+        ActiveRecord::Base.configurations = { 'sqlite3_ar_integration' => options }
+        ActiveRecord::Base.connection
+      rescue Exception  # errors from establishing a connection
+        $stderr.puts 'SQLite 3 unavailable; trying SQLite 2.'
+        options = defaults.merge :adapter => 'sqlite'
+        ActiveRecord::Base.establish_connection(options)
+        ActiveRecord::Base.configurations = { 'sqlite2_ar_integration' => options }
+        ActiveRecord::Base.connection
+      end
+
+      unless Object.const_defined?(:QUOTED_TYPE)
+        Object.send :const_set, :QUOTED_TYPE, ActiveRecord::Base.connection.quote_column_name('type')
+      end
+    else
+      raise "Can't setup connection since ActiveRecord isn't loaded."
+    end
+  end
+
+  def self.load_schema
+    ActiveRecord::Base.silence do
+      ActiveRecord::Migration.verbose = false
+      load File.dirname(__FILE__) + "/../fixtures/schema.rb"
+    end
+  end
+
+  def self.require_fixture_models
+    models = Dir.glob(File.dirname(__FILE__) + "/../fixtures/*.rb")
+    models = (models.grep(/user.rb/) + models).uniq
+    models.each { |f| require f }
+  end
+end

data/sample/depot/vendor/plugins/will_paginate/test/lib/load_fixtures.rb

@@ -0,0 +1,13 @@
+dirname = File.dirname(__FILE__)
+require File.join(dirname, '..', 'boot')
+require File.join(dirname, 'activerecord_test_connector')
+
+# setup the connection
+ActiveRecordTestConnector.setup
+
+# load all fixtures
+fixture_path = File.join(dirname, '..', 'fixtures')
+Fixtures.create_fixtures(fixture_path, ActiveRecord::Base.connection.tables)
+
+require 'will_paginate'
+WillPaginate.enable_activerecord

data/sample/depot/vendor/plugins/will_paginate/test/pagination_test.rb

@@ -0,0 +1,240 @@
+require File.dirname(__FILE__) + '/helper'
+require 'action_controller'
+require 'action_controller/test_process'
+
+ActionController::Routing::Routes.draw do |map|
+  map.connect ':controller/:action/:id'
+end
+
+ActionController::Base.perform_caching = false
+
+require 'will_paginate'
+WillPaginate.enable_actionpack
+
+class PaginationTest < Test::Unit::TestCase
+  
+  class DevelopersController < ActionController::Base
+    def list_developers
+      @options = session[:wp] || {}
+      
+      @developers = (1..11).to_a.paginate(
+        :page => params[@options[:param_name] || :page] || 1,
+        :per_page => params[:per_page] || 4
+      )
+
+      render :inline => '<%= will_paginate @developers, @options %>'
+    end
+
+    def guess_collection_name
+      @developers = session[:wp]
+      @options    = session[:wp_options]
+      render :inline => '<%= will_paginate @options %>'
+    end
+
+    protected
+      def rescue_errors(e) raise e end
+      def rescue_action(e) raise e end
+  end
+  
+  def setup
+    @controller = DevelopersController.new
+    @request    = ActionController::TestRequest.new
+    @response   = ActionController::TestResponse.new
+    super
+  end
+
+  def test_will_paginate
+    get :list_developers
+
+    entries = assigns :developers
+    assert entries
+    assert_equal 4, entries.size
+
+    assert_select 'div.pagination', 1, 'no main DIV' do |el|
+      assert_select 'a[href]', 3 do |elements|
+        validate_page_numbers [2,3,2], elements
+        assert_select elements.last, ':last-child', "Next &raquo;"
+      end
+      assert_select 'span', 2
+      assert_select 'span.disabled:first-child', "&laquo; Previous"
+      assert_select 'span.current', entries.current_page.to_s
+    end
+  end
+
+  def test_will_paginate_with_options
+    get :list_developers, { :page => 2 }, :wp => {
+      :class => 'will_paginate', :prev_label => 'Prev', :next_label => 'Next'
+    }
+    assert_response :success
+    
+    entries = assigns :developers
+    assert entries
+    assert_equal 4, entries.size
+
+    assert_select 'div.will_paginate', 1, 'no main DIV' do
+      assert_select 'a[href]', 4 do |elements|
+        validate_page_numbers [1,1,3,3], elements
+        assert_select elements.first, 'a', "Prev"
+        assert_select elements.last, 'a', "Next"
+      end
+      assert_select 'span.current', entries.current_page.to_s
+    end
+  end
+
+  def test_will_paginate_without_container
+    get :list_developers, {}, :wp => { :container => false }
+    assert_select 'div.pagination', 0, 'no main DIV'
+    assert_select 'a[href]', 3
+  end
+
+  def test_will_paginate_without_page_links
+    get :list_developers, { :page => 2 }, :wp => { :page_links => false }
+    assert_select 'a[href]', 2 do |elements|
+      validate_page_numbers [1,3], elements
+    end
+  end
+  
+  def test_will_paginate_preserves_parameters_on_get
+    get :list_developers, :foo => { :bar => 'baz' }
+    assert_links_match /foo%5Bbar%5D=baz/
+  end
+  
+  def test_will_paginate_doesnt_preserve_parameters_on_post
+    post :list_developers, :foo => 'bar'
+    assert_no_links_match /foo=bar/
+  end
+  
+  def test_adding_additional_parameters
+    get :list_developers, {}, :wp => { :params => { :foo => 'bar' } }
+    assert_links_match /foo=bar/
+  end
+  
+  def test_removing_arbitrary_parameters
+    get :list_developers, { :foo => 'bar' }, :wp => { :params => { :foo => nil } }
+    assert_no_links_match /foo=bar/
+  end
+    
+  def test_adding_additional_route_parameters
+    get :list_developers, {}, :wp => { :params => { :controller => 'baz' } }
+    assert_links_match %r{\Wbaz/list_developers\W}
+  end
+  
+  def test_will_paginate_with_custom_page_param
+    get :list_developers, { :developers_page => 2 }, :wp => { :param_name => :developers_page }
+    assert_response :success
+    
+    entries = assigns :developers
+    assert entries
+    assert_equal 4, entries.size
+
+    assert_select 'div.pagination', 1, 'no main DIV' do
+      assert_select 'a[href]', 4 do |elements|
+        validate_page_numbers [1,1,3,3], elements, :developers_page
+      end
+      assert_select 'span.current', entries.current_page.to_s
+    end    
+  end
+
+  def test_will_paginate_windows
+    get :list_developers, { :page => 6, :per_page => 1 }, :wp => { :inner_window => 1 }
+    assert_response :success
+    
+    entries = assigns :developers
+    assert entries
+    assert_equal 1, entries.size
+
+    assert_select 'div.pagination', 1, 'no main DIV' do
+      assert_select 'a[href]', 8 do |elements|
+        validate_page_numbers [5,1,2,5,7,10,11,7], elements
+        assert_select elements.first, 'a', "&laquo; Previous"
+        assert_select elements.last, 'a', "Next &raquo;"
+      end
+      assert_select 'span.current', entries.current_page.to_s
+    end
+  end
+
+  def test_will_paginate_eliminates_small_gaps
+    get :list_developers, { :page => 6, :per_page => 1 }, :wp => { :inner_window => 2 }
+    assert_response :success
+    
+    assert_select 'div.pagination', 1, 'no main DIV' do
+      assert_select 'a[href]', 12 do |elements|
+        validate_page_numbers [5,1,2,3,4,5,7,8,9,10,11,7], elements
+      end
+    end
+  end
+
+  def test_no_pagination
+    get :list_developers, :per_page => 12
+    entries = assigns :developers
+    assert_equal 1, entries.page_count
+    assert_equal 11, entries.size
+
+    assert_equal '', @response.body
+  end
+  
+  def test_faulty_input_raises_error
+    assert_raise WillPaginate::InvalidPage do
+      get :list_developers, :page => 'foo'
+    end
+  end
+
+  uses_mocha 'helper internals' do
+    def test_collection_name_can_be_guessed
+      collection = mock
+      collection.expects(:page_count).returns(1)
+      get :guess_collection_name, {}, :wp => collection
+    end
+  end
+  
+  def test_inferred_collection_name_raises_error_when_nil
+    ex = assert_raise ArgumentError do
+      get :guess_collection_name, {}, :wp => nil
+    end
+    assert ex.message.include?('@developers')
+  end
+
+  def test_setting_id_for_container
+    get :list_developers
+    assert_select 'div.pagination', 1 do |div|
+      assert_nil div.first['id']
+    end
+    # magic ID
+    get :list_developers, {}, :wp => { :id => true }
+    assert_select 'div.pagination', 1 do |div|
+      assert_equal 'fixnums_pagination', div.first['id']
+    end
+    # explicit ID
+    get :list_developers, {}, :wp => { :id => 'custom_id' }
+    assert_select 'div.pagination', 1 do |div|
+      assert_equal 'custom_id', div.first['id']
+    end
+  end
+  
+protected
+
+  def validate_page_numbers expected, links, param_name = :page
+    param_pattern = /\W#{param_name}=([^&]*)/
+    
+    assert_equal(expected, links.map { |e|
+      e['href'] =~ param_pattern
+      $1 ? $1.to_i : $1
+    })
+  end
+
+  def assert_links_match pattern
+    assert_select 'div.pagination a[href]' do |elements|
+      elements.each do |el|
+        assert_match pattern, el['href']
+      end
+    end
+  end
+
+  def assert_no_links_match pattern
+    assert_select 'div.pagination a[href]' do |elements|
+      elements.each do |el|
+        assert_no_match pattern, el['href']
+      end
+    end
+  end
+end