will_paginate 2.2.2 → 2.3.11

data/test/collection_test.rb

@@ -2,6 +2,9 @@ require 'helper'
 require 'will_paginate/array'
 
 class ArrayPaginationTest < Test::Unit::TestCase
+  
+  def setup ; end
+  
   def test_simple
     collection = ('a'..'e').to_a
     

data/test/database.yml

@@ -9,14 +9,14 @@ sqlite2:
 
 mysql:
   adapter: mysql
-  username: rails
-  password: mislav
+  username: root
+  password: 
   encoding: utf8
   database: will_paginate_unittest
 
 postgres:
   adapter: postgresql
   username: mislav
-  password: mislav
+  password: 
   database: will_paginate_unittest
   min_messages: warning

data/test/finder_test.rb

@@ -261,6 +261,12 @@ class FinderTest < ActiveRecordTestCase
       assert_equal 1, entries.total_entries, 'only one topic should be found'
     end
   end
+  
+  def test_named_scope_with_include
+    project = projects(:active_record)
+    entries = project.topics.with_replies_starting_with('AR ').paginate(:page => 1, :per_page => 1)
+    assert_equal 1, entries.size
+  end
 
   ## misc ##
 
@@ -278,11 +284,11 @@ class FinderTest < ActiveRecordTestCase
   # this functionality is temporarily removed
   def xtest_pagination_defines_method
     pager = "paginate_by_created_at"
-    assert !User.methods.include?(pager), "User methods should not include `#{pager}` method"
+    assert !User.methods.include_method?(pager), "User methods should not include `#{pager}` method"
     # paginate!
     assert 0, User.send(pager, nil, :page => 1).total_entries
     # the paging finder should now be defined
-    assert User.methods.include?(pager), "`#{pager}` method should be defined on User"
+    assert User.methods.include_method?(pager), "`#{pager}` method should be defined on User"
   end
 
   # Is this Rails 2.0? Find out by testing find_all which was removed in [6998]
@@ -340,6 +346,12 @@ class FinderTest < ActiveRecordTestCase
       Developer.paginate :select => 'DISTINCT salary', :page => 2
     end
 
+    def test_count_with_scoped_select_when_distinct
+      Developer.stubs(:find).returns([])
+      Developer.expects(:count).with(:select => 'DISTINCT users.id').returns(0)
+      Developer.distinct.paginate :page => 2
+    end
+
     def test_should_use_scoped_finders_if_present
       # scope-out compatibility
       Topic.expects(:find_best).returns(Array.new(5))
@@ -349,18 +361,15 @@ class FinderTest < ActiveRecordTestCase
     end
 
     def test_paginate_by_sql
-      assert_respond_to Developer, :paginate_by_sql
-      Developer.expects(:find_by_sql).with(regexp_matches(/sql LIMIT 3(,| OFFSET) 3/)).returns([])
-      Developer.expects(:count_by_sql).with('SELECT COUNT(*) FROM (sql) AS count_table').returns(0)
-      
-      entries = Developer.paginate_by_sql 'sql', :page => 2, :per_page => 3
+      sql = "SELECT * FROM users WHERE type = 'Developer' ORDER BY id"
+      entries = Developer.paginate_by_sql(sql, :page => 2, :per_page => 3)
+      assert_equal 11, entries.total_entries
+      assert_equal [users(:dev_4), users(:dev_5), users(:dev_6)], entries
     end
 
     def test_paginate_by_sql_respects_total_entries_setting
-      Developer.expects(:find_by_sql).returns([])
-      Developer.expects(:count_by_sql).never
-      
-      entries = Developer.paginate_by_sql 'sql', :page => 1, :total_entries => 999
+      sql = "SELECT * FROM users"
+      entries = Developer.paginate_by_sql(sql, :page => 1, :total_entries => 999)
       assert_equal 999, entries.total_entries
     end
 
@@ -390,12 +399,20 @@ class FinderTest < ActiveRecordTestCase
 
     def test_paginating_finder_doesnt_mangle_options
       Developer.expects(:find).returns([])
-      options = { :page => 1 }
-      options.expects(:delete).never
+      options = { :page => 1, :per_page => 2, :foo => 'bar' }
       options_before = options.dup
       
       Developer.paginate(options)
-      assert_equal options, options_before
+      assert_equal options_before, options
+    end
+    
+    def test_paginate_by_sql_doesnt_change_original_query
+      query = 'SQL QUERY'
+      original_query = query.dup
+      Developer.expects(:find_by_sql).returns([])
+      
+      Developer.paginate_by_sql query, :page => 1
+      assert_equal original_query, query
     end
 
     def test_paginated_each
@@ -412,5 +429,45 @@ class FinderTest < ActiveRecordTestCase
       
       assert_equal 14, Developer.paginated_each(:page => '2') { }
     end
+
+    def test_paginated_each_with_named_scope
+      assert_equal 2, Developer.poor.paginated_each(:per_page => 1) {
+        assert_equal 11, Developer.count
+      }
+    end
+
+    # detect ActiveRecord 2.1
+    if ActiveRecord::Base.private_methods.include_method?(:references_eager_loaded_tables?)
+      def test_removes_irrelevant_includes_in_count
+        Developer.expects(:find).returns([1])
+        Developer.expects(:count).with({}).returns(0)
+
+        Developer.paginate :page => 1, :per_page => 1, :include => :projects
+      end
+
+      def test_doesnt_remove_referenced_includes_in_count
+        Developer.expects(:find).returns([1])
+        Developer.expects(:count).with({ :include => :projects, :conditions => 'projects.id > 2' }).returns(0)
+
+        Developer.paginate :page => 1, :per_page => 1,
+          :include => :projects, :conditions => 'projects.id > 2'
+      end
+    end
+    
+    def test_paginate_from
+      result = Developer.paginate(:from => 'users', :page => 1, :per_page => 1)
+      assert_equal 1, result.size
+    end
+    
+    def test_hmt_with_include
+      # ticket #220
+      reply = projects(:active_record).replies.find(:first, :order => 'replies.id')
+      assert_equal replies(:decisive), reply
+      
+      # ticket #223
+      Project.find(1, :include => :replies)
+      
+      # I cannot reproduce any of the failures from those reports :(
+    end
   end
 end

data/test/fixtures/developer.rb

@@ -7,6 +7,7 @@ class Developer < User
     end
   end
 
+  named_scope :distinct, :select => 'DISTINCT `users`.*'
   named_scope :poor, :conditions => ['salary <= ?', 80000], :order => 'salary'
 
   def self.per_page() 10 end

data/test/fixtures/topic.rb

@@ -3,4 +3,8 @@ class Topic < ActiveRecord::Base
   belongs_to :project
 
   named_scope :mentions_activerecord, :conditions => ['topics.title LIKE ?', '%ActiveRecord%']
+  
+  named_scope :with_replies_starting_with, lambda { |text|
+    { :conditions => "replies.content LIKE '#{text}%' ", :include  => :replies }
+  }
 end

data/test/helper.rb

@@ -29,7 +29,10 @@ end
 
 # Wrap tests that use Mocha and skip if unavailable.
 def uses_mocha(test_name)
-  require 'mocha' unless Object.const_defined?(:Mocha)
+  unless Object.const_defined?(:Mocha)
+    gem 'mocha', '>= 0.9.5'
+    require 'mocha'
+  end
 rescue LoadError => load_error
   $stderr.puts "Skipping #{test_name} tests. `gem install mocha` and try again."
 else

data/test/lib/activerecord_test_case.rb

@@ -1,6 +1,13 @@
 require 'lib/activerecord_test_connector'
 
 class ActiveRecordTestCase < Test::Unit::TestCase
+  if defined?(ActiveSupport::Testing::SetupAndTeardown)
+    include ActiveSupport::Testing::SetupAndTeardown
+  end
+
+  if defined?(ActiveRecord::TestFixtures)
+    include ActiveRecord::TestFixtures
+  end
   # Set our fixture path
   if ActiveRecordTestConnector.able_to_connect
     self.fixture_path = File.join(File.dirname(__FILE__), '..', 'fixtures')

data/test/lib/activerecord_test_connector.rb

@@ -16,16 +16,20 @@ class ActiveRecordTestConnector
     unless self.connected || !self.able_to_connect
       setup_connection
       load_schema
-      Dependencies.load_paths.unshift FIXTURES_PATH
+      add_load_path FIXTURES_PATH
       self.connected = true
     end
   rescue Exception => e  # errors from ActiveRecord setup
-    $stderr.puts "\nSkipping ActiveRecord tests: #{e}"
-    $stderr.puts "Install SQLite3 to run the full test suite for will_paginate.\n\n"
+    $stderr.puts "\nSkipping ActiveRecord tests: #{e}\n\n"
     self.able_to_connect = false
   end
 
   private
+  
+  def self.add_load_path(path)
+    dep = defined?(ActiveSupport::Dependencies) ? ActiveSupport::Dependencies : ::Dependencies
+    dep.load_paths.unshift path
+  end
 
   def self.setup_connection
     db = ENV['DB'].blank?? 'sqlite3' : ENV['DB']
@@ -37,6 +41,8 @@ class ActiveRecordTestConnector
     ActiveRecord::Base.logger = Logger.new(STDOUT) if $0 == 'irb'
     puts "using #{configuration['adapter']} adapter" unless ENV['DB'].blank?
     
+    gem 'sqlite3-ruby' if 'sqlite3' == db
+    
     ActiveRecord::Base.establish_connection(configuration)
     ActiveRecord::Base.configurations = { db => configuration }
     prepare ActiveRecord::Base.connection

data/test/lib/view_test_process.rb

@@ -1,3 +1,4 @@
+require 'will_paginate/core_ext'
 require 'action_controller'
 require 'action_controller/test_process'
 
@@ -6,11 +7,112 @@ WillPaginate.enable_actionpack
 
 ActionController::Routing::Routes.draw do |map|
   map.connect 'dummy/page/:page', :controller => 'dummy'
+  map.connect 'dummy/dots/page.:page', :controller => 'dummy', :action => 'dots'
+  map.connect 'ibocorp/:page', :controller => 'ibocorp',
+                               :requirements => { :page => /\d+/ },
+                               :defaults => { :page => 1 }
+                               
   map.connect ':controller/:action/:id'
 end
 
 ActionController::Base.perform_caching = false
 
+class WillPaginate::ViewTestCase < Test::Unit::TestCase
+  if defined?(ActionController::TestCase::Assertions)
+    include ActionController::TestCase::Assertions
+  end
+  if defined?(ActiveSupport::Testing::Deprecation)
+    include ActiveSupport::Testing::Deprecation
+  end
+
+  def setup
+    super
+    @controller  = DummyController.new
+    @request     = @controller.request
+    @html_result = nil
+    @template    = '<%= will_paginate collection, options %>'
+    
+    @view = ActionView::Base.new
+    @view.assigns['controller'] = @controller
+    @view.assigns['_request']   = @request
+    @view.assigns['_params']    = @request.params
+  end
+
+  def test_no_complain; end
+  
+  protected
+
+    def paginate(collection = {}, options = {}, &block)
+      if collection.instance_of? Hash
+        page_options = { :page => 1, :total_entries => 11, :per_page => 4 }.merge(collection)
+        collection = [1].paginate(page_options)
+      end
+
+      locals = { :collection => collection, :options => options }
+
+      unless @view.respond_to? :render_template
+        # Rails 2.2
+        @html_result = ActionView::InlineTemplate.new(@template).render(@view, locals)
+      else
+        if defined? ActionView::InlineTemplate
+          # Rails 2.1
+          args = [ ActionView::InlineTemplate.new(@view, @template, locals) ]
+        else
+          # older Rails versions
+          args = [nil, @template, nil, locals]
+        end
+
+        @html_result = @view.render_template(*args)
+      end
+      
+      @html_document = HTML::Document.new(@html_result, true, false)
+
+      if block_given?
+        classname = options[:class] || WillPaginate::ViewHelpers.pagination_options[:class]
+        assert_select("div.#{classname}", 1, 'no main DIV', &block)
+      end
+    end
+
+    def response_from_page_or_rjs
+      @html_document.root
+    end
+
+    def validate_page_numbers expected, links, param_name = :page
+      param_pattern = /\W#{CGI.escape(param_name.to_s)}=([^&]*)/
+      
+      assert_equal(expected, links.map { |e|
+        e['href'] =~ param_pattern
+        $1 ? $1.to_i : $1
+      })
+    end
+
+    def assert_links_match pattern, links = nil, numbers = nil
+      links ||= assert_select 'div.pagination a[href]' do |elements|
+        elements
+      end
+
+      pages = [] if numbers
+      
+      links.each do |el|
+        assert_match pattern, el['href']
+        if numbers
+          el['href'] =~ pattern
+          pages << ($1.nil?? nil : $1.to_i)
+        end
+      end
+
+      assert_equal numbers, pages, "page numbers don't match" if numbers
+    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
+
 class DummyRequest
   attr_accessor :symbolized_path_parameters
   
@@ -46,6 +148,10 @@ class DummyController
     @request = DummyRequest.new
     @url = ActionController::UrlRewriter.new(@request, @request.params)
   end
+
+  def params
+    @request.params
+  end
   
   def url_for(params)
     @url.rewrite(params)

data/test/tasks.rake

@@ -0,0 +1,59 @@
+require 'rake/testtask'
+
+desc 'Test the will_paginate plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+  t.libs << 'test'
+end
+
+# I want to specify environment variables at call time
+class EnvTestTask < Rake::TestTask
+  attr_accessor :env
+
+  def ruby(*args)
+    env.each { |key, value| ENV[key] = value } if env
+    super
+    env.keys.each { |key| ENV.delete key } if env
+  end
+end
+
+for configuration in %w( sqlite3 mysql postgres )
+  EnvTestTask.new("test_#{configuration}") do |t|
+    t.pattern = 'test/finder_test.rb'
+    t.verbose = true
+    t.env = { 'DB' => configuration }
+    t.libs << 'test'
+  end
+end
+
+task :test_databases => %w(test_mysql test_sqlite3 test_postgres)
+
+desc %{Test everything on SQLite3, MySQL and PostgreSQL}
+task :test_full => %w(test test_mysql test_postgres)
+
+desc %{Test everything with Rails 2.1.x, 2.0.x & 1.2.x gems}
+task :test_all do
+  all = Rake::Task['test_full']
+  versions = %w(2.3.2 2.2.2 2.1.0 2.0.4 1.2.6)
+  versions.each do |version|
+    ENV['RAILS_VERSION'] = "~> #{version}"
+    all.invoke
+    reset_invoked unless version == versions.last
+  end
+end
+
+def reset_invoked
+  %w( test_full test test_mysql test_postgres ).each do |name|
+    Rake::Task[name].instance_variable_set '@already_invoked', false
+  end
+end
+
+task :rcov do
+  excludes = %w( lib/will_paginate/named_scope*
+                 lib/will_paginate/core_ext.rb
+                 lib/will_paginate.rb
+                 rails* )
+  
+  system %[rcov -Itest:lib test/*.rb -x #{excludes.join(',')}]
+end

data/test/view_test.rb

@@ -1,22 +1,19 @@
 require 'helper'
-require 'action_controller'
 require 'lib/view_test_process'
 
-class ViewTest < Test::Unit::TestCase
-  
-  def setup
-    super
-    @controller  = DummyController.new
-    @request     = @controller.request
-    @html_result = nil
-    @template    = '<%= will_paginate collection, options %>'
-    
-    @view = ActionView::Base.new
-    @view.assigns['controller'] = @controller
-    @view.assigns['_request']   = @request
-    @view.assigns['_params']    = @request.params
+class AdditionalLinkAttributesRenderer < WillPaginate::LinkRenderer
+  def initialize(link_attributes = nil)
+    super()
+    @additional_link_attributes = link_attributes || { :default => 'true' }
   end
 
+  def page_link(page, text, attributes = {})
+    @template.link_to text, url_for(page), attributes.merge(@additional_link_attributes)
+  end
+end
+
+class ViewTest < WillPaginate::ViewTestCase
+  
   ## basic pagination ##
 
   def test_will_paginate
@@ -39,7 +36,7 @@ class ViewTest < Test::Unit::TestCase
 
   def test_will_paginate_with_options
     paginate({ :page => 2 },
-             :class => 'will_paginate', :prev_label => 'Prev', :next_label => 'Next') do
+             :class => 'will_paginate', :previous_label => 'Prev', :next_label => 'Next') do
       assert_select 'a[href]', 4 do |elements|
         validate_page_numbers [1,1,3,3], elements
         # test rel attribute values:
@@ -57,12 +54,40 @@ class ViewTest < Test::Unit::TestCase
     end
   end
 
+  def test_will_paginate_using_renderer_class
+    paginate({}, :renderer => AdditionalLinkAttributesRenderer) do
+      assert_select 'a[default=true]', 3
+    end
+  end
+
+  def test_will_paginate_using_renderer_instance
+    renderer = WillPaginate::LinkRenderer.new
+    renderer.gap_marker = '<span class="my-gap">~~</span>'
+    
+    paginate({ :per_page => 2 }, :inner_window => 0, :outer_window => 0, :renderer => renderer) do
+      assert_select 'span.my-gap', '~~'
+    end
+    
+    renderer = AdditionalLinkAttributesRenderer.new(:title => 'rendered')
+    paginate({}, :renderer => renderer) do
+      assert_select 'a[title=rendered]', 3
+    end
+  end
+
   def test_prev_next_links_have_classnames
     paginate do |pagination|
       assert_select 'span.disabled.prev_page:first-child'
       assert_select 'a.next_page[href]:last-child'
     end
   end
+  
+  def test_prev_label_deprecated
+    assert_deprecated ':previous_label' do
+      paginate({ :page => 2 }, :prev_label => 'Deprecated') do
+        assert_select 'a[href]:first-child', 'Deprecated'
+      end
+    end
+  end
 
   def test_full_output
     paginate
@@ -78,6 +103,16 @@ class ViewTest < Test::Unit::TestCase
     assert_dom_equal expected, @html_result
   end
 
+  def test_escaping_of_urls
+    paginate({:page => 1, :per_page => 1, :total_entries => 2},
+             :page_links => false, :params => { :tag => '<br>' })
+    
+    assert_select 'a[href]', 1 do |links|
+      query = links.first['href'].split('?', 2)[1]
+      assert_equal %w(page=2 tag=%3Cbr%3E), query.split('&amp;').sort
+    end
+  end
+
   ## advanced options for pagination ##
 
   def test_will_paginate_without_container
@@ -149,27 +184,56 @@ class ViewTest < Test::Unit::TestCase
     array = ('a'..'z').to_a
     
     paginate array.paginate(:page => 2, :per_page => 5)
-    assert_equal %{Displaying entries <b>6&nbsp;-&nbsp;10</b> of <b>26</b> in total},
+    assert_equal %{Displaying strings <b>6&nbsp;-&nbsp;10</b> of <b>26</b> in total},
       @html_result
     
     paginate array.paginate(:page => 7, :per_page => 4)
-    assert_equal %{Displaying entries <b>25&nbsp;-&nbsp;26</b> of <b>26</b> in total},
+    assert_equal %{Displaying strings <b>25&nbsp;-&nbsp;26</b> of <b>26</b> in total},
       @html_result
   end
 
+  uses_mocha 'class name' do
+    def test_page_entries_info_with_longer_class_name
+      @template = '<%= page_entries_info collection %>'
+      collection = ('a'..'z').to_a.paginate
+      collection.first.stubs(:class).returns(mock('class', :name => 'ProjectType'))
+    
+      paginate collection
+      assert @html_result.index('project types'), "expected <#{@html_result.inspect}> to mention 'project types'"
+    end
+  end
+
   def test_page_entries_info_with_single_page_collection
     @template = '<%= page_entries_info collection %>'
     
     paginate(('a'..'d').to_a.paginate(:page => 1, :per_page => 5))
-    assert_equal %{Displaying <b>all 4</b> entries}, @html_result
+    assert_equal %{Displaying <b>all 4</b> strings}, @html_result
     
     paginate(['a'].paginate(:page => 1, :per_page => 5))
-    assert_equal %{Displaying <b>1</b> entry}, @html_result
+    assert_equal %{Displaying <b>1</b> string}, @html_result
     
     paginate([].paginate(:page => 1, :per_page => 5))
     assert_equal %{No entries found}, @html_result
   end
   
+  def test_page_entries_info_with_custom_entry_name
+    @template = '<%= page_entries_info collection, :entry_name => "author" %>'
+    
+    entries = (1..20).to_a
+    
+    paginate(entries.paginate(:page => 1, :per_page => 5))
+    assert_equal %{Displaying authors <b>1&nbsp;-&nbsp;5</b> of <b>20</b> in total}, @html_result
+    
+    paginate(entries.paginate(:page => 1, :per_page => 20))
+    assert_equal %{Displaying <b>all 20</b> authors}, @html_result
+    
+    paginate(['a'].paginate(:page => 1, :per_page => 5))
+    assert_equal %{Displaying <b>1</b> author}, @html_result
+    
+    paginate([].paginate(:page => 1, :per_page => 5))
+    assert_equal %{No authors found}, @html_result
+  end
+  
   ## parameter handling in page links ##
   
   def test_will_paginate_preserves_parameters_on_get
@@ -190,6 +254,11 @@ class ViewTest < Test::Unit::TestCase
     assert_links_match /foo=bar/
   end
   
+  def test_adding_anchor_parameter
+    paginate({}, :params => { :anchor => 'anchor' })
+    assert_links_match /#anchor$/
+  end
+  
   def test_removing_arbitrary_parameters
     @request.params :foo => 'bar'
     paginate({}, :params => { :foo => nil })
@@ -208,6 +277,14 @@ class ViewTest < Test::Unit::TestCase
       end
     end    
   end
+
+  def test_will_paginate_with_atmark_url
+    @request.symbolized_path_parameters[:action] = "@tag"
+    renderer = WillPaginate::LinkRenderer.new
+    
+    paginate({ :page => 1 }, :renderer=>renderer)
+    assert_links_match %r[/foo/@tag\?page=\d]
+  end
   
   def test_complex_custom_page_param
     @request.params :developers => { :page => 2 }
@@ -229,6 +306,24 @@ class ViewTest < Test::Unit::TestCase
     end
   end
 
+  def test_custom_routing_page_param_with_dot_separator
+    @request.symbolized_path_parameters.update :controller => 'dummy', :action => 'dots'
+    paginate :per_page => 2 do
+      assert_select 'a[href]', 6 do |links|
+        assert_links_match %r{/page\.(\d+)$}, links, [2, 3, 4, 5, 6, 2]
+      end
+    end
+  end
+
+  def test_custom_routing_with_first_page_hidden
+    @request.symbolized_path_parameters.update :controller => 'ibocorp', :action => nil
+    paginate :page => 2, :per_page => 2 do
+      assert_select 'a[href]', 7 do |links|
+        assert_links_match %r{/ibocorp(?:/(\d+))?$}, links, [nil, nil, 3, 4, 5, 6, 3]
+      end
+    end
+  end
+
   ## internal hardcore stuff ##
 
   class LegacyCollection < WillPaginate::Collection
@@ -275,70 +370,4 @@ class ViewTest < Test::Unit::TestCase
     end
   end
   
-  
-  protected
-
-    def paginate(collection = {}, options = {}, &block)
-      if collection.instance_of? Hash
-        page_options = { :page => 1, :total_entries => 11, :per_page => 4 }.merge(collection)
-        collection = [1].paginate(page_options)
-      end
-
-      locals = { :collection => collection, :options => options }
-
-      if defined? ActionView::Template
-        # Rails 2.1
-        args = [ ActionView::Template.new(@view, @template, false, locals, true, nil) ]
-      else
-        # older Rails versions
-        args = [nil, @template, nil, locals]
-      end
-      
-      @html_result = @view.render_template(*args)
-      @html_document = HTML::Document.new(@html_result, true, false)
-
-      if block_given?
-        classname = options[:class] || WillPaginate::ViewHelpers.pagination_options[:class]
-        assert_select("div.#{classname}", 1, 'no main DIV', &block)
-      end
-    end
-
-    def response_from_page_or_rjs
-      @html_document.root
-    end
-
-    def validate_page_numbers expected, links, param_name = :page
-      param_pattern = /\W#{CGI.escape(param_name.to_s)}=([^&]*)/
-      
-      assert_equal(expected, links.map { |e|
-        e['href'] =~ param_pattern
-        $1 ? $1.to_i : $1
-      })
-    end
-
-    def assert_links_match pattern, links = nil, numbers = nil
-      links ||= assert_select 'div.pagination a[href]' do |elements|
-        elements
-      end
-
-      pages = [] if numbers
-      
-      links.each do |el|
-        assert_match pattern, el['href']
-        if numbers
-          el['href'] =~ pattern
-          pages << $1.to_i
-        end
-      end
-
-      assert_equal pages, numbers, "page numbers don't match" if numbers
-    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