spree 0.11.0 → 0.11.1

data/spec/models/address_spec.rb

@@ -1,79 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-module AddressSpecHelper
-  def valid_address_attributes
-    {
-      :firstname => "First",
-      :lastname => "Last",
-      :address1 => "Address1",
-      :city => "City",
-      :state_name => "A State",
-      :zipcode => "00000",
-      :country => Country.new,
-      :phone => "00000000"
-    }
-  end
-end
-
-
-describe Address do
-  include AddressSpecHelper
-
-  before(:each) do
-    @address = Address.new
-  end
-
-  it "should not be valid when empty" do
-    @address.should_not be_valid
-  end
-
-  ['firstname', 'lastname', 'address1', 'city', 'country', 'zipcode', 'phone'].each do |field|
-    it "should require #{field}" do
-      @address.should_not be_valid                    
-      @address.errors.full_messages.should include("#{Address.human_attribute_name(field)} #{I18n.translate("activerecord.errors.messages.blank")}")
-    end
-  end
-
-  it "should require a state name when the associated country don't have states" do
-    @address.attributes = valid_address_attributes.with(:state_name => "")
-
-    @address.should_not be_valid
-    @address.errors.full_messages.should include("#{'state_name'.humanize} #{I18n.translate("activerecord.errors.messages.blank")}")
-  end
-
-  it "should require a state when the associated country have states" do
-    @address.attributes = valid_address_attributes.with(
-      :country => Country.new(:states => [State.new(:name => "A State", :abbr => "ST")]),
-      :state_name => ""
-    )
-
-    @address.should_not be_valid
-    @address.errors.full_messages.should include("#{'state'.humanize} #{I18n.translate("activerecord.errors.messages.blank")}")
-  end
-  
-  it "should be valid when having correct information" do
-    @address.attributes = valid_address_attributes
-    @address.should be_valid
-  end
-
-  it "should return full name when requested" do
-    @address.attributes = valid_address_attributes
-    @address.full_name.should == @address.firstname + " " + @address.lastname
-  end
-  
-  it "should return state text as state_name attribute when the associated state is nil" do
-    @address.attributes = valid_address_attributes.except(:state)
-    @address.state_text.should == @address.state_name
-  end
-    
-  it "should return state text as state.name attribute when the associated state is not nil but the abbreviation is empty" do
-    @address.attributes = valid_address_attributes.with(:state => State.new(:name => "A State", :abbr => ""))
-    @address.state_text.should == @address.state.name
-  end
-    
-  it "should return state text as state.abbr attribute when the associated state is not nil and the abbreviation is not empty" do
-    @address.attributes = valid_address_attributes.with(:state => State.new(:name => "A State", :abbr => "ST"))
-    @address.state_text.should == @address.state.abbr
-  end
-
-end

data/spec/models/app_configuration_spec.rb

@@ -1,13 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe AppConfiguration do
-  before(:each) do
-    @valid_attributes = {
-      :name => "Default Configuration"
-    }
-  end
-
-  it "should create a new instance given valid attributes" do
-    AppConfiguration.create!(@valid_attributes)
-  end
-end

data/spec/models/creditcard_payment_spec.rb

@@ -1,17 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe CreditcardPayment do
-  before(:each) {@creditcard_payment = CreditcardPayment.create(:order => Order.new)}
-  it "#can_capture? should return false if there is no response code" do
-    @creditcard_payment.txns.create(:txn_type => CreditcardTxn::TxnType::AUTHORIZE)
-    @creditcard_payment.can_capture?.should == false
-  end
-  it "#can_capture? should return true if the last transaction was an authorization" do
-    @creditcard_payment.txns.create(:txn_type => CreditcardTxn::TxnType::AUTHORIZE, :response_code => "123")
-    @creditcard_payment.can_capture?.should == true
-  end
-  it "#can_capture? should return false if the last transaction is not an authorization" do
-    @creditcard_payment.txns.create(:txn_type => CreditcardTxn::TxnType::CAPTURE, :response_code => "123")
-    @creditcard_payment.can_capture?.should == false    
-  end
-end

data/spec/models/creditcard_spec.rb

@@ -1,43 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Creditcard do
-  before(:each) do
-    @creditcard = Creditcard.new(:number => "4111111111111111", 
-                                 :month => "12",
-                                 :year => "2010",
-                                 :verification_value => "123",
-                                 :first_name => "Sean",
-                                 :last_name => "Schofield")
-  end
-    
-  it "should correctly assign the type of credit card based on the number" do
-    @creditcard.save
-    @creditcard.cc_type.should == "visa"
-  end  
-
-  it "should store the creditcard number if :store_cc => true" do
-    Spree::Config.set(:store_cc => true)
-    @creditcard.save
-    @creditcard = Creditcard.find(@creditcard.id)
-    @creditcard.number.should == "4111111111111111"
-  end
-  it "should not store the creditcard number if :store_cc => false" do
-    Spree::Config.set(:store_cc => false)
-    @creditcard.save
-    @creditcard = Creditcard.find(@creditcard.id)
-    @creditcard.number.should be_nil
-  end
-  it "should store the verification_value if :store_cvv => true" do
-    Spree::Config.set(:store_cvv => true)
-    @creditcard.save
-    @creditcard = Creditcard.find(@creditcard.id)
-    @creditcard.verification_value.should == "123"
-  end
-  it "should not store the verification_value if :store_cvv => false" do
-    Spree::Config.set(:store_cvv => false)
-    @creditcard.save
-    @creditcard = Creditcard.find(@creditcard.id)
-    @creditcard.verification_value.should be_nil
-  end
-  
-end

data/spec/models/inventory_unit_spec.rb

@@ -1,18 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper.rb'
-
-describe InventoryUnit do
-  
-  before(:each) do
-    @order = mock_model(Order)
-  end
-  
-  it "should mark the correct number of inventory units as SOLD" do
-    line_item = mock_model(LineItem)
-    variant = mock_model(Variant)
-    line_item.stub!(:variant).and_return(variant)
-    @order.stub!(:line_items).and_return([line_item])
-    
-    # TODO - finish this test
-  end
-  
-end

data/spec/models/option_type_spec.rb

@@ -1,36 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-module OptionTypeSpecHelper
-  def valid_option_type_attributes
-    {
-      :name => "an_option_type",
-      :presentation => "An Option Type"
-    }
-  end
-end
-
-
-describe OptionType do
-  include OptionTypeSpecHelper
-
-  before(:each) do
-    @option_type = OptionType.new
-  end
-
-  it "should not be valid when empty" do
-    @option_type.should_not be_valid
-  end
-
-  ['name', 'presentation'].each do |field|
-    it "should require #{field}" do
-      @option_type.should_not be_valid
-      @option_type.errors.full_messages.should include("#{field.humanize} #{I18n.translate("activerecord.errors.messages.blank")}")
-    end
-  end
-
-  it "should be valid when having correct information" do
-    @option_type.attributes = valid_option_type_attributes
-    @option_type.should be_valid
-  end
-  
-end

data/spec/models/option_value_spec.rb

@@ -1,39 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-module OptionValueSpecHelper
-  def valid_option_value_attributes
-    {
-      :name => "an_option_value",
-      :presentation => "An Option Value",
-      :position => 1
-    }
-  end
-end
-
-
-describe OptionValue do
-  include OptionValueSpecHelper
-
-  before(:each) do
-    @option_value = OptionValue.new
-  end
-
-  it "should not be valid when empty" do
-    pending "Shouldn't it require a name and a presentation?"
-    @option_value.should_not be_valid
-  end
-
-  ['name', 'presentation'].each do |field|
-    it "should require #{field}" do
-      pending "Shouldn't it require a name and a presentation?"
-      @option_value.should_not be_valid
-      @option_value.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
-    @option_value.attributes = valid_option_value_attributes
-    @option_value.should be_valid
-  end
-  
-end

data/spec/models/order_spec.rb

@@ -1,207 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper.rb'
-
-describe Order do
-  before(:each) do
-    @variant = Variant.new(:id => "1234", :price => 7.99)
-    @inventory_unit = mock_model(InventoryUnit, :null_object => true)
-    @creditcard_payment = mock_model(CreditcardPayment, :null_object => true)
-    @user = mock_model(User, :email => "foo@exampl.com")
-
-    @order = Order.new
-    @order.checkout_complete = true
-    @order.creditcard_payments = [@creditcard_payment]
-    @order.number = '#TEST1010'
-    @order.user =  @user
-
-    @order.stub!(:save => true, :inventory_units => [@inventory_unit])
-    @line_item =  LineItem.new(:variant => @variant, :quantity => 1, :price => 7.99)
-    @order.line_items << @line_item
-    InventoryUnit.stub!(:retrieve_on_hand).with(@variant, 1).and_return [@inventory_unit]
-    OrderMailer.stub!(:deliver_confirm).with(any_args)   
-    OrderMailer.stub!(:deliver_cancel).with(any_args)    
-
-  end
-
-  describe "create" do
-    it "should generate an order number" do
-      order = Order.create
-      order.number.should_not be_nil
-    end
-    it "should generate a token" do
-      order = Order.create
-      order.token.should_not be_nil 
-    end
-  end
-  
-  describe "next" do
-    describe "from creditcard_payment" do
-      before(:each) do
-        @order.state = 'creditcard'
-      end
-      it "should transition to new" do
-        @order.next
-        @order.state.should == "new"
-      end
-      it "should mark inventory as sold" do
-        @inventory_unit.should_receive(:sell!)
-        @order.next
-      end
-      it "should send a confirmation email" do
-        OrderMailer.should_receive(:deliver_confirm).with(@order)
-        @order.next
-      end
-    end
-  end
-    
-  describe "cancel" do
-    it "should mark inventory as on_hand" do
-      @order.state = "captured"
-      @inventory_unit.stub!(:state).and_return('sold')
-      @inventory_unit.should_receive(:restock!)
-      @order.cancel
-    end
-    it "should send a cancellation email" do
-      OrderMailer.should_receive(:deliver_cancel).with(@order)
-      @order.cancel
-    end                        
-    %w{in_progress creditcard}.each do |state|
-      it "should be available in the #{state} state" do
-        @order.state = state
-        @order.checkout_complete = false
-        @order.can_cancel?.should be_true
-      end
-    end
-  end
-  
-  describe "return" do
-    it "should mark inventory as on_hand" do
-      @order.state = "shipped"
-      @inventory_unit.stub!(:state).and_return('shipped')
-      @inventory_unit.should_receive(:restock!)
-      @order.return
-    end
-  end
-  
-  describe "add_variant" do
-    it "should add new line item if product does not currently existing in order" do
-      @variant2 = mock_model(Variant, :id => "5678", :price => 9.99)
-      
-      @order.line_items.should_receive(:in_order).with(@variant2).and_return(nil)
-      @order.line_items.size.should == 1
-
-      @order.add_variant(@variant2)
-      
-      @order.line_items.size.should == 2
-    end
-    
-    it "should increment the quantity of line_item by 1 when product already exists in order, and no specific quantity is supplied" do
-
-      @order.line_items.should_receive(:in_order).with(@variant).and_return(@line_item)
-      @line_item.should_receive(:save).and_return(true)
-      
-      @order.line_items[0].quantity.should == 1
-      @order.add_variant(@variant)
-    
-      @order.line_items[0].quantity.should == 2
-    end
-    
-    it "should increment the quantity of line_item by x when product already exists in order, and a specific quantity is supplied"do
-
-      @order.line_items.should_receive(:in_order).with(@variant).and_return(@line_item)
-      @line_item.should_receive(:save).and_return(true)
-      
-      @order.line_items[0].quantity.should == 1
-      @order.add_variant(@variant, 5)
-    
-      @order.line_items[0].quantity.should == 6
-    end
-    
-    it "should populate additional fields on line_item when additional_fields is present" do
-        Variant.stub!(:additional_fields).and_return([
-          {:name => 'Weight', :only => [:product]},
-          {:name => 'Height', :only => [:product, :variant], :format => "%.2f"},
-          {:name => 'Width', :only => [:variant], :format => "%.2f", :populate => [:line_item]},
-          {:name => 'Depth', :only => [:variant], :populate => [:line_item]}
-        ])
-        
-        #build / mock second line item to be returned, when we add the new variant
-        @line_item2 =  LineItem.new(:variant => @variant, :quantity => 1)
-        @line_item2.should_receive(:save).exactly(3).times.and_return(true)
-        @line_item2.stub!(:width=) 
-        @line_item2.stub!(:depth=)
-        
-        #mock new variant to add to order
-        @variant2 = mock_model(Variant, :id => "5678", :price => 9.99, :width => 19, :depth => 79)
-        
-        #this is what we expect to happen
-        @order.line_items.should_receive(:in_order).with(@variant2).and_return(@line_item2)
-        @line_item2.should_receive(:width=).with(@variant2.width) 
-        @line_item2.should_receive(:depth=).with(@variant2.depth)
-          
-        @order.add_variant(@variant2)
-        
- 
-    end
-  end
-
-  describe "resume" do
-    %w{in_progress shipment shipping_method creditcard charged }.each do |state|
-      it "should not be available in #{state} state" do 
-        @order.state = state
-        @order.send("can_resume?").should == false
-      end
-    end
-    it "should be available in canceled state" do 
-      @order.state = 'canceled'
-      @order.state_events = [StateEvent.new(:name => 'cancel', :previous_state => 'charged')]
-      @order.send("can_resume?").should == true
-    end
-    it "should restore the order to the previous state" do
-      @order.state_events = [StateEvent.new(:name => 'cancel', :previous_state => 'charged')]
-      @order.state = 'canceled'
-      @order.resume!
-      @order.state.should == 'charged'
-    end
-    it "should not be available for legacy orders wtih no prior state information" do 
-      @order.state = 'canceled'
-      @order.state_events = [StateEvent.new(:name => 'cancel')]
-      @order.send("can_resume?").should == false
-    end
-  end  
-  
-  describe "grant_access?" do
-    it "should grant if current_user is the same as the order's user" do
-      current_user = User.new
-      user_session = mock_model(UserSession, :user => current_user)
-      UserSession.stub!(:find).and_return(user_session)
-      @order.user = current_user
-      @order.grant_access?.should be_true
-    end
-    it "should deny if current_user is not the same as the order's user and no token" do
-      current_user = User.new
-      user_session = mock_model(UserSession, :user => current_user)
-      UserSession.stub!(:find).and_return(user_session)
-      @order.user = User.new
-      @order.grant_access?.should be_false
-    end
-    it "should deny if current_user is not the same as the order's user and wrong token" do
-      current_user = User.new
-      user_session = mock_model(UserSession, :user => current_user)
-      UserSession.stub!(:find).and_return(user_session)
-      @order.user = User.new
-      @order.token = "FOO_TOKEN"
-      @order.grant_access?("WRONG_TOKEN").should be_false
-    end
-    it "should allow if current_user does not match order but correct token is provided" do
-      token = "FOO_TOKEN"
-      current_user = User.new
-      user_session = mock_model(UserSession, :user => current_user)
-      UserSession.stub!(:find).and_return(user_session)
-      @order.user = User.new
-      @order.token = token
-      @order.grant_access?(token).should be_true
-    end
-    
-  end
-
-end