effective_orders 1.8.1 → 2.0.0

data/spec/models/acts_as_purchasable_spec.rb

@@ -9,13 +9,13 @@ describe Product do
 
   describe 'assumptions' do
     it 'should be effectively purchasable' do
-      product.is_effectively_purchasable?.should eq true
+      product.kind_of?(ActsAsPurchasable).should eq true
     end
   end
 
   describe 'purchased' do
     it 'is purchased? when in a purchased Order' do
-      order.purchase!('by a test')
+      order.purchase!
 
       product.purchased?.should eq true
       product.purchased_orders.include?(order).should eq true
@@ -36,7 +36,7 @@ describe Product do
         end
       end
 
-      order.purchase!('by a test')
+      order.purchase!
 
       instance_order.purchased?.should eq true
       instance_product.purchased?.should eq true
@@ -44,7 +44,7 @@ describe Product do
     end
 
     it 'is returned by the purchased scopes' do
-      order.purchase!('by a test')
+      order.purchase!
 
       Product.purchased.to_a.include?(product).should eq true
       Product.purchased_by(order.user).to_a.include?(product).should eq true
@@ -60,7 +60,8 @@ describe Product do
       product_with_float_price.price = 20.00
       product_with_float_price.tax_exempt = true
 
-      order = Effective::Order.new(product_with_float_price, user)
+      order = Effective::Order.new(product_with_float_price, user: user)
+      order.billing_address = FactoryGirl.create(:address, state_code: 'AB')
 
       order.subtotal.should eq 2000
       order.tax.should eq 0
@@ -71,7 +72,8 @@ describe Product do
       product_with_float_price.price = 20.00
       product_with_float_price.tax_exempt = false
 
-      order = Effective::Order.new(product_with_float_price, user)
+      order = Effective::Order.new(product_with_float_price, user: user)
+      order.billing_address = FactoryGirl.create(:address, state_code: 'AB')
 
       order.subtotal.should eq 2000
       order.tax.should eq 100

data/spec/models/factories_spec.rb

@@ -8,7 +8,13 @@ describe 'Factories' do
   after { StripeMock.stop }
 
   it 'should have all valid factories' do
-    factories.each { |factory| FactoryGirl.create(factory).valid?.should eq true }
+    factories.each do |factory|
+      obj = FactoryGirl.create(factory)
+
+      puts "Invalid factory #{factory}: #{obj.errors.inspect}" unless obj.valid?
+
+      obj.valid?.should eq true
+    end
   end
 
   it 'should have created an Order with a billing_address and shipping_address' do

data/spec/models/order_item_spec.rb

@@ -19,7 +19,7 @@ describe Effective::OrderItem do
 
   describe 'scopes' do
     it 'is included in the Sold scope when order is purchased' do
-      order.purchase!('from a test')
+      order.purchase!
       (order.order_items.size > 0).should eq true
 
       sold_items = Effective::OrderItem.sold.to_a

data/spec/models/order_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Effective::Order do
+describe Effective::Order, type: :model do
   let(:cart) { FactoryGirl.create(:cart) }
   let(:order) { FactoryGirl.create(:order) }
   let(:user) { FactoryGirl.create(:user) }
@@ -8,9 +8,8 @@ describe Effective::Order do
   let(:product2) { FactoryGirl.create(:product) }
 
   it 'calculates dollars based on its order items' do
-    order.total.should eq order.order_items.collect(&:total).sum
     order.subtotal.should eq order.order_items.collect(&:subtotal).sum
-    order.tax.should eq order.order_items.collect(&:tax).sum
+    order.total.should eq (order.order_items.collect(&:subtotal).sum + order.tax.to_i)
     order.num_items.should eq order.order_items.collect(&:quantity).sum
   end
 
@@ -26,9 +25,7 @@ describe Effective::Order do
       end
 
       order.order_items.length.should eq cart.cart_items.length
-      order.total.should eq cart.total
       order.subtotal.should eq cart.subtotal
-      order.tax.should eq cart.tax
     end
 
     it 'creates appropriate OrderItems when initialized with an array of purchasables' do
@@ -36,7 +33,6 @@ describe Effective::Order do
       order.order_items.size.should eq 2
 
       order.subtotal.should eq (product.price + product2.price)
-      order.total.should eq ((product.price + product2.price) * 1.05)
     end
 
     it 'creates appropriate OrderItems when initialized with a single purchasable' do
@@ -58,24 +54,22 @@ describe Effective::Order do
 
   describe 'minimum zero math' do
     it 'has a minimum order total of 0' do
-      order.order_items.each { |order_item| allow(order_item).to receive(:total).and_return(-1000) }
+      order.subtotal = nil
+      order.total = nil
 
+      order.order_items.each { |oi| oi.price = -1000; oi.tax_exempt = true; }
       order.order_items.collect(&:total).sum.should eq -3000
+
       order.total.should eq 0
     end
 
     it 'has no minimum subtotal' do
-      order.order_items.each { |order_item| allow(order_item).to receive(:subtotal).and_return(-1000) }
+      order.subtotal = nil
 
+      order.order_items.each { |oi| oi.price = -1000; oi.tax_exempt = true; }
       order.order_items.collect(&:subtotal).sum.should eq -3000
-      order.subtotal.should eq -3000
-    end
 
-    it 'has a minimum order tax of 0.00' do
-      order.order_items.each { |order_item| allow(order_item).to receive(:tax).and_return(-1000) }
-
-      order.order_items.collect(&:tax).sum.should eq -3000
-      order.tax.should eq 0
+      order.subtotal.should eq -3000
     end
   end
 
@@ -89,8 +83,8 @@ describe Effective::Order do
     it 'assigns addresses from the user' do
       order = Effective::Order.new()
 
-      user.billing_address = FactoryGirl.create(:address, :category => :billing)
-      user.shipping_address = FactoryGirl.create(:address, :category => :shipping)
+      user.billing_address = FactoryGirl.create(:address, category: :billing)
+      user.shipping_address = FactoryGirl.create(:address, category: :shipping)
 
       order.user = user
 
@@ -103,6 +97,10 @@ describe Effective::Order do
   end
 
   describe 'validations' do
+    it 'should validate inclusion of purchase state' do
+      expect(subject).to validate_inclusion_of(:purchase_state).in_array([nil, EffectiveOrders::PURCHASED, EffectiveOrders::DECLINED, EffectiveOrders::PENDING])
+    end
+
     it 'should be invalid without a user or order_items' do
       order = Effective::Order.new()
       order.valid?.should eq false
@@ -126,8 +124,7 @@ describe Effective::Order do
     end
 
     it 'should be invalid when less than the minimum charge' do
-      allow(order).to receive(:total).and_return(49)
-
+      order.order_items.each { |oi| oi.price = 1 }
       order.valid?.should eq false
 
       order.errors[:total].present?.should eq true
@@ -150,9 +147,125 @@ describe Effective::Order do
     end
   end
 
+  describe 'tax and tax rate' do
+    it 'is invalid with no tax rate' do
+      order = Effective::Order.new()
+      order.tax_rate.should eq nil
+      order.valid?.should eq false
+      order.errors[:tax_rate].present?.should eq true
+    end
+
+    it 'is valid with no tax rate when skip_buyer_validations = true' do
+      order = Effective::Order.new()
+      order.skip_buyer_validations = true
+      order.tax_rate.should eq nil
+      order.errors[:tax_rate].present?.should eq false
+    end
+
+    it 'sets a tax rate when billing_address is present' do
+      order = FactoryGirl.create(:order)
+      order.billing_address.present?.should eq true
+      order.valid?.should eq true
+      order.errors[:tax_rate].blank?.should eq true
+    end
+
+    it 'updates the tax rate on valid? when billing_address changes' do
+      order = FactoryGirl.create(:order)
+
+      order.billing_address = FactoryGirl.create(:address, state_code: 'AB') # 5.0% tax
+      order.valid?.should eq true
+      order.tax_rate.should eq 5.0
+      order.tax.should eq (order.subtotal * 0.05)
+      order.total.should eq (order.subtotal + order.tax)
+      total_one = order.total
+
+      order.billing_address = FactoryGirl.create(:address, state_code: 'ON') # 13.0% tax
+      order.valid?.should eq true
+      order.tax_rate.should eq 13.0
+      order.tax.should eq (order.subtotal * 0.13)
+      order.total.should eq (order.subtotal + order.tax)
+      total_two = order.total
+
+      total_one.should_not eq total_two
+    end
+
+  end
+
+  describe 'create_as_pending' do
+    it 'sets the pending state' do
+      order = FactoryGirl.build(:order)
+      order.order_items << FactoryGirl.build(:order_item, order: order)
+
+      order.create_as_pending.should eq true
+      order.pending?.should eq true
+    end
+
+    it 'disregards invalid addresses' do
+      order = FactoryGirl.build(:order)
+      order.order_items << FactoryGirl.build(:order_item, order: order)
+
+      order.billing_address = Effective::Address.new(address1: 'invalid')
+      order.shipping_address = Effective::Address.new(address1: 'invalid')
+
+      success = order.create_as_pending
+
+      success.should eq true
+    end
+
+    it 'sends a request for payment when send_payment_request_to_buyer is true' do
+      Effective::OrdersMailer.deliveries.clear
+
+      order = FactoryGirl.build(:order)
+      order.order_items << FactoryGirl.build(:order_item, order: order)
+
+      order.send_payment_request_to_buyer = true
+
+      order.create_as_pending.should eq true
+      order.send_payment_request_to_buyer?.should eq true
+
+      Effective::OrdersMailer.deliveries.length.should eq 1
+    end
+
+    it 'does not send a request for payment when send_payment_request_to_buyer is false' do
+      Effective::OrdersMailer.deliveries.clear
+
+      order = FactoryGirl.build(:order)
+      order.order_items << FactoryGirl.build(:order_item, order: order)
+
+      order.create_as_pending.should eq true
+
+      Effective::OrdersMailer.deliveries.length.should eq 0
+    end
+
+  end
+
+  describe 'save as pending' do
+    let(:order) { FactoryGirl.build(:order, billing_address: FactoryGirl.build(:address), shipping_address: FactoryGirl.build(:address)) }
+
+    it 'sets the pending state' do
+      order.order_items << FactoryGirl.build(:order_item, order: order)
+
+      order.purchase_state = EffectiveOrders::PENDING
+
+      order.save.should eq true
+      order.pending?.should eq true
+    end
+
+    it 'does not accept invalid addresses' do
+      order.order_items << FactoryGirl.build(:order_item, order: order)
+
+      order.billing_address = Effective::Address.new(address1: 'invalid')
+      order.shipping_address = Effective::Address.new(address1: 'invalid')
+
+      order.purchase_state = EffectiveOrders::PENDING
+
+      order.save.should eq false
+    end
+  end
+
   describe 'purchase!' do
     it 'assigns the purchase_state, purchase_at and payment' do
-      order.purchase!('by a test').should eq true
+      order.purchase!(details: 'by a test').should eq true
 
       order.purchase_state.should eq EffectiveOrders::PURCHASED
       order.purchased_at.kind_of?(Time).should eq true
@@ -161,62 +274,62 @@ describe Effective::Order do
 
     it 'sends purchased callback to all order_items' do
       order.order_items.each { |oi| oi.purchasable.should_receive(:purchased!).with(order, oi) }
-      order.purchase!('by a test')
+      order.purchase!(details: 'by a test')
     end
 
     it 'returns true when purchased twice' do
-      order.purchase!('first time by a test')
-      order.purchase!('second time by a test').should eq false
+      order.purchase!(details: 'first time by a test')
+      order.purchase!(details: 'second time by a test').should eq false
     end
 
     it 'sends emails to the admin, buyer and seller' do
       Effective::OrdersMailer.deliveries.clear
 
-      order.purchase!('by a test')
+      order.purchase!(details: 'by a test')
 
       Effective::OrdersMailer.deliveries.length.should eq 2
 
       Effective::OrdersMailer.deliveries[0].to.first.should eq 'admin@example.com'
-      Effective::OrdersMailer.deliveries[0].subject.include?("Order ##{order.to_param} Receipt").should eq true
+      Effective::OrdersMailer.deliveries[0].subject.include?("Order Receipt: ##{order.to_param}").should eq true
 
       Effective::OrdersMailer.deliveries[1].to.first.should eq order.user.email
-      Effective::OrdersMailer.deliveries[1].subject.include?("Order ##{order.to_param} Receipt").should eq true
+      Effective::OrdersMailer.deliveries[1].subject.include?("Order Receipt: ##{order.to_param}").should eq true
     end
 
-    it 'does not send email if passed :email => false' do
+    it 'does not send email if passed email: false' do
       Effective::OrdersMailer.deliveries.clear
 
-      order.purchase!('by a test', :email => false)
+      order.purchase!(details: 'by a test', email: false)
 
       Effective::OrdersMailer.deliveries.length.should eq 0
     end
 
     it 'is included with the purchased scope' do
-      order.purchase!('by a test')
+      order.purchase!(details: 'by a test')
       Effective::Order.purchased.to_a.include?(order).should eq true
       Effective::Order.purchased_by(order.user).to_a.include?(order).should eq true
     end
 
     it 'is not included with the declined scope' do
-      order.purchase!('by a test')
+      order.purchase!(details: 'by a test')
       Effective::Order.declined.to_a.include?(order).should eq false
     end
 
     it 'should return false when the Order is invalid' do
       allow(order).to receive(:valid?).and_return(false)
-      expect { order.purchase!('by a test') }.to raise_exception(Exception)
+      expect { order.purchase!(details: 'by a test') }.to raise_exception(Exception)
     end
 
-    it 'should return true when the Order is invalid and :validate => false is passed' do
+    it 'should return true when the Order is invalid and validate: false is passed' do
       allow(order).to receive(:valid?).and_return(false)
-      order.purchase!('by a test', :validate => false).should eq true
+      order.purchase!(details: 'by a test', validate: false).should eq true
     end
 
   end
 
   describe 'purchased?' do
     it 'returns true when a purchased order' do
-      order.purchase!('by a test')
+      order.purchase!(details: 'by a test')
       order.purchased?.should eq true
     end
 
@@ -225,14 +338,14 @@ describe Effective::Order do
     end
 
     it 'returns false when declined' do
-      order.decline!('by a test')
+      order.decline!(details: 'by a test')
       order.purchased?.should eq false
     end
   end
 
   describe 'decline!' do
     it 'assigns the purchase_state' do
-      order.decline!('by a test').should eq true
+      order.decline!(details: 'by a test').should eq true
 
       order.purchase_state.should eq EffectiveOrders::DECLINED
       order.payment[:details].should eq 'by a test'
@@ -241,26 +354,26 @@ describe Effective::Order do
 
     it 'sends declined callback to all order_items' do
       order.order_items.each { |oi| oi.purchasable.should_receive(:declined!).with(order, oi) }
-      order.decline!('by a test')
+      order.decline!(details: 'by a test')
     end
 
     it 'returns false when declined twice' do
-      order.decline!('first time')
-      order.decline!('second time').should eq false
+      order.decline!(details: 'first time')
+      order.decline!(details: 'second time').should eq false
     end
 
     it 'returns false when declined twice' do
-      order.decline!('first time')
-      order.decline!('second time').should eq false
+      order.decline!(details: 'first time')
+      order.decline!(details: 'second time').should eq false
     end
 
     it 'is included with the declined scope' do
-      order.decline!('by a test')
+      order.decline!(details: 'by a test')
       Effective::Order.declined.to_a.include?(order).should eq true
     end
 
     it 'is not included with the purchased scope' do
-      order.decline!('by a test')
+      order.decline!(details: 'by a test')
       Effective::Order.purchased.to_a.include?(order).should eq false
       Effective::Order.purchased_by(order.user).to_a.include?(order).should eq false
     end
@@ -268,7 +381,7 @@ describe Effective::Order do
 
   describe 'declined?' do
     it 'returns true when a declined order' do
-      order.decline!('by a test')
+      order.decline!(details: 'by a test')
       order.declined?.should eq true
     end
 
@@ -277,7 +390,7 @@ describe Effective::Order do
     end
 
     it 'returns false when purchased' do
-      order.purchase!('by a test')
+      order.purchase!(details: 'by a test')
       order.declined?.should eq false
     end
   end
@@ -322,5 +435,11 @@ describe Effective::Order do
     end
   end
 
-
+  describe '#pending?' do
+    it 'should return true for pending orders only' do
+      expect(FactoryGirl.create(:purchased_order).pending?).to be_falsey
+      expect(FactoryGirl.create(:declined_order).pending?).to be_falsey
+      expect(FactoryGirl.create(:pending_order).pending?).to be_truthy
+    end
+  end
 end