spree 0.11.4 → 0.30.0.beta1

data/test/shoulda_macros/should_redirect.rb

@@ -1,15 +0,0 @@
-class ActiveSupport::TestCase
-  def self.should_redirect_to_thanks
-    should_redirect_to("thank you page") { order_url(@order) }
-  end
-  def self.should_redirect_to_register
-    should_redirect_to("registration") { register_order_checkout_url(@order) }
-  end
-  def self.should_redirect_to_first_step
-    should_redirect_to("first step of checkout") { edit_order_checkout_url(@order) }
-  end
-  def self.should_redirect_to_authorization_failure
-    should_redirect_to("login") { "/user_sessions/authorization_failure" }
-  end
-end
-

data/test/test_helper.rb

@@ -1,139 +0,0 @@
-require 'rubygems'
-require 'spork'
-
-Spork.prefork do
-  # Loading more in this block will cause your tests to run faster. However,
-  # if you change any configuration or code from libraries loaded here, you'll
-  # need to restart spork for it take effect.
-
-  ENV["RAILS_ENV"] = "test"
-  require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
-  require 'test_help'
-  require "authlogic/test_case"
-  require File.expand_path(File.dirname(__FILE__) + "/../vendor/extensions/payment_gateway/test/mocks/authorize_net_cim_mock")
-
-  # BENCHMARK=[true|full] to use test_benchmark
-  require 'test_benchmark' if ENV["BENCHMARK"]
-
-  class ActiveSupport::TestCase
-    self.use_transactional_fixtures = true
-    self.use_instantiated_fixtures  = false
-    fixtures :all
-  end
-
-  I18n.locale = "en"
-  Spree::Config.set(:default_country_id => Country.first.id) if Country.first
-
-  class ActionController::TestCase
-    setup :activate_authlogic
-  end
-
-  ActionController::TestCase.class_eval do
-    # special overload methods for "global"/nested params
-    [ :get, :post, :put, :delete ].each do |overloaded_method|
-      define_method overloaded_method do |*args|
-        action,params,extras = *args
-        super action, params || {}, *extras unless @params
-        super action, @params.merge( params || {} ), *extras if @params
-      end
-    end
-  end
-
-  def setup
-    super
-    @params = {}
-  end
-
-  class TestCouponCalc
-    def self.calculate_discount(checkout)
-      0.99
-    end
-  end
-
-  Zone.class_eval do
-    def self.global
-      find_by_name("GlobalZone") || Factory(:global_zone)
-    end
-  end
-
-  def create_complete_order
-    @zone = Zone.global
-    @order = Factory(:order)
-    3.times do
-      #variant = Factory(:product).variants.first
-      variant = Factory(:variant)
-      Factory(:line_item, :variant => variant, :order => @order)
-    end
-
-    @shipping_method = Factory(:shipping_method)
-    @checkout = @order.checkout
-    @checkout.email = Faker::Internet.email
-    @checkout.ship_address = Factory(:address)
-    @checkout.shipping_method = @shipping_method
-
-    @checkout.payments = [Factory(:payment, :amount => @order.total)]
-    @checkout.save
-
-    @shipment = @order.shipment
-
-    @checkout.bill_address = Factory(:address)
-
-    unless @zone.include?(@order.shipment.address)
-      ZoneMember.create(:zone => Zone.global, :zoneable => @checkout.ship_address.country)
-      @zone.reload
-    end
-
-    @checkout.save
-    @shipment.save
-    @order.save
-    @order.reload
-    @order.save
-    @order
-  end
-
-# Sets up an order with state 'new' with completed checkout and authorized payment
-  def create_new_order
-    create_complete_order
-    @checkout.next!
-    @checkout.next!
-    @checkout.creditcard_attributes = Factory.attributes_for(:creditcard)
-    @checkout.next!
-  end
-
-  def create_new_order_v2
-    create_complete_order
-    @checkout.payments = [Factory(:payment)]
-    @checkout.state = "complete"
-    @checkout.save
-    @order.complete!
-  end
-  
-  def create_paid_order
-    create_complete_order
-    @order.payments = [Factory(:payment, :amount => @order.total, :payable => @order)]
-    until @order.checkout.complete?
-      @order.checkout.next!
-    end
-    @order.payments.first.finalize!
-    @order.reload
-    @order.pay!
-  end
-
-# useful method for functional tests that require an authenticated user
-  def set_current_user
-    @user = Factory(:user)
-    @controller.stub!(:current_user, :return => @user)
-  end
-
-  def sort_list_hash(thing)
-    thing.map(&:sort).sort
-  end
-  def assert_equal_list_hash(alpha,beta)
-    assert_equal(sort_list_hash(alpha), sort_list_hash(beta))
-  end
-end
-
-Spork.each_run do
-  # This code will be run each time you run your specs.
-
-end

data/test/unit/address_test.rb

@@ -1,59 +0,0 @@
-require 'test_helper'
-Fixtures.create_fixtures("test/fixtures", %w(countries states))
-
-class AddressTest < ActiveSupport::TestCase
-  context Address do
-    should_validate_presence_of :firstname, :lastname, :address1,
-      :city, :zipcode, :country, :phone
-    # this validation disabled for now
-    # should_not_allow_values_for :phone, "abcd", "1234"
-
-    context "create from factory" do
-      setup { Factory :address }
-      should_change("Address.count", :by => 1) { Address.count }
-    end
-
-    context "in USA" do
-      setup do
-        @address = Factory(:address)
-        @address.country = Country.find_by_iso_name('US')
-        @address.state = nil
-      end
-      should("be valid if state_name is US state") do
-        @address.state_name = Faker::Address.us_state
-        assert @address.valid?, "Address in USA should be valid for state #{@address.state_name}"
-      end
-      should("be valid if state_name is US state abbr") do
-        @address.state_name = @address.country.states.rand.abbr
-        assert @address.valid?, "Address in USA should be valid for state #{@address.state_name}"
-      end
-      should("be not valid if state_name is not US state") do
-        @address.state_name = Faker::Address.uk_country
-        assert !@address.valid?, "Address in USA should be not valid for state #{@address.state_name}"
-      end
-    end
-
-    context "instance" do
-      setup do
-        @address = Factory(:address)
-      end
-        
-      # these two properties now under control of checkout controller
-      # should "not be allowed to be changed when have checkout" do
-      # should "not be allowed to be changed when have shippment" do
-    end
-
-    context "clone" do
-      setup do
-        @address = Factory(:address)
-      end
-
-      should("be valid") { assert @address.clone.valid? }
-      ["country", "state"].each do |field|
-        should("have same #{field}") {
-          assert_equal(@address.clone.send(field), @address.send(field))
-        }
-      end
-    end
-  end
-end

data/test/unit/adjustment_test.rb

@@ -1,96 +0,0 @@
-require 'test_helper'
-
-class TestAdjustment < Adjustment
-  attr_accessor :applicable
-  attr_accessor :adjustment_amount
-
-  # true by default ;) I love tri-state logic
-  def applicable?
-    @applicable.nil? ? true : @applicable
-  end
-
-  def calculate_adjustment
-    @adjustment_amount || 10
-  end
-end
-
-class AdjustmentTest < ActiveSupport::TestCase
-  fixtures :payment_methods
-  
-  should_validate_presence_of :description
-
-  context "Adjustment with order" do
-    setup do
-      create_complete_order
-      TestAdjustment.create(:order => @order, :description => "TestAdjustment")
-      @adjustment = @order.reload.adjustments.select{|a| a.class==TestAdjustment}.first
-    end
-
-    context "with non integer amount" do
-      setup {@adjustment = @order.adjustments.create(:amount => 19.95, :description => "Test Charge")}
-      should "create adjument with the correct amount" do
-        assert_equal 19.95, @adjustment.amount
-      end
-    end
-
-    context "not completed" do
-      setup do
-        @order.completed_at = nil
-        assert(!@order.checkout_complete, 'Order was completed, adjustments are freezed')
-      end
-
-      should "find all types of charges" do
-        Charge.create(:order => @order, :description => "TestCharge")
-        ShippingCharge.create(:order => @order, :description => "TestCharge")
-        TestAdjustment.create(:order => @order, :description => "TestCharge")
-        assert_equal(4, @order.reload.charges.length) # 3 + default tax charge
-      end
-
-      should "find all types of adjustments" do
-        Charge.create(:order => @order, :description => "TestCharge")
-        ShippingCharge.create(:order => @order, :description => "TestCharge")
-        Adjustment.create(:order => @order, :description => "TestAdjustment")
-        assert_equal(6, @order.reload.adjustments.length) # default shipping charge, default tax charge, test adjustment + 3
-      end
-
-      should "remove adjustments if they are no longet applicable" do
-        @adjustment.applicable = false
-        @order.update_totals
-        assert_equal(["ShippingCharge", "TaxCharge"], @order.adjustments.map{|a| a.type}.sort)
-        assert_equal 2, @order.adjustments.length # tax charge nad shipping charge should still be there
-        assert_nil Adjustment.find_by_id(@adjustment.id)
-      end
-
-      should "not remove adjustments if they are applicable" do
-        @adjustment.applicable = true
-        @order.update_totals
-        assert_equal 3, @order.adjustments.length
-        assert Adjustment.find_by_id(@adjustment.id)
-      end
-    end
-    
-    context "with checkout finished" do
-      setup do
-         @order.completed_at = Time.now
-         @order.complete!
-      end
-
-      should "save amounts of all adjustments" do
-        assert @order.adjustments.reload.all{|a| a.read_attribute(:amount)}
-      end
-
-      should "not change amounts" do
-        @adjustment.adjustment_amount = 20
-        @order.update_totals
-        assert_equal 10, @order.adjustments.select{|a| a.class==TestAdjustment}.first.amount
-      end
-
-      should "not remove adjustments if they are no longet applicable" do
-        @adjustment.applicable = false
-        @order.update_totals
-        assert_equal(["ShippingCharge", "TaxCharge", "TestAdjustment"], @order.adjustments.map{|a| a.type}.sort)
-        assert_equal 3, @order.adjustments.length # tax charge nad shipping charge should still be there
-      end
-    end
-  end
-end

data/test/unit/charge_test.rb

@@ -1,114 +0,0 @@
-require 'test_helper'
-
-class TestCharge < Charge; end
-
-Charge.class_eval do
-  private
-  def self.subclasses
-    self == Charge ? [TaxCharge, ShippingCharge, TestCharge] : []
-  end
-end
-
-class ChargeTest < ActiveSupport::TestCase
-  fixtures :payment_methods
-
-  should_validate_presence_of :description
-
-  context "Order" do
-    setup do
-      @order = Factory(:order)
-    end
-
-    should "create default tax charge" do
-      assert_equal(1, @order.tax_charges.length)
-      assert_equal(1, @order.charges.reload.length)
-      assert_equal(0, @order.shipping_charges.length)
-    end
-
-    should "find all types of charges" do
-      Charge.create(:order => @order, :description => "TestCharge")
-      ShippingCharge.create(:order => @order, :description => "TestCharge")
-      TaxCharge.create(:order => @order, :description => "TestCharge")
-      TestCharge.create(:order => @order, :description => "TestCharge")
-      assert_equal(5, @order.reload.charges.length) # 4 + 1 default tax charge
-    end
-
-    context "TaxCharge" do
-      setup do
-        @tax_charge = @order.tax_charges.first
-        assert(@tax_charge, "Tax charge is not present")
-      end
-
-      should "set order as charge source" do
-        assert_equal(@order, @tax_charge.adjustment_source)
-      end
-
-      should "not calculate tax_charge" do
-        assert_equal(nil, @tax_charge.calculate_adjustment)
-      end
-
-      should "have amount = 0" do
-        assert_equal(0, @tax_charge.amount.to_f)
-      end
-    end
-
-    context "with checkout, shipping method and addresses" do
-      setup do
-        create_complete_order
-        @order.update_attribute(:completed_at, nil)
-        @ship_charge = @order.shipping_charges.first
-        @tax_charge = @order.tax_charges.first
-        assert(@ship_charge, "Shipping charge was not created")
-        assert_equal @order, @ship_charge.order
-        assert !@order.checkout_complete
-      end
-
-      should "have ship_address and at least one zone address belongs to" do
-        assert(@order.shipment.address, "Ship_address is empty")
-        assert_not_nil(Zone.global.include?(@order.shipment.address), "Default zone doesn't include address.")
-        zones = Zone.match(@order.shipment.address)
-        assert(!zones.empty?, "Zones are empty")
-      end
-
-      should "create default shipping charge" do
-        assert_equal(1, @order.tax_charges.length)
-        assert_equal(2, @order.charges.length)
-        assert_equal(1, @order.shipping_charges.length)
-      end
-
-      should "calculate value for ship charge" do
-        assert !@ship_charge.order.checkout_complete
-        assert_nil(@ship_charge.read_attribute(:amount))
-        assert_equal("10.0", @ship_charge.calculate_adjustment.to_s)
-        assert_equal("10.0", @ship_charge.amount.to_s)
-      end
-
-      should "set first shipment as charge source of ship_charge" do
-        assert_equal(@order.shipment, @ship_charge.adjustment_source)
-      end
-
-      should "calculate value of ship_charge" do
-        assert_equal("10.0", @ship_charge.calculate_adjustment.to_s)
-      end
-
-      should "recalculate tax_charge, to be 0.05 of item total" do
-        assert_not_nil(Zone.global.include?(@order.shipment.address), "Default zone doesn't include address.")
-        assert_equal Zone.global, TaxRate.find(:first).zone
-        assert(!Zone.global.tax_rates.empty?)
-        tax = @order.line_items.reload.total * 0.05
-        assert_equal(tax.to_s, @tax_charge.calculate_adjustment.to_s)
-      end
-
-      context "with line_items quantity changes" do
-        setup do
-          @order.line_items.first.update_attribute(:quantity, @order.line_items.first.quantity + 1)
-          @order.save
-          @tax_delta = @order.line_items.first.price * 0.05
-          @total_delta = @order.line_items.first.price + @tax_delta
-        end
-        should_change("tax charge",  :by => @tax_delta)   { @order.tax_charges.first.amount }
-        should_change("order total", :by => @total_delta) { @order.total }
-      end
-    end
-  end
-end

data/test/unit/checkout_test.rb

@@ -1,127 +0,0 @@
-require 'test_helper'
-
-class CheckoutTest < ActiveSupport::TestCase
-  fixtures :payment_methods
-
-  should_belong_to :bill_address
-
- context Checkout do
-   setup do
-     @order = Factory(:order_with_totals)
-     @checkout = @order.checkout
-     @checkout.email = Faker::Internet.email
-     @checkout.shipping_method = Factory(:shipping_method)
-     @checkout.state = "confirm"
-     @checkout.save!
-   end
-
-   context "with :register as current validation group" do
-     setup do
-       @checkout.enable_validation_group(:register)
-     end
-     subject { @checkout }
-
-     should_not_allow_values_for :email, "blah", "b lah", "blah@blah"
-   end
-
-   context "in confirm state w/no auto capture" do
-     setup do
-       Spree::Config.set(:auto_capture => false)
-       @payment = Factory(:payment, :payable => @checkout)
-     end
-     context "next" do
-       setup do
-         @checkout.next!
-        end
-       should_change("@checkout.state", :to => "complete") { @checkout.state }
-       should_change("@checkout.order.completed_at", :from => nil) { @checkout.order.completed_at }
-       should_change("@checkout.order.state", :from => "in_progress", :to => "new") { @checkout.order.state }
-       should_change("CreditcardTxn.count", :by => 1) { CreditcardTxn.count }
-     end
-   end
-
-   context "in payment state w/no auto capture" do
-    context "next with declineable creditcard" do
-      setup do
-        @checkout.state = 'payment'
-        @payment = Factory(:payment, :payable => @checkout, :source => Factory.build(:creditcard, :number => "123" ))
-        begin
-          @checkout.next!
-        rescue
-          Spree::GatewayError
-        end
-      end
-      should_not_change("CreditcardTxn.count") { CreditcardTxn.count }
-      should_not_change("@checkout.state") { @checkout.state }
-    end
-   end
-
-   context "in confirm state w/auto capture" do
-     setup do
-       Spree::Config.set(:auto_capture => true)
-     end
-     context "next" do
-       setup do
-         @checkout.state = 'confirm'
-         @payment = Factory(:payment, :payable => @checkout)
-         @checkout.next!
-       end
-       should_change("@checkout.state", :to => "complete") { @checkout.state }
-       should_change("@checkout.order.completed_at", :from => nil) { @checkout.order.completed_at }
-       should_change("@checkout.order.state", :from => "in_progress", :to => "paid") { @checkout.order.state }
-       should_change("CreditcardTxn.count", :by => 1) { CreditcardTxn.count }
-     end
-   end
-   context "on update" do
-     setup do
-       @order = Factory(:order)
-       @checkout = @order.checkout
-       @checkout.bill_address = Factory(:address)
-       @checkout.ship_address = Factory(:address)
-       @shipping_method = Factory(:shipping_method)
-       @checkout.save
-     end
-     should "update shipping method of order's default shipment" do
-       @checkout.shipping_method = @checkout.shipping_methods.first
-       assert_nil @order.shipment.shipping_method
-       @checkout.save
-       assert_equal @checkout.shipping_method, @order.shipment.shipping_method, "default shipment shipping_method didn't match shipping_method of checkout"
-     end
-     should "update address of order's default shipment" do
-       assert_equal @checkout.ship_address, @order.shipment.address, "default shipment address didn't match ship address from checkout"
-     end
-   end
- end
- context "Checkout#countries" do
-   setup do
-     3.times { Factory(:country) }
-     @country = Factory(:country)
-     zone_member = ZoneMember.create(:zoneable => @country)
-     @zone = Zone.create(:name => Faker::Lorem.words, :description => Faker::Lorem.sentence, :zone_members => [zone_member])
-   end
-   context "with no checkout zone defined" do
-     setup { Spree::Config.set(:checkout_zone => nil) }
-     should "return complete list of countries" do
-       assert_equal Country.count, Checkout.countries.size
-     end
-   end
-   context "with a checkout zone defined" do
-     setup { Spree::Config.set(:checkout_zone => @zone.name) }
-     should "return only the countries defined by the checkout zone" do
-       assert_equal [@country], Checkout.countries
-     end
-   end
- end
- context "Checkout state machine with no Gateway configured" do
-   setup do
-     Gateway.stub!(:current, :return => nil)
-     @order = Factory(:order_with_totals)
-     @checkout = @order.checkout
-     @checkout.state = 'payment'
-     @checkout.next!
-   end
-   should "transition to complete" do
-     assert_equal @checkout.state, "complete"
-   end
- end
-end