effective_orders 1.0.0

data/spec/models/acts_as_purchasable_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+# # Attributes
+describe Product do
+  let(:user) { FactoryGirl.create(:user) }
+  let(:order) { FactoryGirl.create(:order) }
+  let(:product) { order.order_items.first.purchasable }
+  let(:product_with_float_price) { FactoryGirl.create(:product_with_float_price) }
+
+  describe 'assumptions' do
+    it 'should be effectively purchasable' do
+      product.is_effectively_purchasable?.should eq true
+    end
+  end
+
+  describe 'purchased' do
+    it 'is purchased? when in a purchased Order' do
+      order.purchase!('by a test')
+
+      product.purchased?.should eq true
+      product.purchased_orders.include?(order).should eq true
+    end
+
+    it 'is returned by the purchased scopes' do
+      order.purchase!('by a test')
+
+      Product.purchased.to_a.include?(product).should eq true
+      Product.purchased_by(order.user).to_a.include?(product).should eq true
+
+      Product.sold.to_a.include?(product).should eq true
+
+      Product.not_purchased.to_a.include?(product).should eq false
+    end
+  end
+
+  describe 'float prices' do
+    it 'should automatically convert float prices to integer' 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.subtotal.should eq 2000
+      order.tax.should eq 0
+      order.total.should eq 2000
+    end
+
+    it 'should automatically convert tax floats to integers' 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.subtotal.should eq 2000
+      order.tax.should eq 100
+      order.total.should eq 2100
+    end
+  end
+
+  describe 'price=' do
+    it 'should accept an integer price' do
+      product = Product.new()
+      product.price = 1250
+
+      product.price.should eq 1250
+    end
+
+    it 'should convert a String that looks like an Integer' do
+      product = Product.new()
+      product.price = '1250'
+
+      product.price.should eq 1250
+    end
+
+    it 'should convert a String that looks like a Float' do
+      product = Product.new()
+      product.price = '12.50'
+
+      product.price.should eq 1250
+    end
+
+    it 'should convert from a Float' do
+      product = Product.new()
+      product.price = 12.50
+      product.price.should eq 1250
+
+      product.price = Float(12.50)
+      product.price.should eq 1250
+    end
+
+    it 'should convert from a BigDecimal' do
+      product = Product.new()
+      product.price = BigDecimal.new(12.5, 4)
+
+      product.price.should eq 1250
+    end
+
+    it 'should treat nil as a zero' do
+      product = Product.new()
+      product.price = nil
+
+      product.price.should eq 0
+    end
+
+  end
+
+end

data/spec/models/customer_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+require 'stripe_mock'
+
+# # Attributes
+describe Effective::Customer do
+  let(:customer) { FactoryGirl.create(:customer) }
+  let(:user) { FactoryGirl.create(:user) }
+
+  describe 'Customer.for_user' do
+    it 'creates a new Customer when passed a new user' do
+      c = Effective::Customer.for_user(user)
+
+      c.kind_of?(Effective::Customer).should eq true
+      c.persisted?.should eq true
+      c.valid?.should eq true
+      c.user.should eq user
+    end
+
+    it 'returns an existing Customer when passed an existing user' do
+      c =  Effective::Customer.for_user(customer.user)
+      c.should eq customer
+    end
+  end
+
+  describe 'Stripe Integration' do
+    before { StripeMock.start }
+    after { StripeMock.stop }
+
+    describe '#stripe_customer' do
+      it 'creates a new Stripe::Customer if one doesnt exist.' do
+        stripe_customer = customer.stripe_customer
+
+        stripe_customer.kind_of?(::Stripe::Customer).should eq true
+
+        stripe_customer.email.should eq customer.user.email
+        stripe_customer.id.should eq customer.stripe_customer_id
+      end
+
+      it 'retrieves an existing Stripe::Customer if exists' do
+        # Test set up. Create the user.
+        user = customer.user
+        stripe_customer = ::Stripe::Customer.create(:email => user.email, :description => user.id.to_s)
+        customer.update_attributes(:stripe_customer_id => stripe_customer.id)
+
+        customer.reload
+
+        customer.stripe_customer.id.should eq stripe_customer.id
+      end
+    end
+
+    describe '#update_card' do
+      it 'can update the card' do
+        customer.update_card!('sometoken').should eq true
+      end
+
+      it 'updates stripe_active_card when updating the card' do
+        customer.should_receive(:save!).and_return(true)
+        customer.update_card!('sometoken').should eq true
+
+        customer.stripe_active_card.present?.should eq true
+      end
+
+    end
+
+  end
+
+
+
+
+end

data/spec/models/factories_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+# Attributes
+describe 'Factories' do
+  let(:factories) { [:user, :customer, :subscription, :address, :product, :cart, :order_item, :order, :purchased_order, :declined_order, :cart_with_subscription, :order_with_subscription] }
+
+  before { StripeMock.start }
+  after { StripeMock.stop }
+
+  it 'should have all valid factories' do
+    factories.each { |factory| FactoryGirl.create(factory).valid?.should eq true }
+  end
+end

data/spec/models/order_item_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+# # Attributes
+describe Effective::OrderItem do
+  let(:order) { FactoryGirl.create(:order) }
+  let(:order_item) { FactoryGirl.create(:order_item) }
+
+  describe 'validations' do
+    it 'is invalid without required fields' do
+      order_item = Effective::OrderItem.new()
+      order_item.valid?.should eq false
+
+      order_item.errors[:title].present?.should eq true
+      order_item.errors[:quantity].present?.should eq true
+      order_item.errors[:tax_exempt].present?.should eq true
+      order_item.errors[:purchasable].present?.should eq true
+    end
+  end
+
+  describe 'scopes' do
+    it 'is included in the Sold scope when order is purchased' do
+      order.purchase!('from a test')
+      (order.order_items.size > 0).should eq true
+
+      sold_items = Effective::OrderItem.sold.to_a
+      sold_items.size.should eq order.order_items.size
+
+      order.order_items.each { |oi| sold_items.include?(oi).should eq true }
+    end
+
+  end
+
+
+
+end

data/spec/models/order_spec.rb

@@ -0,0 +1,323 @@
+require 'spec_helper'
+
+describe Effective::Order do
+  let(:cart) { FactoryGirl.create(:cart) }
+  let(:order) { FactoryGirl.create(:order) }
+  let(:user) { FactoryGirl.create(:user) }
+  let(:product) { FactoryGirl.create(:product) }
+  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.num_items.should eq order.order_items.collect(&:quantity).sum
+  end
+
+  describe '#initialize' do
+    it 'creates appropriate OrderItems when initialized with a Cart' do
+      order = Effective::Order.new(cart)
+
+      order.order_items.each_with_index do |order_item, x|
+        order_item.title.should eq cart.cart_items[x].title
+        order_item.price.should eq cart.cart_items[x].price
+        order_item.quantity.should eq cart.cart_items[x].quantity
+        order_item.purchasable.should eq cart.cart_items[x].purchasable
+      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
+      order = Effective::Order.new([product, product2])
+      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
+      order = Effective::Order.new(product)
+      order.order_items.size.should eq 1
+
+      order_item = order.order_items.first
+
+      order_item.title.should eq product.title
+      order_item.price.should eq product.price
+      order_item.purchasable.should eq product
+      order_item.quantity.should eq 1
+    end
+
+    it 'throws an ArgumentError when passed something unexpected' do
+      expect { Effective::Order.new(Object.new()) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe 'minimum zero math' do
+    it 'has a minimum order total of 0' do
+      order.order_items.each { |order_item| order_item.stub(:total).and_return(-1000) }
+
+      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| order_item.stub(:subtotal).and_return(-1000) }
+
+      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| order_item.stub(:tax).and_return(-1000) }
+
+      order.order_items.collect(&:tax).sum.should eq -3000
+      order.tax.should eq 0
+    end
+  end
+
+  describe 'user=' do
+    it 'assigns the user' do
+      order = Effective::Order.new()
+      order.user = user
+      order.user.should eq user
+    end
+
+    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)
+
+      order.user = user
+
+      order.billing_address.should eq user.billing_address
+      order.save_billing_address.should eq true
+
+      order.shipping_address.should eq user.shipping_address
+      order.save_shipping_address.should eq true
+    end
+  end
+
+  describe 'validations' do
+    it 'should be invalid without a user or order_items' do
+      order = Effective::Order.new()
+      order.valid?.should eq false
+
+      order.errors[:user_id].present?.should eq true
+      order.errors[:order_items].present?.should eq true
+    end
+
+    it 'should be invalid when user is invalid' do
+      order.user.stub(:valid?).and_return(false)
+      order.valid?.should eq false
+
+      order.errors[:user].present?.should eq true
+    end
+
+    it 'should be invalid when an order_item is invalid' do
+      order.order_items.first.stub(:valid?).and_return(false)
+      order.valid?.should eq false
+
+      order.errors[:order_items].present?.should eq true
+    end
+
+    it 'should be invalid when less than the minimum charge' do
+      order.stub(:total).and_return(49)
+
+      order.valid?.should eq false
+
+      order.errors[:total].present?.should eq true
+      order.errors[:total].first.downcase.include?('minimum order of 50 is required').should eq true
+    end
+
+    it 'should be valid when >= minimum charge' do
+      order.stub(:total).and_return(50)
+      order.valid?.should eq true
+
+      order.stub(:total).and_return(51)
+      order.valid?.should eq true
+    end
+
+    it 'should be valid for a free order' do
+      order.order_items.each { |order_item| order_item.stub(:total).and_return(0) }
+
+      order.valid?.should eq true
+      order.errors[:total].present?.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_state.should eq EffectiveOrders::PURCHASED
+      order.purchased_at.kind_of?(Time).should eq true
+      order.payment[:details].should eq 'by a test'
+    end
+
+    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')
+    end
+
+    it 'throws an error when purchased twice' do
+      order.purchase!('first time')
+
+      expect { order.purchase!('second time') }.to raise_error(EffectiveOrders::AlreadyPurchasedException)
+    end
+
+    it 'sends emails to the admin, buyer and seller' do
+      Effective::OrdersMailer.deliveries.clear
+
+      order.purchase!('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[1].to.first.should eq order.user.email
+      Effective::OrdersMailer.deliveries[1].subject.include?("Order ##{order.to_param} Receipt").should eq true
+    end
+
+    it 'does not send email if passed :email => false' do
+      Effective::OrdersMailer.deliveries.clear
+
+      order.purchase!('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')
+      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')
+      Effective::Order.declined.to_a.include?(order).should eq false
+    end
+
+    it 'should return false when the Order is invalid' do
+      order.stub(:valid?).and_return(false)
+      expect { order.purchase!('by a test') }.to raise_exception
+    end
+
+    it 'should return true when the Order is invalid and :validate => false is passed' do
+      order.stub(:valid?).and_return(false)
+      order.purchase!('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.purchased?.should eq true
+    end
+
+    it 'returns false when not purchased' do
+      order.purchased?.should eq false
+    end
+
+    it 'returns false when declined' do
+      order.decline!('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.purchase_state.should eq EffectiveOrders::DECLINED
+      order.payment[:details].should eq 'by a test'
+      order.purchased_at.should eq nil
+    end
+
+    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')
+    end
+
+    it 'throws an error when declined twice' do
+      order.decline!('first time')
+
+      expect { order.decline!('second time') }.to raise_error(EffectiveOrders::AlreadyDeclinedException)
+    end
+
+    it 'is included with the declined scope' do
+      order.decline!('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')
+      Effective::Order.purchased.to_a.include?(order).should eq false
+      Effective::Order.purchased_by(order.user).to_a.include?(order).should eq false
+    end
+  end
+
+  describe 'declined?' do
+    it 'returns true when a declined order' do
+      order.decline!('by a test')
+      order.declined?.should eq true
+    end
+
+    it 'returns false when not declined' do
+      order.declined?.should eq false
+    end
+
+    it 'returns false when purchased' do
+      order.purchase!('by a test')
+      order.declined?.should eq false
+    end
+  end
+
+  describe '#save_billing_address?' do
+    it 'is true when save_billing_address is 1' do
+      order.save_billing_address = '1'
+      order.save_billing_address?.should eq true
+    end
+
+    it 'is false when save_billing_address is 0' do
+      order.save_billing_address = '0'
+      order.save_billing_address?.should eq false
+    end
+
+    it 'is false when save_billing_address is nil' do
+      order.save_billing_address = nil
+      order.save_billing_address?.should eq false
+    end
+  end
+
+  describe '#save_shipping_address?' do
+    it 'is true when save_shipping_address is 1' do
+      order.save_shipping_address = '1'
+      order.save_shipping_address?.should eq true
+    end
+
+    it 'is false when save_shipping_address is 0' do
+      order.save_shipping_address = '0'
+      order.save_shipping_address?.should eq false
+    end
+
+    it 'is false when save_shipping_address is nil' do
+      order.save_shipping_address = nil
+      order.save_shipping_address?.should eq false
+    end
+  end
+
+  describe '#to_param' do
+    it 'returns an obfuscated ID' do
+      (order.to_param.length >= 10).should eq true
+    end
+  end
+
+
+end

data/spec/models/stripe_charge_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+# # Attributes
+describe Effective::StripeCharge do
+  let(:order) { FactoryGirl.create(:order_with_subscription) }
+  let(:charge) { Effective::StripeCharge.new(order) }
+
+  before { StripeMock.start }
+  after { StripeMock.stop }
+
+  it 'can be initialized with an order' do
+    charge = Effective::StripeCharge.new(order)
+    charge.order.should eq order
+    charge.effective_order_id.should eq order.to_param
+  end
+
+  it 'can be initialized without an order' do
+    charge = Effective::StripeCharge.new(:token => 'tok_123', :effective_order_id => 3)
+    charge.token.should eq 'tok_123'
+    charge.effective_order_id.should eq 3
+    charge.order.nil?.should eq true
+  end
+
+  it 'performs validations' do
+    charge = Effective::StripeCharge.new()
+    charge.valid?.should eq false
+    charge.errors[:token].present?.should eq true
+    charge.errors[:effective_order_id].present?.should eq true
+  end
+
+  it '#order_items returns all OrderItems where the purchasable is not a Subscription' do
+    charge.order_items.all? { |oi| oi.purchasable_type != 'Effective::Subscription'}.should eq true
+  end
+
+  it '#subscriptions returns all Subscriptions (not order items)' do
+    charge.subscriptions.all? { |oi| oi.kind_of?(Effective::Subscription) }.should eq true
+  end
+
+end

data/spec/models/subscription_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+# # Attributes
+describe Effective::Subscription do
+  let(:subscription) { FactoryGirl.create(:subscription) }
+
+  before { StripeMock.start }
+  after { StripeMock.stop }
+
+  describe '#stripe_plan' do
+
+  end
+
+  describe '#stripe_plan_id=' do
+    it 'assigns the stripe_plan_id' do
+      subscription.stripe_plan_id = 'Plan 9'
+      subscription.stripe_plan_id.should eq 'Plan 9'
+    end
+
+    it 'rejects an invalid stripe_plan' do
+      subscription.stripe_plan.present?.should eq true  # From the Factory
+
+      subscription.stripe_plan_id = 'Plan 9'  # Set it to an Invalid plan
+      subscription.stripe_plan_id.should eq 'Plan 9'
+
+      subscription.stripe_plan.should eq nil
+    end
+
+    it 'sets the stripe plan' do
+      subscription = Effective::Subscription.new()
+
+      plan = ::Stripe::Plan.create()
+      subscription.stripe_plan_id = plan.id
+      subscription.stripe_plan.id.should eq plan.id
+    end
+  end
+
+  describe '#stripe_coupon_id=' do
+    it 'assigns the stripe_coupon_id' do
+      subscription.stripe_coupon_id = 'Plan 9'
+      subscription.stripe_coupon_id.should eq 'Plan 9'
+    end
+
+    it 'rejects an invalid stripe_coupon' do
+      subscription.stripe_coupon.present?.should eq true  # From the Factory
+
+      subscription.stripe_coupon_id = 'Plan 9'  # Set it to an Invalid plan
+      subscription.stripe_coupon_id.should eq 'Plan 9'
+
+      subscription.stripe_coupon.should eq nil
+    end
+
+    it 'sets the stripe coupon' do
+      subscription = Effective::Subscription.new()
+
+      coupon = ::Stripe::Coupon.create()
+      subscription.stripe_coupon_id = coupon.id
+      subscription.stripe_coupon.id.should eq coupon.id
+    end
+  end
+
+  describe '#assign_price_and_title' do
+    it 'assigns the price and title as per the stripe plan and coupon' do
+      subscription = Effective::Subscription.new()
+
+      plan = ::Stripe::Plan.create()
+
+      subscription.stripe_plan_id = plan.id
+
+      subscription.price.should eq plan.amount
+      subscription.title.include?(plan.name).should eq true
+      subscription.title.include?(plan.interval).should eq true
+    end
+
+    it 'assigns the price and title as per the stripe plan and coupon amount off' do
+      subscription = Effective::Subscription.new()
+
+      plan = ::Stripe::Plan.create()
+      coupon = ::Stripe::Coupon.create(:percent_off => 25)
+
+      subscription.stripe_plan_id = plan.id
+      subscription.stripe_coupon_id = coupon.id
+
+      subscription.price.should eq (plan.amount * (coupon.percent_off.to_i / 100.0)).floor
+      subscription.title.include?('25% off').should eq true
+    end
+
+    it 'assigns the price and title as per the stripe plan and coupon percent off' do
+      subscription = Effective::Subscription.new()
+
+      plan = ::Stripe::Plan.create()
+      coupon = ::Stripe::Coupon.create(:percent_off => nil, :amount_off => 100)
+
+      subscription.stripe_plan_id = plan.id
+      subscription.stripe_coupon_id = coupon.id
+
+      subscription.price.should eq plan.amount - coupon.amount_off
+      subscription.title.include?('$1.00 off').should eq true
+    end
+  end
+
+
+end