MyCommerceapi 1.0.0

data/core/spec/lib/calculated_adjustments_spec.rb

@@ -0,0 +1,54 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+# Its pretty difficult to test this module in isolation b/c it needs to work in conjunction with an actual class that
+# extends ActiveRecord::Base and has a corresponding table in the database.  So we'll just test it using Order and
+# ShippingMethod instead since those classes are including the module.
+describe Spree::CalculatedAdjustments do
+
+  let(:calculator) { mock_model(Calculator, :compute => 10, :[]= => nil) }
+
+  it "should add has_one :calculator relationship" do
+    assert ShippingMethod.reflect_on_all_associations(:has_one).map(&:name).include?(:calculator)
+  end
+  it "should be able to register calculators" do
+    expect {
+      TaxRate.register_calculator(calculator)
+    }.to change { TaxRate.calculators.count }.by 1
+  end
+
+  let(:tax_rate) { TaxRate.new(:calculator => calculator) }
+
+  context "#create_adjustment and its resulting adjustment" do
+    let(:order) { Order.create }
+    let(:target) { order }
+
+    it "should be associated with the target" do
+      target.adjustments.should_receive(:create)
+      tax_rate.create_adjustment("foo", target, order)
+    end
+
+    it "should have the correct originator and an amount derived from the calculator and supplied calculable" do
+      adjustment = tax_rate.create_adjustment("foo", target, order)
+      adjustment.should_not be_nil
+      adjustment.amount.should == 10
+      adjustment.source.should == order
+      adjustment.originator.should == tax_rate
+    end
+
+    it "should be mandatory if true is supplied for that parameter" do
+      adjustment = tax_rate.create_adjustment("foo", target, order, true)
+      adjustment.should be_mandatory
+    end
+
+  end
+
+  context "#update_adjustment" do
+    it "should update the adjustment using its calculator (and the specified source)" do
+      adjustment = mock(:adjustment).as_null_object
+      calculable = mock :calculable
+      adjustment.should_receive(:update_attribute_without_callbacks).with(:amount, 10)
+      tax_rate.update_adjustment(adjustment, calculable)
+    end
+  end
+
+end

data/core/spec/lib/ext_spec.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe 'Core extensions' do
+
+  describe 'ActiveRecord::Base' do
+
+    let(:order) { Order.create }
+
+    context "update_attribute_without_callbacks" do
+
+      it "sets the attribute" do
+        order.update_attribute_without_callbacks 'state', 'new_state'
+        order.state.should == 'new_state'
+      end
+
+      it "updates the attribute in the database" do
+        order.update_attribute_without_callbacks 'state', 'new_state'
+        order.reload
+        order.state.should == 'new_state'
+      end
+
+      it "doesn't call valid" do
+        order.should_not_receive(:valid?)
+        order.update_attribute_without_callbacks 'state', 'new_state'
+      end
+
+    end
+
+    context "updte_attributes_without_callbacks" do
+
+      it "sets the attributes" do
+        order.update_attributes_without_callbacks :state => 'new_state', :email => 'spree@example.com'
+        order.state.should == 'new_state'
+        order.email.should == 'spree@example.com'
+      end
+
+      it "updates the attributes in the database" do
+        order.update_attributes_without_callbacks :state => 'new_state', :email => 'spree@example.com'
+        order.reload
+        order.state.should == 'new_state'
+        order.email.should == 'spree@example.com'
+      end
+
+      it "doesn't call valid" do
+        order.should_not_receive(:valid?)
+        order.update_attributes_without_callbacks :state => 'new_state', :email => 'spree@example.com'
+      end
+
+    end
+
+  end
+
+end

data/core/spec/lib/mail_interceptor_spec.rb

@@ -0,0 +1,69 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+# We'll use the OrderMailer as a quick and easy way to test.  IF it works here - it works for all email (in theory.)
+describe OrderMailer do
+  let(:mail_method) { mock("mail_method", :preferred_mails_from => nil, :preferred_intercept_email => nil, :preferred_mail_bcc => nil) }
+  let(:order) { Order.new(:email => "customer@example.com") }
+  let(:message) { OrderMailer.confirm_email(order) }
+  #let(:email) { mock "email" }
+
+  context "#deliver" do
+    before do
+      ActionMailer::Base.delivery_method = :test
+      MailMethod.stub :current => mail_method
+    end
+    after { ActionMailer::Base.deliveries.clear }
+
+    it "should use the from address specified in the preference" do
+      mail_method.stub :preferred_mails_from => "no-reply@foobar.com"
+      message.deliver
+      @email = ActionMailer::Base.deliveries.first
+      @email.from.should == ["no-reply@foobar.com"]
+    end
+
+    it "should use the provided from address" do
+      mail_method.stub :preferred_mails_from => "preference@foobar.com"
+      message = ActionMailer::Base.mail(:from => "override@foobar.com", :to => "test@test.com")
+      message.deliver
+      @email = ActionMailer::Base.deliveries.first
+      @email.from.should == ["override@foobar.com"]
+    end
+
+    it "should add the bcc email when provided" do
+      mail_method.stub :preferred_mail_bcc => "bcc-foo@foobar.com"
+      message.deliver
+      @email = ActionMailer::Base.deliveries.first
+      @email.bcc.should == ["bcc-foo@foobar.com"]
+    end
+
+    context "when intercept_email is provided" do
+      before {  }
+      it "should strip the bcc recipients"
+      it "should strip the cc recipients"
+      it "should replace the receipient with the specified address" do
+        mail_method.stub :preferred_intercept_email => "intercept@foobar.com"
+        message.deliver
+        @email = ActionMailer::Base.deliveries.first
+        @email.to.should == ["intercept@foobar.com"]
+      end
+      it "should modify the subject to include the original email" do
+        mail_method.stub :preferred_intercept_email => "intercept@foobar.com"
+        message.deliver
+        @email = ActionMailer::Base.deliveries.first
+        @email.subject.match(/customer@example\.com/).should be_true
+      end
+    end
+
+    context "when intercept_mode is not provided" do
+      before { mail_method.stub :preferred_intercept_email => "" }
+
+      it "should not modify the recipient" do
+        message.deliver
+        @email = ActionMailer::Base.deliveries.first
+        @email.to.should == ["customer@example.com"]
+      end
+      it "should bcc the address specified in the preference"
+      it "should not change the recipient"
+    end
+  end
+end

data/core/spec/lib/mail_settings_spec.rb

@@ -0,0 +1,82 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Spree::MailSettings do
+  let(:mail_method) { MailMethod.new(:environment => "test") }
+
+  context "init" do
+    before { MailMethod.stub :current => mail_method }
+
+    context "perform_delivery preference" do
+      it "should override the application defaults" do
+        mail_method.set_preference(:enable_mail_delivery, false)
+        Spree::MailSettings.init
+        ActionMailer::Base.perform_deliveries.should be_false
+        mail_method.set_preference(:enable_mail_delivery, true)
+      end
+    end
+
+    context "when delivery is true" do
+      before { mail_method.set_preference(:enable_mail_delivery, true) }
+
+      context "when mail_auth_type is other than none" do
+        before { mail_method.set_preference(:mail_auth_type, "login") }
+
+        context "mail_auth_type preference" do
+          it "should override the application defaults" do
+            Spree::MailSettings.init
+            ActionMailer::Base.smtp_settings[:authentication].should == "login"
+          end
+        end
+
+        context "mail_host preference" do
+          it "should override the application defaults" do
+            mail_method.set_preference(:mail_host, "smtp.example.com")
+            Spree::MailSettings.init
+            ActionMailer::Base.smtp_settings[:address].should == "smtp.example.com"
+          end
+        end
+
+        context "mail_domain preference" do
+          it "should override the application defaults" do
+            mail_method.set_preference(:mail_domain, "example.com")
+            Spree::MailSettings.init
+            ActionMailer::Base.smtp_settings[:domain].should == "example.com"
+          end
+        end
+
+        context "mail_port preference" do
+          it "should override the application defaults" do
+            mail_method.set_preference(:mail_port, "123")
+            Spree::MailSettings.init
+            ActionMailer::Base.smtp_settings[:port].should == "123"
+          end
+        end
+
+        context "smtp_username preference" do
+          it "should override the application defaults" do
+            mail_method.set_preference(:smtp_username, "schof")
+            Spree::MailSettings.init
+            ActionMailer::Base.smtp_settings[:user_name].should == "schof"
+          end
+        end
+
+        context "smtp_password preference" do
+          it "should override the application defaults" do
+            mail_method.set_preference(:smtp_password, "hellospree!")
+            Spree::MailSettings.init
+            ActionMailer::Base.smtp_settings[:password].should == "hellospree!"
+          end
+        end
+
+        context "secure_connection_type preference" do
+          it "should override the application defaults" do
+            mail_method.set_preference(:secure_connection_type, "TLS")
+            Spree::MailSettings.init
+            ActionMailer::Base.smtp_settings[:enable_starttls_auto].should be_true
+          end
+        end
+      end
+    end
+
+  end
+end

data/core/spec/models/address_spec.rb

@@ -0,0 +1,135 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Address do
+  context "validations" do
+    it { should belong_to(:country) }
+    it { should belong_to(:state) }
+    it { should have_many(:shipments) }
+    it { should validate_presence_of(:firstname) }
+    it { should validate_presence_of(:lastname) }
+    it { should validate_presence_of(:address1) }
+    it { should validate_presence_of(:city) }
+    it { should validate_presence_of(:zipcode) }
+    it { should validate_presence_of(:country) }
+    it { should validate_presence_of(:phone) }
+    it { should have_valid_factory(:address) }
+  end
+
+  context "factory" do
+    let(:address) { Factory(:address) }
+    specify { address.state.country.should == address.country }
+  end
+
+
+  context 'country usa already exists' do
+    let!(:country) { Factory(:country,  :iso_name => 'UNITED STATES',
+                                        :iso => 'US',
+                                        :name => 'United States',
+                                        :numcode => 840) }
+    let(:address) { Factory(:address) }
+    it 'should have country belonging to usa' do
+      address.country == country
+    end
+  end
+
+  context "validation" do
+    let(:state) { Factory(:state, :name => 'maryland', :abbr => 'md') }
+    before { Spree::Config.set :address_requires_state => true }
+
+    context "state_name is not nil and country does not have any states" do
+      let(:address) { Factory(:address, :state => nil, :state_name => 'alabama')}
+      specify { address.new_record?.should be_false }
+    end
+
+    context "state_name is nil" do
+      let(:address) { Factory.build(:address, :state => nil, :state_name => nil, :country => state.country)}
+      before { address.save }
+      specify { address.errors.full_messages.first.should == "State can't be blank" }
+    end
+
+    context "full state name is in state_name and country does contain that state" do
+      let(:address) { Factory(:address, :state => nil, :state_name => 'maryland', :country => state.country)}
+      before do
+        State.delete_all
+        Country.delete_all
+        @state = Factory(:state)
+        @address = Factory(:address, :state => nil, :state_name => @state.name, :country => @state.country)
+      end
+      specify do
+        address.should be_valid
+        address.state_id.should_not be_nil
+        address.state_name.should be_nil
+      end
+    end
+
+    context "state abbr is in state_name and country does contain that state" do
+        before do
+          State.delete_all
+          Country.delete_all
+          @state = Factory(:state)
+          @address = Factory(:address, :state => nil, :state_name => @state.abbr, :country => @state.country)
+        end
+      specify do
+        @address.should be_valid
+        @address.state_id.should_not be_nil
+        @address.state_name.should be_nil
+      end
+    end
+
+    context "state is entered but country does not contain that state" do
+      let(:address) { Factory.build(:address, :state => state, :country => Factory(:country))}
+      before { address.save }
+
+      specify { address.errors.full_messages.first.should == 'State is invalid' }
+    end
+
+    context "both state and state_name are entered but country does not contain the state" do
+      let(:address) { Factory(:address, :state => state, :state_name => 'maryland', :country => Factory(:country))}
+      specify do
+        address.should be_valid
+        address.state_id.should be_nil
+      end
+    end
+
+    context "both state and state_name are entered and country does contain the state" do
+      let(:address) { Factory(:address, :state => state, :state_name => 'maryland', :country => state.country)}
+      specify do
+        address.should be_valid
+        address.state_name.should be_nil
+      end
+    end
+
+    context "address_requires_state preference is false" do
+      before { Spree::Config.set :address_requires_state => false }
+
+      let(:address) { Factory(:address, :state => nil, :state_name => nil) }
+      specify { address.should be_valid }
+    end
+
+  end
+
+  context '#full_name' do
+    let(:address) { Factory(:address, :firstname => 'Michael', :lastname => 'Jackson') }
+    specify { address.full_name.should == 'Michael Jackson' }
+  end
+
+  context '#state_text' do
+    context 'state is blank' do
+      let(:address) { Factory(:address, :state => nil, :state_name => 'virginia') }
+      specify { address.state_text.should == 'virginia' }
+    end
+
+    context 'both name and abbr is present' do
+      let(:state) { Factory(:state, :name => 'virginia', :abbr => 'va') }
+      let(:address) { Factory(:address, :state => state) }
+      specify { address.state_text.should == 'va' }
+    end
+
+    context 'only name is present' do
+      let(:state) { Factory(:state, :name => 'virginia', :abbr => nil) }
+      let(:address) { Factory(:address, :state => state) }
+      specify { address.state_text.should == 'virginia' }
+    end
+
+  end
+end

data/core/spec/models/adjustment_spec.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Adjustment do
+
+  context 'validations' do
+    it { should have_valid_factory(:adjustment) }
+  end
+
+  context "factory_girl" do
+    before do
+      Order.delete_all
+      @order = Factory(:order)
+      @adjustment = Factory(:adjustment, :order => @order)
+    end
+    it 'should refer to the order that was passed to the factory' do
+      @adjustment.order.id.should == @order.id
+    end
+  end
+
+  let(:order) { mock_model(Order, :update! => nil) }
+  let(:adjustment) { Adjustment.new }
+  it "should accept a negative amount"
+
+  context "when amount is 0" do
+    before { adjustment.amount = 0 }
+    it "should be applicable if mandatory?" do
+      adjustment.mandatory = true
+      adjustment.applicable?.should be_true
+    end
+    it "should not be applicable unless mandatory?" do
+      adjustment.mandatory = false
+      adjustment.applicable?.should be_false
+    end
+  end
+
+  context "#update!" do
+    context "when originator present" do
+      let(:originator) { mock "originator" }
+      before do
+        originator.stub :update_amount => true
+        adjustment.stub :originator => originator
+      end
+      it "should do nothing when locked" do
+        adjustment.locked = true
+        originator.should_not_receive(:update_adjustment)
+        adjustment.update!
+      end
+      it "should ask the originator to update_adjustment" do
+        originator.should_receive(:update_adjustment)
+        adjustment.update!
+      end
+    end
+    it "should do nothing when originator is nil" do
+      adjustment.stub :originator => nil
+      adjustment.should_not_receive(:amount=)
+      adjustment.update!
+    end
+  end
+
+  context "#save" do
+    it "should call order#update!" do
+      adjustment = Adjustment.new(:order => order, :amount => 10, :label => "Foo")
+      order.should_receive(:update!)
+      adjustment.save
+    end
+  end
+end