spree 0.11.0 → 0.11.1

data/spec/models/payment_sepc.rb

@@ -1,29 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper.rb'
-
-describe Payment do
-  before(:each) do
-    @order = Order.new
-    @order.checkout_complete = true
-    @order.stub!(:total).and_return(100)
-    @payment = CreditcardPayment.new(:order => @order)
-  end
-
-  describe "save hook" do
-    it "should mark order as paid if payment_total = total" do
-      @order.stub!(:payment_total).and_return(100)
-      @order.should_receive(:pay!)
-      @payment.save
-    end
-    it "should mark order as paid if payment_total > total" do
-      @order.stub!(:payment_total).and_return(101)
-      @order.should_receive(:pay!)
-      @payment.save
-    end
-    it "should not mark order as paid if payment_total < total" do
-      @order.stub!(:payment_total).and_return(99)
-      @order.should_not_receive(:pay!)
-      @payment.save
-    end 
-  end
-
-end

data/spec/models/product_option_type_spec.rb

@@ -1,38 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-module ProductOptionTypeSpecHelper
-  def valid_product_option_type_attributes
-    {
-      :position => 1
-    }
-  end
-end
-
-
-describe ProductOptionType do
-  include ProductOptionTypeSpecHelper
-
-  before(:each) do
-    @product_option_type = ProductOptionType.new
-  end
-
-  it "should not be valid when empty" do
-    pending "Shouldn't it require a position?"
-    @product_option_type.should_not be_valid
-  end
-
-  ['position'].each do |field|
-    it "should require #{field}" do
-      pending "Shouldn't it require a position?"
-      @product_option_type.should_not be_valid
-      @product_option_type.errors.full_messages.should include("#{field.intern.l(field).humanize} #{:error_message_blank.l}")
-    end
-  end
-
-  it "should be valid when having correct information" do
-    pending "Shouldn't it require a product and an option type too?"
-    @product_option_type.attributes = valid_product_option_type_attributes
-    @product_option_type.should be_valid
-  end
-
-end

data/spec/models/product_property_spec.rb

@@ -1,29 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-module ProductPropertySpecHelper
-  def valid_product_property_attributes
-    {
-      :value => "x"
-    }
-  end
-end
-
-
-describe ProductProperty do
-  include ProductPropertySpecHelper
-
-  before(:each) do
-    @product_property = ProductProperty.new
-  end
-
-  it "should not be valid when empty" do
-    @product_property.should_not be_valid
-  end
-
-  it "should be valid when having correct information" do
-    pending "Shouldn't it require a product and a property too?"
-    @product_property.attributes = valid_product_property_attributes
-    @product_property.should be_valid
-  end
-
-end

data/spec/models/property_spec.rb

@@ -1,37 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-module PropertySpecHelper
-  def valid_property_attributes
-    {
-      :name => "a_property",
-      :presentation => "A Property"
-    }
-  end
-end
-
-describe Property do
-  include PropertySpecHelper
-
-  before(:each) do
-    @property = Property.new
-  end
-
-  it "should not be valid when empty" do
-    @property.should_not be_valid
-  end
-
-  ['name', 'presentation'].each do |field|
-    it "should require #{field}" do
-      @property.should_not be_valid
-      @property.errors.full_messages.should include("#{I18n.translate("activerecord.attributes.property.#{field}")} #{I18n.translate("activerecord.errors.messages.blank")}")
-    end
-  end
-
-  it "should be valid when having correct information" do
-    @property.attributes = valid_property_attributes
-    @property.should be_valid
-  end
-
-  it "should find all by prototype"
-
-end

data/spec/models/prototype_spec.rb

@@ -1,35 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-module PrototypeSpecHelper
-  def valid_prototype_attributes
-    {
-      :name => "A Prototype"
-    }
-  end
-end
-
-
-describe Prototype do
-  include PrototypeSpecHelper
-
-  before(:each) do
-    @prototype = Prototype.new
-  end
-
-  it "should not be valid when empty" do
-    @prototype.should_not be_valid
-  end
-
-  ['name'].each do |field|
-    it "should require #{field}" do
-      @prototype.should_not be_valid
-      @prototype.errors.full_messages.should include("#{I18n.t("activerecord.attributes.prototype.#{field}")} #{I18n.t("activerecord.errors.messages.blank")}")
-    end
-  end
-
-  it "should be valid when having correct information" do
-    @prototype.attributes = valid_prototype_attributes
-    @prototype.should be_valid
-  end
-
-end

data/spec/models/shipment_spec.rb

@@ -1,8 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-class MockCalculator
-end
-
-describe Shipment do
-
-end

data/spec/models/shipping_category_spec.rb

@@ -1,8 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe ShippingCategory do
-  before(:each) do
-    @shipping_category = ShippingCategory.new
-  end
-
-end

data/spec/models/shipping_order_spec.rb

@@ -1,113 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper.rb'
-
-describe Order do
-  before(:each) do
-    @shipment = Shipment.new                                                          
-    @inventory_unit = InventoryUnit.new(:state => "sold")
-    @order = Order.new(:shipments => [@shipment], :inventory_units => [@inventory_unit]) #(:address => @address = mock_model(Address, :null_object => true))
-  end
-
-  # moved from order_spec (may not be correct or relevant)
-  describe "ship" do
-    before(:each) {@order.state = "paid"}
-    it "should transition to shipped" do
-      @order.ship
-      @order.state.should == 'shipped'
-    end
-    it "should mark inventory as shipped" do
-      pending "doesn't seem to cause transition on inv unit"
-      @inventory_unit.should_receive(:ship!)
-      @order.ship
-    end
-  end
-
-  describe "shipping_countries" do
-    it "should return an empty array if there are no shipping methods configured" do
-      ShippingMethod.stub!(:all, :return => [])
-      @order.shipping_countries.should == []
-    end
-    it "should contain only a single country even if multiple shipping methods are configured with that same country" do
-      country = Country.new(:name => "foo")
-      method1 = mock_model(ShippingMethod, :zone => mock_model(Zone, :country_list => [country]))
-      method2 = mock_model(ShippingMethod, :zone => mock_model(Zone, :country_list => [country]))
-      ShippingMethod.stub!(:all, :return => [method1, method2])
-      @order.shipping_countries.should == [country]
-    end
-    it "should contain the unique list of countries that fall within at least one shipping method's zone" do
-      country1 = Country.new(:name => "bar")
-      country2 = Country.new(:name => "foo")
-      method1 = mock_model(ShippingMethod, :zone => mock_model(Zone, :country_list => [country1]))
-      method2 = mock_model(ShippingMethod, :zone => mock_model(Zone, :country_list => [country2]))
-      ShippingMethod.stub!(:all, :return => [method1, method2])
-      @order.shipping_countries.should == [country1, country2]
-    end
-  end
-  
-  describe "shipping_methods" do
-    it "should return empty array if there are no shipping methods configured" do
-      @order.shipping_methods.should == []
-    end
-=begin (commented this out since we need to rework all of this shipping stuff as shoulda and it was failing )
-    it "should check the shipping address against the shipping method's zone" do
-      address = Address.new
-      @order.ship_address = address
-      zone = mock_model(Zone)
-      method = mock_model(ShippingMethod, :zone => zone)
-      ShippingMethod.stub!(:all, :return => [method])
-      zone.should_receive(:include?).with(address)
-      @order.shipping_methods
-    end
-=end        
-    it "should return empty array if none of the configured shipping methods cover the shipping address" do
-      method = mock_model(ShippingMethod, :zone => mock_model(Zone, :include? => false))
-      ShippingMethod.stub!(:all, :return => [method])
-      @order.shipping_methods.should == []
-    end
-    it "should return all shipping methiods that cover the shipping address" do
-      method1 = mock_model(ShippingMethod, :zone => mock_model(Zone, :include? => true))
-      method2 = mock_model(ShippingMethod, :zone => mock_model(Zone, :include? => true))
-      method3 = mock_model(ShippingMethod, :zone => mock_model(Zone, :include? => false))
-      ShippingMethod.stub!(:all, :return => [method1, method2, method3])
-      pending "not investigated"
-      @shipment.shipping_methods.should == [method1, method2]
-    end
-  end
-  
-  describe "state_machine in 'address' state" do
-    before :each do
-      @order.state = 'in_progress'
-    end
-    describe "when there are no shipping methods" do
-      it "next! should transition to 'creditcard'" do
-        pending "not investigated"
-        @order.stub!(:shipping_methods).and_return([])
-        @order.next!
-        @order.state.should == "creditcard"
-      end
-    end
-    describe "when there is more then one shipping method" do
-      it "next! should transition to 'shipping_method'" do
-        pending "not investigated"
-        @order.state = "shipment"
-        @order.stub!(:shipping_methods).and_return([ShippingMethod.new, ShippingMethod.new])
-        @order.next!
-        @order.state.should == "shipping_method"
-      end
-    end
-  end
-  
-  describe "next!" do
-    it "should transition from 'shipment' to 'shipping_method'" do
-      pending "not investigated"
-      @order.state = 'shipment'
-      @order.next!
-      @order.state.should == "shipping_method"
-    end
-    it "should transition from 'shipping_method' to 'creditcard'" do
-      pending "not investigated"
-      @order.state = 'shipping_method'
-      @order.next!
-      @order.state.should == "creditcard"
-    end
-  end
-end

data/spec/models/tax_category_spec.rb

@@ -1,11 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe TaxCategory do
-  before(:each) do
-    @tax_category = TaxCategory.new :name => 'dummy'
-  end
-
-  it "should be valid" do
-    @tax_category.should be_valid
-  end
-end

data/spec/models/taxon_spec.rb

@@ -1,50 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-module TaxonHelper
-  def valid_taxon_attributes
-    {
-      :name => "A Taxon",
-      :position => 1
-    }
-  end
-end
-
-describe Taxon do
-  include TaxonHelper
-
-  before(:each) do
-    @taxonomy = Taxonomy.create(:name => "Test")
-    @taxon = Taxon.new
-  end
-
-  it "should not be valid when empty" do
-    pending "Can it really be valid when empty?"
-    @taxon.should_not be_valid
-  end
-
-  ['name'].each do |field|
-    it "should require #{field}" do
-      pending "Is this field mandatory?"
-      @taxon.should_not be_valid
-      @taxon.errors.full_messages.should include("#{field.intern.l(field).humanize} #{:error_message_blank.l}")
-    end
-  end
-  
-  it "should be valid when having correct information" do
-    @taxon.attributes = valid_taxon_attributes
-
-    @taxon.should be_valid
-  end
-  
-  it "should set the permalink on create" do
-    @taxon = Taxon.create(:name => "foo", :taxonomy => @taxonomy)
-    @taxon.permalink.should == "foo/"
-  end
-  
-  it "should update the permalink on update" do
-    @taxon = Taxon.create(:name => "foo", :taxonomy => @taxonomy)
-    @taxon.update_attribute("name", "fooz")
-    @taxon.permalink.should == "fooz/"
-  end
-  
-end

data/spec/models/taxonomy_spec.rb

@@ -1,37 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-module TaxonomyHelper
-  def valid_taxonomy_attributes
-    {
-      :name => "A Taxonomy"
-    }
-  end
-end
-
-describe Taxonomy do
-  include TaxonomyHelper
-
-  before(:each) do
-    @taxonomy = Taxonomy.new
-  end
-
-  it "should not be valid when empty" do
-    pending "Can it really be valid when empty?"
-    @taxonomy.should_not be_valid
-  end
-
-  ['name', 'root'].each do |field|
-    it "should require #{field}" do
-      pending "Is this field mandatory?"
-      @taxonomy.should_not be_valid
-      @taxonomy.errors.full_messages.should include("#{field.intern.l(field).humanize} #{:error_message_blank.l}")
-    end
-  end
-  
-  it "should be valid when having correct information" do
-    @taxonomy.attributes = valid_taxonomy_attributes
-
-    @taxonomy.should be_valid
-  end
-  
-end

data/spec/models/zone_member_spec.rb

@@ -1,5 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe ZoneMember do
-
-end

data/spec/models/zone_spec.rb

@@ -1,137 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe Zone do
-  before(:each) do
-    # has_many_polymorphs requires that the record be saved before you create associations
-    @zone = Zone.create(:name => "foo", :description => "foofah")
-  end
-  
-  describe "#kind" do
-    it "should be country when zone contains countries" do
-      @zone.members << ZoneMember.new(:zoneable => Country.new)
-      @zone.kind.should == "country"
-    end
-    it "should be state when zone contains states" do
-      @zone.members << ZoneMember.new(:zoneable => State.new)
-      @zone.kind.should == "state"
-    end
-    it "should be zone when zone contains zones" do
-      @zone.members << ZoneMember.new(:zoneable => Zone.new)
-      @zone.kind.should == "zone"
-    end
-    it "should be country when zone contains no members (default)" do
-      @zone.kind.should == "country"
-    end
-  end
-
-  describe "#include?" do
-    describe "with countries based zone" do 
-      it "should return true when the address country is included in the zones list of countries" do
-        country = Country.new
-        address = Address.new(:country => country)
-        @zone.members << ZoneMember.new(:zoneable => country)
-        @zone.include?(address).should be_true
-      end
-      it "should return false when the address country is not included in the zones list of countries " do
-        country = Country.new
-        address = Address.new(:country => country)
-        @zone.members << ZoneMember.new(:zoneable => Country.new)
-        @zone.include?(address).should be_false
-      end
-    end
-    describe "with states based zone" do   
-      it "should return true when the address state is included in the zones list of states" do
-        state = State.new
-        address = Address.new(:state => state)
-        @zone.members << ZoneMember.new(:zoneable => state)
-        @zone.include?(address).should be_true
-      end
-      it "should return false when the address state is not included in the zones list of states" do
-        state = State.new
-        address = Address.new(:state => state)
-        @zone.members << ZoneMember.new(:zoneable => Address.new)
-        @zone.include?(address).should be_false
-      end
-    end
-    describe "with zones based zone" do               
-      it "should return true when the address satisfies at least one of the zones in the list of zones" do
-        address = Address.new
-        @zone.should_receive(:include?).with(address).and_return(true)
-        @zone.members << ZoneMember.new(:zoneable => @zone)
-        @zone.include?(address).should be_true
-      end
-      it "should return false when the address satisfies none of the zones in the list of zones" do
-        address = Address.new
-        @zone.should_receive(:include?).with(address).and_return(false)
-        @zone.members << ZoneMember.new(:zoneable => @zone)
-        @zone.include?(address).should be_false
-      end
-    end
-  end
-
-  describe "match" do
-    
-    before :each do
-      @address = mock_model(Address)
-    end
-    
-    it "should return an empty array if there are no zone" do
-      Zone.should_receive(:all).and_return([])
-      Zone.match(@address).should == []
-    end
-    
-    it "should return only one zone if the address matches only one zone" do
-      zone1 = mock_model(Zone)
-      zone1.should_receive(:include?).with(@address).and_return(true)
-      zone2 = mock_model(Zone)
-      zone2.should_receive(:include?).with(@address).and_return(false)
-      Zone.should_receive(:all).and_return([zone1, zone2])
-      Zone.match(@address).should == [zone1]
-    end
-
-    it "should return both zones if the address matches both zones" do
-      zone1 = mock_model(Zone)
-      zone1.should_receive(:include?).with(@address).and_return(true)
-      zone2 = mock_model(Zone)
-      zone2.should_receive(:include?).with(@address).and_return(true)
-      Zone.should_receive(:all).and_return([zone1, zone2])
-      Zone.match(@address).should == [zone1, zone2]
-    end
-
-    it "should return no zones if address matches neither of the zones" do
-      zone1 = mock_model(Zone)
-      zone1.should_receive(:include?).with(@address).and_return(false)
-      zone2 = mock_model(Zone)
-      zone2.should_receive(:include?).with(@address).and_return(false)
-      Zone.should_receive(:all).and_return([zone1, zone2])
-      Zone.match(@address).should == []
-    end
-
-  end
-  
-  describe "country_list" do
-    it "should return an empty array if the zone kind is state" do
-      @zone.stub!(:kind, :return => "state")
-      @zone.country_list.should == []
-    end
-    it "should return the corresponding countries if zone kind is country" do
-      country = Country.new
-      @zone.members << ZoneMember.new(:zoneable => country)
-      @zone.country_list.should == [country]
-    end
-    it "should return the countries of the zone children if the kind is zone" do   
-      country1 = Country.new
-      country2 = Country.new
-      
-      zone1 = Zone.new
-      zone1.members << ZoneMember.new(:zoneable => country1)
-      
-      zone2 = Zone.new
-      zone2.members << ZoneMember.new(:zoneable => country2)
-      
-      @zone.members << ZoneMember.new(:zoneable => zone1)
-      @zone.members << ZoneMember.new(:zoneable => zone2)
-      @zone.country_list.should == [country1, country2]
-    end
-  end
-end