spree 0.6.0 → 0.7.0

data/lib/plugins/paginating_find/test_app/test/unit/abstract_test.rb

@@ -1,7 +0,0 @@
-
-$:.unshift(File.dirname(__FILE__) + '/../../../lib')
-require 'paginating_find'
-require File.dirname(__FILE__) + '/../test_helper'
-require File.join(File.dirname(__FILE__), '/../fixtures/models')
-load(File.dirname(__FILE__) + "/../../db/schema.rb")
-load(File.dirname(__FILE__) + "/../../../init.rb")

data/lib/plugins/paginating_find/test_app/test/unit/group_test.rb

@@ -1,40 +0,0 @@
-require File.dirname(__FILE__) + '/abstract_test.rb'
-
-class GroupTest < Test::Unit::TestCase
-  def test_should_paginate_with_group
-    one = Article.create(:name => "one", :author_id => 1)
-    two = Article.create(:name => "two", :author_id => 1)
-    three = Article.create(:name => "three", :author_id => 1)
-    four = Article.create(:name => "four", :author_id => 2)
-    results = Article.find(:all, :group => "author_id", :page => {:size => 2})
-    assert_equal 2, results.size
-    assert results.to_a.include?(one)
-    assert !results.to_a.include?(two)
-    assert !results.to_a.include?(three)
-    assert results.to_a.include?(four)
-    assert_equal 1, results.page_count
-    assert_equal 2, results.page_size
-  end
-  
-  def test_should_paginate_with_group_and_order
-    one = Article.create(:name => "one", :author_id => 1)
-    two = Article.create(:name => "two", :author_id => 1)
-    three = Article.create(:name => "three", :author_id => 1)
-    four = Article.create(:name => "four", :author_id => 2)
-    results = Article.find(:all, :group => "author_id", :order => "name DESC", :page => {:size => 2})
-    assert_equal 2, results.size
-    assert_equal 1, results.page_count
-    assert_equal 2, results.page_size
-  end
-  
-  def test_should_work_with_having_tacked_onto_group
-    one = Article.create(:name => "one", :author_id => 1)
-    two = Article.create(:name => "two", :author_id => 1)
-    three = Article.create(:name => "three", :author_id => 1)
-    four = Article.create(:name => "four", :author_id => 2)
-    results = Article.find(:all, :group => "author_id HAVING author_id=1", :order => "name DESC", :page => {:size => 2})
-    assert_equal 1, results.size
-    assert_equal 1, results.page_count
-    assert_equal 2, results.page_size
-  end
-end

data/lib/plugins/paginating_find/test_app/test/unit/paginating_find_test.rb

@@ -1,194 +0,0 @@
-require File.dirname(__FILE__) + '/abstract_test.rb'
-
-class PaginatingFindTest < Test::Unit::TestCase
-  fixtures :authors, :edits, :articles
-  
-  def test_should_not_bonk_on_marshal_dump
-    results = Article.find(:all, :page => {:size => 2})
-    Marshal.dump(results)
-  end
-  
-  def test_should_preserve_enumerator_stats_on_marshal_load
-    results = Article.find(:all, :page => {:size => 2})
-    loaded = Marshal.load(Marshal.dump(results))
-    assert_equal 2, loaded.page_size
-    assert_equal Article.count, loaded.size
-  end
-  
-  def test_should_auto_paginate
-    h = ArticleHelper.new(112)
-    h.find_articles(:all, :page => {:size => 10, :auto => true}) do |results|
-      results.each {} # enumerate all 112 results
-      assert_equal results.page_count, results.stop_page
-      assert_equal results.page_count, results.page
-    end
-  end
-  
-  def test_should_paginate
-    h = ArticleHelper.new(112)
-    h.find_articles(:all, :page => {:size => 10}) do |results|
-      results.each {} # enumerate first 10 results
-      results.next_page! # move to next page
-      results.page = 2
-      results.each {} # enumerate next 10 results
-    end
-  end
-  
-  def test_should_not_paginate
-    results = Article.find(:all)
-    assert !results.respond_to?(:page_count)
-    assert !results.respond_to?(:page_size)
-  end
-  
-  def test_should_paginate_with_conditions
-    h = ArticleHelper.new(20)
-    h.find_articles(:all, :conditions => "name = 1", :order => "name ASC", :page => {:size => 10}) do |results|
-      assert_equal 10, results.page_size
-      assert_equal 1, results.size
-      results.each {} 
-      assert_equal 1, results.page
-      end
-  end
-  
-  def test_should_respect_limit
-    h = ArticleHelper.new(80, 52)
-    h.find_articles(:all, :limit => 52, :page => {:size => 10}) do |results|
-      assert_equal 52, results.size
-      assert_equal 10, results.page_size
-    end
-  end
-  
-  def test_should_not_query_for_count
-    h = ArticleHelper.new(80, 50)
-    h.find_articles(:all, :page => {:size => 10, :count => 50}) do |results|
-      assert_equal 50, results.size
-      assert_equal 10, results.page_size
-    end
-  end
-  
-  def test_should_use_limit_instead_of_count
-    h = ArticleHelper.new(80, 41)
-    h.find_articles(:all, :limit => 41, :page => {:size => 10, :count => 50}) do |results|
-      assert_equal 41, results.size
-      assert_equal 10, results.page_size
-    end
-  end
-  
-  def test_should_use_count_instead_of_limit
-    h = ArticleHelper.new(80, 41)
-    h.find_articles(:all, :limit => 50, :page => {:size => 10, :count => 41}) do |results|
-      assert_equal 41, results.size
-      assert_equal 10, results.page_size
-    end
-  end
-  
-  def test_should_respect_include
-    results = Article.find(:all, 
-                           :conditions => ["authors.id = ?", authors(:alex).id],
-                           :include => [:author],
-                           :page => {:size => 10})
-    assert_equal 1, results.size
-    assert_equal 10, results.page_size
-    assert_equal authors(:alex), results.to_a.first.author
-  end
-  
-  def test_should_correctly_count_through_associations
-    editors = articles(:testing).editors.find(:all,
-                                              :page => {:size => 20,
-                                                        :first => 1,
-                                                        :current => 1 })
-    assert_equal 20, editors.page_size
-    assert_equal articles(:testing).editors.count, editors.size  
-    assert_equal articles(:testing).editors.count, editors.to_a.size                    
-  end
-  
-  def test_should_respect_scope
-    Article.find_with_scope({ :conditions => "name = 1" }) do
-      h = ArticleHelper.new(20)
-      h.find_articles(:all, :page => {:size => 10}) do |results|
-        assert_equal 1, results.size
-        assert_equal 1, results.to_a.size
-        assert_equal 10, results.page_size
-      end
-    end
-  end
-  
-  def test_should_respect_scope_with_include
-    h = ArticleHelper.new(20)
-    Article.find_with_scope({:conditions => "articles.name >= 1 and articles.name <= 3" }) do
-      h.find_articles(:all, :include => [:author, :edits], :page => {:size => 10, :current => 1, :first => 1}, :order => "articles.name ASC") do |results|
-        assert_equal 3, results.size
-        assert_equal 3, results.to_a.size
-        assert_equal 10, results.page_size
-      end
-    end
-  end
-  
-  def test_should_respect_nested_scope
-    h = ArticleHelper.new(20)
-    Article.find_with_scope({ :conditions => "name = 1" }) do
-      Article.find_with_scope({ :conditions => "name = 2" }) do
-        h.find_articles(:all, :page => {:size => 10}) do |results|
-          assert_equal 0, results.size
-          assert_equal 0, results.to_a.size
-          assert_equal 10, results.page_size
-        end
-      end  
-    end
-  end
-  
-  # =)
-  def test_should_respect_out_of_scope_scope
-    results = nil
-    (1..20).each { |n| Article.create(:name => n, :author_id => 1) }
-    Article.find_with_scope({ :conditions => "name >= 1 and name <= 15" }) do
-      results = Article.find(:all, :page => {:size => 10, :auto => true})
-    end
-    assert_equal 10, results.page_size
-    assert_equal 15, results.size
-    assert_equal 15, results.to_a.size
-  end
-  
-  def test_should_respect_out_of_scope_scope_with_include
-    results = nil
-    (1..20).each { |n| Article.create(:name => n, :author_id => 1) }
-    Article.find_with_scope({ :conditions => "articles.name >= 1 and articles.name <= 15 and authors.id = 1", :include => [:author, :edits]}) do
-      results = Article.find(:all, :page => {:size => 10, :auto => true})
-    end
-    assert_equal 10, results.page_size
-    assert_equal 15, results.size
-    assert_equal 15, results.to_a.size
-  end
-  
-end
-
-class ArticleHelper
-  def initialize(how_many, limit=nil)
-    @how_many = how_many
-    @limit=limit
-  end
-  
-  # Create n number of articles, and query them using the specified
-  # arguments. Check that the correct number of pages were returned
-  # and yield the results.
-  #
-  def find_articles(*args)
-    (1..@how_many).each { |n| Article.create(:name => n, :author_id => 1) }
-    results = Article.find(*args)
-    if results.size > results.page_size
-      page_count, num_on_last_page = how_many.divmod(results.page_size)
-      page_count = page_count + 1 if num_on_last_page > 0
-    else 
-      page_count = 1
-    end
-    if (page_count != results.page_count)
-      raise "Expected #{page_count} pages but there were #{results.page_count}"
-    end  
-    yield results if block_given? 
-    results
-  end
-  
-  def how_many
-    @limit ? @limit : @how_many
-  end
-end

data/lib/plugins/paginating_find/test_app/test/unit/paging_enumerator_test.rb

@@ -1,143 +0,0 @@
-require File.dirname(__FILE__) + '/abstract_test.rb'
-require 'paging_enumerator'
-
-class PagingEnumeratorTest < Test::Unit::TestCase
-  
-  def test_should_count_pages_correctly
-    assert_equal 4, enum(page_size, total_size).page_count
-  end
-  
-  def test_should_page
-    assert_equal(
-      (1..total_size).to_a, 
-      iterate(enum(page_size, total_size, true)) # iterate enum
-    )
-  end
-  
-  def test_should_page_manually
-    assert_equal(
-      (1..page_size).to_a, 
-      iterate(enum(page_size, total_size)) # iterate manual_paging enum
-    )
-  end
-  
-  def test_should_move_to_next_page
-    enum = enum(page_size, total_size)
-
-    # Iterate the enumeration and inspect the results
-    # and manually move to the next page
-    iterate(enum)
-    enum.next_page!
-
-    # Iterate the next page and verify that the enum
-    # returned the results from the next page
-    assert_equal(
-      ((page_size + 1)..(page_size * 2)).to_a, 
-      iterate(enum)
-    )
-   end
-  
-  def test_should_not_move_to_next_page
-    enum = enum(page_size, total_size)
-    
-    # Iterate the enumeration and inspect the results
-    assert_equal (1..page_size).to_a, iterate(enum)
-    
-    # Verify that we are able to iterate the same page twice in a row
-    assert_equal (1..page_size).to_a, iterate(enum)
-  end
-  
-  def test_should_move_to_last_page
-    enum = enum(page_size, total_size)
-
-    # Iterate the enumeration and inspect the results
-    # then manually move to the last page
-    iterate(enum)
-    enum.last_page!
-
-    assert_equal([10], iterate(enum))
-   end
-  
-  def test_should_move
-    enum = enum(page_size, total_size)
-    assert_equal(1, enum.page)
-    enum.move!(2)
-    assert_equal(2, enum.page)
-    assert_equal(1, enum.first_page)
-    start_val = (page_size - 1) * 2
-    end_val = (page_size - 1) * 3
-    assert_equal (start_val..end_val).to_a, iterate(enum)
-  end
-  
-  def test_move_should_respect_upper_boundary
-    enum = enum(page_size, total_size)
-    assert_equal(1, enum.page)
-    enum.move!(100) # try moving to really high page
-    assert_equal(enum.last_page, enum.page)
-  end
-  
-  def test_move_should_respect_lower_boundary
-    enum = enum(page_size, total_size)
-    assert_equal(1, enum.page)
-    enum.move!(-100) # try moving to low page
-    assert_equal(enum.first_page, enum.page)
-  end
-  
-  def test_should_raise_on_move
-    enum = enum(page_size, total_size, true)
-    assert_equal(1, enum.page)
-    assert_raises(ArgumentError) { enum.move!(2) }
-  end
-  
-  def test_next_page_should_respect_upper_boundar
-    enum = enum(page_size, total_size)
-    enum.last_page!
-    assert_equal enum.last_page, enum.page
-    enum.next_page!
-    assert_equal enum.last_page, enum.page
-  end
-  
-  def test_previous_page_should_respect_upper_boundar
-    enum = enum(page_size, total_size)
-    enum.first_page!
-    assert_equal enum.first_page, enum.page
-    enum.previous_page!
-    assert_equal enum.first_page, enum.page
-  end
-  
-  def test_should_handle_zero_page_size
-    enum(0, 1).each {}
-  end
-  
-  def iterate(enum)
-    results = []
-    first_page = enum.first_page
-    enum.each do |e|
-      # Verify that the enum.first_page does not change as we iterate
-      assert_equal(first_page, enum.first_page)
-      # Verify that the enum.page is correct for the current enum value 
-      assert_equal(((e - 1) / enum.page_size) + 1, enum.page)
-      results << e 
-    end
-    results
-  end
-  
-  # Build the PagingEnumerable with a certain page size and
-  # total number of elements. Set up a callback that pages
-  # integers in range 1..total_size. 
-  def enum(page_size, total_size, auto = nil)
-    PagingEnumerator.new(page_size, total_size, auto) do |page|
-      lower = page == 1 ? 0 : (page - 1) * page_size
-      upper = lower + page_size - 1
-      (1..total_size).to_a[lower..upper]
-    end
-  end
-  
-  def page_size
-    3
-  end
-  
-  def total_size
-    10
-  end
-end

data/spec/views/products/index.html.erb_spec.rb

@@ -1,46 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe '/products/index' do
-  before(:each) do
-    @product = mock_model(Product)
-    template.stub!(:small_image)
-    template.stub!(:breadcrumbs).and_return("")
-    @product.stub!(:master_price)
-    @product.stub!(:name).and_return('Delicious Cows')
-    @product.stub!(:has_stock?).and_return(true)
-    assigns[:products] = [@product]
-
-    # TODO: put these pagination stubs into a helper?
-    assigns[:products].stub!(:page_count).and_return(1)
-    assigns[:products].stub!(:first_page).and_return(true)
-    assigns[:products].stub!(:previous_page?).and_return(false)
-    assigns[:products].stub!(:next_page?).and_return(false)
-    template.stub!(:windowed_pagination_links).and_return(false)
-    template.stub_render(:partial => 'shared/taxonomies')
-  end
-
-  it "should display items in stock" do
-    render '/products/index'
-    response.should have_tag('a[href=?]', product_path(@product), /#{@product.name}/)
-  end
-
-  describe 'with out-of-stock items' do
-    before(:each) do
-      @product.stub!(:has_stock?).and_return(false)
-    end
-
-    it "should not display if show_zero_stock_products is not set" do
-      Spree::Config.stub!(:[]).with(:show_zero_stock_products).and_return(false)
-      render '/products/index'
-      response.should_not have_tag('a[href=?]', product_path(@product), /#{@product.name}/)
-    end
-
-    it "should display if show_zero_stock_products is set" do
-      Spree::Config.stub!(:[]).with(:show_zero_stock_products).and_return(true)
-      render '/products/index'
-      response.should have_tag('a[href=?]', product_path(@product), /#{@product.name}/)
-    end
-
-  end
-end
-

data/spec/views/products/show.html.erb_spec.rb

@@ -1,46 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-
-describe '/product/show' do
-  before(:each) do
-    template.stub!(:product_image)
-    @product = Product.new(:name => 'Delicious Cows', :permalink => 'delicious-cows',
-                           :description => 'Cows are delicious!', :master_price => 45.00,
-                           :variants => [Variant.new]
-    )
-    @product.stub!(:images).and_return(mock(Image, :size => 1))
-    assigns[:product] = @product
-  end
-
-  it "should display the item" do
-    render '/products/show'
-    response.should have_tag('td[class=?]', 'product-name', /#{@product.name}/)
-  end
-
-  describe 'with out-of-stock items' do
-    before(:each) do
-      @product.stub!(:has_stock?).and_return(false)
-    end
-
-    it "should not display product if allow_backorders is not set" do
-      Spree::Config.stub!(:[]).with(:allow_backorders).and_return(false)
-      render '/products/show'
-      response.should have_tag('strong', /Out of Stock/)
-      response.should_not have_tag('input[type=?]', 'submit')
-    end
-
-    it "should display product if allow_backorders is set" do
-      Spree::Config.stub!(:[]).with(:allow_backorders).and_return(true)
-      render '/products/show'
-      response.should_not have_tag('strong', /Out of Stock/)
-      response.should have_tag('input[type=?]', 'submit')
-    end
-  end
-
-  # NOTE: the behavior of variants is largely described thru the variant_options
-  #       helper method in app/helpers/spree/base_helpers.rb.  For that reason,
-  #       the variant testing lives there
-
-end
-
-