effective_orders 3.0.0 → 3.0.1

data/spec/controllers/carts_controller_spec.rb

@@ -1,143 +0,0 @@
-require 'spec_helper'
-
-describe Effective::CartsController, type: :controller do
-  routes { EffectiveOrders::Engine.routes }
-
-  let(:user) { FactoryGirl.create(:user) }
-  let(:cart) { FactoryGirl.create(:cart) }
-  let(:product) { FactoryGirl.create(:product) }
-
-  describe 'First time user - not logged in' do
-    it 'creates a new cart and set the session[:cart]' do
-      get :show
-      assigns(:cart).id.should eq session[:cart]
-      assigns(:cart).size.should eq 0
-    end
-
-    it 'allows me to add_to_cart' do
-      get :add_to_cart, :purchasable_type => product.class, :purchasable_id => product.id
-      assigns(:cart).size.should eq 1
-      assigns(:cart).find(product).present?.should eq true
-    end
-
-    it 'allow me to remove_from_cart' do
-      get :add_to_cart, :purchasable_type => product.class, :purchasable_id => product.id
-      assigns(:cart).size.should eq 1
-      assigns(:cart).find(product).present?.should eq true
-
-      delete :remove_from_cart, :id => assigns(:cart).cart_items.first.id
-      assigns(:cart).reload.size.should eq 0
-      assigns(:cart).find(product).present?.should eq false
-    end
-
-    it 'allow me to destroy the cart' do
-      get :add_to_cart, :purchasable_type => product.class, :purchasable_id => product.id
-      assigns(:cart).size.should eq 1
-
-      delete :destroy
-      response.should redirect_to('/cart')
-
-      # This redirects me, and reassigns the @cart
-      assigns(:cart).size.should eq 0
-    end
-  end
-
-  describe 'Logging in' do
-    describe 'with no previous cart' do
-      it 'assigns a new cart and unsets session[:cart]' do
-        session[:cart] = 12
-        sign_in user
-
-        get :show
-
-        assigns(:cart).user.should eq user
-        assigns(:cart).size.should eq 0
-
-        session[:cart].should eq nil
-      end
-    end
-
-    describe 'with an existing cart' do
-      it 'assigns me the existing cart' do
-        sign_in cart.user
-        get :show
-        assigns(:cart).should eq cart
-        assigns(:cart).size.should eq 3 # As per our factory
-        session[:cart].should eq nil
-      end
-    end
-
-    describe 'with no existing user cart, and a session cart full of items' do
-      it 'copies the session cart items into the user cart' do
-        get :show
-        assigns(:cart).id.should eq session[:cart]
-        assigns(:cart).size.should eq 0
-
-        get :add_to_cart, :purchasable_type => product.class, :purchasable_id => product.id
-        assigns(:cart).size.should eq 1
-        assigns(:cart).find(product).present?.should eq true
-
-        sign_in user
-        controller.instance_variable_set(:@cart, nil) # This is what happens in a real RailsController. zzz.
-
-        get :show
-
-        assigns(:cart).user.should eq user
-        assigns(:cart).size.should eq 1
-        assigns(:cart).find(product).present?.should eq true
-      end
-    end
-
-    describe 'with an existing user cart, and a session cart full of items' do
-      it 'merges the session cart into the user cart and destroy the session cart' do
-        get :show
-        session_cart = session[:cart]
-
-        assigns(:cart).id.should eq session[:cart]
-        assigns(:cart).size.should eq 0
-
-        get :add_to_cart, :purchasable_type => product.class, :purchasable_id => product.id
-        assigns(:cart).size.should eq 1
-        assigns(:cart).find(product).present?.should eq true
-
-        sign_in cart.user
-        controller.instance_variable_set(:@cart, nil) # This is what happens in a real RailsController. zzz.
-
-        get :show
-        assigns(:cart).user.should eq cart.user
-        assigns(:cart).cart_items.length.should eq 4 # the 3 from my factory, and 1 more we just created
-        assigns(:cart).find(product).present?.should eq true
-
-        Effective::Cart.where(:id => session_cart).should eq []
-      end
-    end
-  end
-
-  describe '#add_to_cart' do
-    before(:each) do
-      sign_in cart.user
-    end
-
-    it 'provides a useful error when passed an unknown purchasable_id' do
-      get :add_to_cart, :purchasable_type => product.class, :purchasable_id => 'asdf'
-
-      assigns(:purchasable).should eq nil
-      flash[:danger].include?('Unable to add item').should eq true
-    end
-
-    it 'provides a useful error when passed an unknown purchasable_type' do
-      get :add_to_cart, :purchasable_type => 'Something', :purchasable_id => product.id
-
-      assigns(:purchasable).should eq nil
-      flash[:danger].include?('Unable to add item').should eq true
-    end
-  end
-
-  describe '#remove_from_cart' do
-    it 'throws ActiveRecord::RecordNotFound when passed an invalid ID' do
-      expect { delete :remove_from_cart, :id => 12345 }.to raise_error(ActiveRecord::RecordNotFound)
-      assigns(:cart_item).should eq nil
-    end
-  end
-
-end

data/spec/controllers/ccbill_orders_controller_spec.rb

@@ -1,103 +0,0 @@
-require 'spec_helper'
-
-# We're testing the effective/providers/ccbill.rb file, which is included into the OrdersController at runtime
-
-describe Effective::OrdersController, type: :controller do
-  routes { EffectiveOrders::Engine.routes }
-
-  let(:order) { FactoryGirl.create(:order) }
-
-  let(:ccbill_params) do
-    {
-      "customer_fname"=>"Nathan",
-      "customer_lname"=>"Feaver",
-      "email"=>"nathan@agilestyle.com",
-      "username"=>"",
-      "password"=>"[FILTERED]",
-      "productDesc"=>"Cool Stuff",
-      "price"=>"#{ccbill_formatted_price(order.total)} for 365 days",
-      "subscription_id"=>"0216026202000000347",
-      "denialId"=>"",
-      "clientAccnum"=>"999999",
-      "clientSubacc"=>"0000",
-      "address1"=>"123 Easy St",
-      "city"=>"Edmonton",
-      "state"=>"AB",
-      "country"=>"CA",
-      "phone_number"=>"",
-      "zipcode"=>"A1B 2C3",
-      "start_date"=>"2016-01-26 13:55:44",
-      "referer"=>"",
-      "ccbill_referer"=>"",
-      "affiliate"=>"",
-      "reservationId"=>"",
-      "referringUrl"=>"http://localhost:3000/orders/833-7014-992",
-      "reasonForDecline"=>"",
-      "reasonForDeclineCode"=>"",
-      "formName"=>"211cc",
-      "cardType"=>"VISA",
-      "responseDigest"=>"43492c3db3f97944bab31a0f15d486cb",
-      "commit"=>"Checkout with CCBill",
-      "authenticity_token"=>"96wvM13VjhtNwgCyRZfO03Gn4x2ntgl7GBSn3U51OdwlGLxe2YYNdCHETtGjm8WwikQfRF79/aHF2zmldwsFCA==",
-      "order_id"=>order.to_param,
-      "utf8"=>"✓",
-      "typeId"=>"0",
-      "initialPrice"=>"10.5",
-      "initialPeriod"=>"365",
-      "recurringPrice"=>"0",
-      "recurringPeriod"=>"0",
-      "rebills"=>"0",
-      "initialFormattedPrice"=>ccbill_formatted_price(order.total),
-      "recurringFormattedPrice"=>"$0.00",
-      "ip_address"=>"00.00.000.00"
-    }
-  end
-
-  let(:ccbill_declined_params) do
-    ccbill_params.merge(
-      "denialId"=>"",
-      "reasonForDecline"=>"Transaction Denied by Bank",
-      "reasonForDeclineCode"=>"24",
-    )
-  end
-
-  def ccbill_formatted_price(price)
-    price_in_dollars = price.to_s.insert(-3, '.')
-    "$#{price_in_dollars}"
-  end
-
-  describe 'ccbill_postback' do
-    before do
-      sign_in order.user
-      allow_any_instance_of(Effective::Providers::CcbillPostback).to receive(:verified?).and_return(true)
-    end
-
-    describe 'invalid parameters' do
-      it 'raises RecordNotFound when passed an unknown order id' do
-        expect {
-          post :ccbill_postback, ccbill_params.tap { |x| x[:order_id] = 999 }
-        }.to raise_error(ActiveRecord::RecordNotFound)
-      end
-    end
-
-    describe 'declined purchase params' do
-      it 'marks an order declined when params[:result] indicate decline'  do
-        expect(subject).to receive(:order_declined).and_call_original
-
-        post :ccbill_postback, ccbill_declined_params
-
-        expect(assigns(:order)).to be_declined
-      end
-    end
-
-    describe 'approved purchase' do
-      it 'marks the order as purchased' do
-        expect(subject).to receive(:order_purchased).and_call_original
-
-        post :ccbill_postback, ccbill_params
-
-        expect(assigns(:order)).to be_purchased
-      end
-    end
-  end
-end

data/spec/controllers/moneris_orders_controller_spec.rb

@@ -1,133 +0,0 @@
-require 'spec_helper'
-
-# We're testing the effective/providers/moneris.rb file, which is included into the OrdersController at runtime
-
-describe Effective::OrdersController, type: :controller do
-  routes { EffectiveOrders::Engine.routes }
-
-  let(:order) { FactoryGirl.create(:order) }
-  let(:moneris_params) do
-    {
-      response_order_id: "#{order.to_param}",
-      date_stamp: '2014-10-27',
-      time_stamp: '17:42:31',
-      bank_transaction_id:'660110910011137660',
-      charge_total: "#{'%.2f' % order.total}",
-      bank_approval_code: '497365',
-      response_code: '027',
-      iso_code: '01',
-      message: 'APPROVED           *                    =',
-      trans_name: 'purchase',
-      cardholder: 'Matt',
-      f4l4: '4242***4242',
-      card:'V',
-      expiry_date: '1904',
-      result: '1',
-      rvar_authenticity_token: 'nJQf5RKL9SES4uiQIaj4aMNNdIQayEeauOL44iSppD4=',
-      transactionKey: 'C3kYLXwyMDDFD1ArgxiHFph3wIy1Jx'
-    }
-  end
-
-  describe 'moneris_postback' do
-    before do
-      allow(subject).to receive(:send_moneris_verify_request).and_return('') # Don't actually make Moneris requests
-      sign_in order.user
-    end
-
-    describe 'invalid parameters' do
-      it 'raises RecordNotFound when passed an unknown order id' do
-        expect {
-          post :moneris_postback, moneris_params.tap { |x| x[:response_order_id] = 999 }
-        }.to raise_error(ActiveRecord::RecordNotFound)
-      end
-    end
-
-    describe 'declined purchase params' do
-      it 'marks an order declined when params[:result] indicate decline'  do
-        subject.should_not_receive(:send_moneris_verify_request)
-        subject.should_not_receive(:parse_moneris_response)
-
-        post :moneris_postback, moneris_params.tap { |x| x[:result] = 'null' }
-
-        response.should redirect_to "/orders/#{order.to_param}/declined"
-        assigns(:order).declined?.should eq true
-      end
-
-      it 'marks an order declined when params[:transactionKey] is blank'  do
-        post :moneris_postback, moneris_params.tap { |x| x.delete(:transactionKey) }
-
-        response.should redirect_to "/orders/#{order.to_param}/declined"
-        assigns(:order).declined?.should eq true
-      end
-    end
-
-    describe 'successful purchase params' do
-      it 'sends a moneris verify request when passed successful purchase params'  do
-        subject.should_receive(:send_moneris_verify_request)
-        subject.should_receive(:parse_moneris_response)
-
-        post :moneris_postback, moneris_params
-      end
-    end
-
-    describe 'transaction verification step' do
-      it 'marks the order as purchased when response code is valid' do
-        allow(subject).to receive(:parse_moneris_response).and_return({response_code: 1}) # success
-
-        post :moneris_postback, moneris_params
-
-        response.should redirect_to "/orders/#{order.to_param}/purchased"
-        assigns(:order).purchased?.should eq true
-      end
-
-      it 'marks order declined when response_code = null' do
-        allow(subject).to receive(:parse_moneris_response).and_return({response_code: 'null'}) # failure
-
-        post :moneris_postback, moneris_params
-
-        response.should redirect_to "/orders/#{order.to_param}/declined"
-        assigns(:order).purchased?.should eq false
-        assigns(:order).declined?.should eq true
-      end
-
-      it 'marks order declined when response_code blank' do
-        allow(subject).to receive(:parse_moneris_response).and_return({}) # failure
-
-        post :moneris_postback, moneris_params
-
-        response.should redirect_to "/orders/#{order.to_param}/declined"
-        assigns(:order).purchased?.should eq false
-        assigns(:order).declined?.should eq true
-      end
-
-      it 'marks order declined when response_code = 0' do
-        allow(subject).to receive(:parse_moneris_response).and_return({response_code: 0}) # failure
-        post :moneris_postback, moneris_params
-        response.should redirect_to "/orders/#{order.to_param}/declined"
-        assigns(:order).purchased?.should eq false
-      end
-
-      it 'marks order declined when response_code = 50' do
-        allow(subject).to receive(:parse_moneris_response).and_return({response_code: 50}) # failure
-        post :moneris_postback, moneris_params
-        response.should redirect_to "/orders/#{order.to_param}/declined"
-        assigns(:order).purchased?.should eq false
-      end
-    end
-
-    describe 'redirect urls' do
-      it 'redirects to the purchased_url on purchase' do
-        allow(subject).to receive(:parse_moneris_response).and_return({response_code: 1}) # success
-        post :moneris_postback, moneris_params.tap { |x| x[:rvar_purchased_url] = '/something' }
-        response.should redirect_to '/something'
-      end
-
-      it 'redirects to the declined_url on decline' do
-        allow(subject).to receive(:parse_moneris_response).and_return({response_code: 'null'}) # failure
-        post :moneris_postback, moneris_params.tap { |x| x[:rvar_declined_url] = '/something' }
-        response.should redirect_to '/something'
-      end
-    end
-
-  end
-end

data/spec/controllers/orders_controller_spec.rb

@@ -1,500 +0,0 @@
-require 'spec_helper'
-
-describe Effective::OrdersController, type: :controller do
-  routes { EffectiveOrders::Engine.routes }
-
-  let(:purchased_order) { FactoryGirl.create(:purchased_order) }
-  let(:order) { FactoryGirl.create(:order) }
-
-  let(:cart) { FactoryGirl.create(:cart) }
-  let(:address) { FactoryGirl.create(:address) }
-
-  let(:billing_address) { FactoryGirl.create(:address) }
-  let(:billing_atts) { billing_address.attributes.reject { |k, v| ['id', 'addressable_type', 'addressable_id', 'category', 'updated_at', 'created_at'].include?(k) } }
-
-  let(:shipping_address) { FactoryGirl.create(:address) }
-  let(:shipping_atts) { shipping_address.attributes.reject { |k, v| ['id', 'addressable_type', 'addressable_id', 'category', 'updated_at', 'created_at'].include?(k) } }
-
-  let(:valid_order_attributes) do
-    {
-      effective_order: {
-        billing_address: billing_atts, save_billing_address: false,
-        shipping_address: shipping_atts, save_shipping_address: false,
-      }
-    }
-  end
-
-  it 'uses authenticate_user! to redirect to sign in if not signed in' do
-    get :new
-    response.should redirect_to '/users/sign_in'
-  end
-
-  describe '#new' do
-    it 'should assign an @order based off the user cart' do
-      sign_in cart.user
-      get :new
-
-      assigns(:order).user.should eq cart.user
-
-      assigns(:order).order_items.size.should eq cart.cart_items.size
-      assigns(:order).total.should eq cart.subtotal
-    end
-
-    it 'redirects if there is an empty order' do
-      sign_in cart.user
-      cart.cart_items.destroy_all
-
-      get :new
-
-      flash[:danger].downcase.include?('add one or more item to your cart').should eq true
-      response.should redirect_to '/cart' # cart_path
-    end
-
-    it 'redirects if order total is less than minimum charge' do
-      sign_in cart.user
-
-      cart.cart_items.each do |cart_item|
-        cart_item.purchasable.update_column(:price, 10)
-      end
-
-      get :new
-
-      flash[:danger].downcase.include?('a minimum order of $0.50 is required').should eq true
-      response.should redirect_to '/cart' # cart_path
-    end
-  end
-
-  # "effective_order"=> {
-  #   "order_items_attributes"=> {
-  #     "0"=> {
-  #       "class"=>"Effective::Subscription", "stripe_coupon_id"=>"50OFF", "id"=>"2"}},
-  #   "billing_address"=>{"address1"=>"1234 Fake street", "address2"=>"", "city"=>"Edmonton", "country_code"=>"KH", "state_code"=>"1", "postal_code"=>"T5T2T1"},
-  #   "save_billing_address"=>"1",
-  #   "shipping_address"=>{"address1"=>"123 Shipping street", "address2"=>"", "city"=>"Edmonton", "country_code"=>"KH", "state_code"=>"10", "postal_code"=>"t5t2t1"},
-  #   "save_shipping_address"=>"1"},
-  #   "commit"=>"Continue Checkout"
-  # }
-
-  describe '#create' do
-    before(:each) do
-      sign_in cart.user
-    end
-
-    it 'should assign an @order based off the user cart' do
-      post :create, effective_order: {}
-
-      assigns(:order).user.should eq cart.user
-      assigns(:order).order_items.size.should eq cart.cart_items.size
-      assigns(:order).total.should eq cart.subtotal
-      assigns(:order).purchased?.should eq false
-    end
-
-    it 'assign appropriate User fields' do
-      post :create, effective_order: {
-        billing_address: billing_atts, save_billing_address: false,
-        shipping_address: shipping_atts, save_shipping_address: false,
-        user_attributes: {first_name: 'First', last_name: 'Last', email: 'email@somwhere.com'}
-      }
-
-      (assigns(:order).valid? && assigns(:order).persisted?).should eq true
-
-      assigns(:order).user.first_name.should eq 'First'
-      assigns(:order).user.last_name.should eq 'Last'
-      assigns(:order).user.email.should_not eq 'email@somwhere.com'
-    end
-
-    it 'assign addresses to the order and not the user' do
-      post :create, effective_order: {
-        billing_address: billing_atts, save_billing_address: false,
-        shipping_address: shipping_atts, save_shipping_address: false,
-      }
-
-      (assigns(:order).valid? && assigns(:order).persisted?).should eq true
-
-      assigns(:order).billing_address.address1.should eq billing_atts['address1']
-      assigns(:order).shipping_address.address1.should eq shipping_atts['address1']
-
-      assigns(:order).user.billing_address.present?.should eq false
-      assigns(:order).user.shipping_address.present?.should eq false
-    end
-
-    it 'assign addresses to the order and the user' do
-      post :create, effective_order: {
-        billing_address: billing_atts, save_billing_address: true,
-        shipping_address: shipping_atts, save_shipping_address: true
-      }
-
-      (assigns(:order).valid? && assigns(:order).persisted?).should eq true
-
-      assigns(:order).billing_address.address1.should eq billing_atts['address1']
-      assigns(:order).shipping_address.address1.should eq shipping_atts['address1']
-
-      assigns(:order).user.billing_address.address1.should eq billing_atts['address1']
-      assigns(:order).user.shipping_address.address1.should eq shipping_atts['address1']
-
-      response.should redirect_to "/orders/#{assigns(:order).to_param}"
-    end
-
-    it 'does not assign the billing_address to user if save_billing_address is false' do
-      post :create, effective_order: {
-        billing_address: billing_atts, save_billing_address: false,
-        shipping_address: shipping_atts, save_shipping_address: true
-      }
-
-      (assigns(:order).valid? && assigns(:order).persisted?).should eq true
-
-      assigns(:order).billing_address.address1.should eq billing_atts['address1']
-      assigns(:order).shipping_address.address1.should eq shipping_atts['address1']
-
-      assigns(:order).user.billing_address.present?.should eq false
-      assigns(:order).user.shipping_address.address1.should eq shipping_atts['address1']
-
-      response.should redirect_to "/orders/#{assigns(:order).to_param}"
-    end
-
-    it 'does not assign the shipping_address to user if save_shipping_address is false' do
-      post :create, effective_order: {
-        billing_address: billing_atts, save_billing_address: true,
-        shipping_address: shipping_atts, save_shipping_address: false
-      }
-
-      (assigns(:order).valid? && assigns(:order).persisted?).should eq true
-
-      assigns(:order).billing_address.address1.should eq billing_atts['address1']
-      assigns(:order).shipping_address.address1.should eq shipping_atts['address1']
-
-      assigns(:order).user.billing_address.address1.should eq billing_atts['address1']
-      assigns(:order).user.shipping_address.present?.should eq false
-
-      response.should redirect_to "/orders/#{assigns(:order).to_param}"
-    end
-
-    it 'assign billing address to the order shipping_address when shipping_address_same_as_billing' do
-      post :create, effective_order: {
-        billing_address: billing_atts, save_billing_address: true,
-        shipping_address: shipping_atts.merge(shipping_address_same_as_billing: 1), save_shipping_address: true,
-      }
-
-      (assigns(:order).valid? && assigns(:order).persisted?).should eq true
-
-      assigns(:order).billing_address.address1.should eq billing_atts['address1']
-      assigns(:order).shipping_address.address1.should eq billing_atts['address1']
-
-      assigns(:order).user.billing_address.address1.should eq billing_atts['address1']
-      assigns(:order).user.shipping_address.address1.should eq billing_atts['address1']
-
-      response.should redirect_to "/orders/#{assigns(:order).to_param}"
-    end
-
-    it 'assign billing address to the order shipping_address when shipping_address_same_as_billing and no shipping provided' do
-      post :create, effective_order: {
-        billing_address: billing_atts, save_billing_address: true, shipping_address: { shipping_address_same_as_billing: 1 }
-      }
-
-      (assigns(:order).valid? && assigns(:order).persisted?).should eq true
-
-      assigns(:order).billing_address.address1.should eq billing_atts['address1']
-      assigns(:order).shipping_address.address1.should eq billing_atts['address1']
-
-      assigns(:order).user.billing_address.address1.should eq billing_atts['address1']
-      assigns(:order).user.shipping_address.address1.should eq billing_atts['address1']
-
-      response.should redirect_to "/orders/#{assigns(:order).to_param}"
-    end
-
-    it 'assign billing address to the order shipping_address but not the user when shipping_address_same_as_billing provided' do
-      post :create, effective_order: {
-        billing_address: billing_atts, save_billing_address: false, shipping_address: { shipping_address_same_as_billing: 1 },
-        save_shipping_address: false
-      }
-
-      (assigns(:order).valid? && assigns(:order).persisted?).should eq true
-
-      assigns(:order).billing_address.address1.should eq billing_atts['address1']
-      assigns(:order).shipping_address.address1.should eq billing_atts['address1']
-
-      assigns(:order).user.billing_address.present?.should eq false
-      assigns(:order).user.shipping_address.present?.should eq false
-
-      response.should redirect_to "/orders/#{assigns(:order).to_param}"
-    end
-
-    it 'is invalid when passed an invalid address' do
-      post :create, effective_order: {
-        billing_address: billing_atts, save_billing_address: true,
-        shipping_address: shipping_atts.tap { |x| x[:address1] = nil }, save_shipping_address: true
-      }
-
-      (assigns(:order).valid? && assigns(:order).persisted?).should eq false
-      assigns(:order).errors[:shipping_address].present?.should eq true
-
-      response.should render_template(:checkout_step1)
-    end
-
-    it 'is invalid when passed an invalid order_item' do
-      Effective::OrderItem.any_instance.stub(:valid?).and_return(false)
-
-      post :create, effective_order: {
-        billing_address: billing_atts, save_billing_address: true,
-        shipping_address: shipping_atts, save_shipping_address: true,
-      }
-
-      (assigns(:order).valid? && assigns(:order).persisted?).should eq false
-      response.should render_template(:checkout_step1)
-    end
-
-    it 'is invalid when passed an invalid user' do
-      User.any_instance.stub(:valid?).and_return(false)
-
-      post :create, effective_order: {
-        billing_address: billing_atts, save_billing_address: true,
-        shipping_address: shipping_atts, save_shipping_address: true,
-      }
-
-      (assigns(:order).valid? && assigns(:order).persisted?).should eq false
-      response.should render_template(:checkout_step1)
-    end
-
-    it 'is invalid when passed an invalid purchasable' do
-      Product.any_instance.stub(:valid?).and_return(false)
-
-      post :create, effective_order: {
-        billing_address: billing_atts, save_billing_address: true,
-        shipping_address: shipping_atts, save_shipping_address: true,
-      }
-
-      (assigns(:order).valid? && assigns(:order).persisted?).should eq false
-      response.should render_template(:checkout_step1)
-    end
-
-    it 'prevents the order from proceeding when missing a required address' do
-      post :create, effective_order: { billing_address: billing_atts, save_billing_address: true }
-
-      (assigns(:order).valid? && assigns(:order).persisted?).should eq false
-      assigns(:order).errors[:shipping_address].present?.should eq true
-
-      response.should render_template(:checkout_step1)
-    end
-  end
-
-  describe '#create with a Stripe Subscription object' do
-    let(:cart_with_subscription) { FactoryGirl.create(:cart_with_subscription) }
-    let(:subscription) { cart_with_subscription.cart_items.find { |obj| obj.purchasable.kind_of?(Effective::Subscription)}.purchasable }
-
-    let(:valid_order_with_new_subscription_coupon_attributes) do
-      valid_order_attributes.tap { |x| x[:effective_order]['order_items_attributes'] = {'0' => {"class"=>"Effective::Subscription", "stripe_coupon_id"=>"#{FactoryGirl.create(:stripe_coupon).id}", 'id' => "#{subscription.id}"}} }
-    end
-
-    before do
-      StripeMock.start
-      sign_in cart_with_subscription.user
-    end
-
-    after { StripeMock.stop }
-
-    it 'has an OrderItem that is a Subscription' do
-      post :create, valid_order_attributes
-      assigns(:order).persisted?.should eq true
-
-      subscription = assigns(:order).order_items.find { |obj| obj.purchasable.kind_of?(Effective::Subscription) }
-      subscription.present?.should eq true
-    end
-
-    it 'does not alter the subscription.stripe_coupon_id' do
-      post :create, valid_order_attributes
-      assigns(:order).persisted?.should eq true
-
-      order_subscription = assigns(:order).order_items.find { |obj| obj.purchasable.kind_of?(Effective::Subscription) }.purchasable
-      order_subscription.stripe_coupon_id.should eq subscription.stripe_coupon_id
-    end
-
-    it 'updates the subscription.stripe_coupon_id when passed' do
-      post :create, valid_order_with_new_subscription_coupon_attributes
-      assigns(:order).persisted?.should eq true
-
-      order_subscription = assigns(:order).order_items.find { |obj| obj.purchasable.kind_of?(Effective::Subscription) }.purchasable
-      order_subscription.stripe_coupon_id.should_not eq subscription.stripe_coupon_id
-    end
-
-    it 'is invalid when passed an invalid coupon code' do
-      invalid_coupon_atts = valid_order_with_new_subscription_coupon_attributes.tap { |x| x[:effective_order]['order_items_attributes']['0']['stripe_coupon_id'] = 'SOMETHING INVALID' }
-
-      post :create, invalid_coupon_atts
-
-      assigns(:order).errors['order_items.purchasable'].present?.should eq true
-      assigns(:order).errors['order_items.purchasable.stripe_coupon_id'].present?.should eq true
-      assigns(:order).persisted?.should eq false
-    end
-  end
-
-  describe '#order_purchased (with a free order)' do
-    before(:each) do
-      sign_in cart.user
-      cart.cart_items.each { |cart_item| cart_item.purchasable.update_attributes(price: 0) }
-    end
-
-    it 'creates a purchased order' do
-      post :create, valid_order_attributes
-      assigns(:order).purchased?.should eq true
-      assigns(:order).payment[:details].should eq 'automatic purchase of free order'
-    end
-
-    it 'destroys the current user cart' do
-      post :create, valid_order_attributes
-
-      expect { Effective::Cart.find(cart.id) }.to raise_error(ActiveRecord::RecordNotFound)
-      Effective::Cart.count.should eq 0
-    end
-
-    it 'redirects to the purchased page' do
-      post :create, valid_order_attributes
-      response.should redirect_to "/orders/#{assigns(:order).to_param}/purchased"
-    end
-  end
-
-  describe '#show' do
-    context 'when finding order' do
-      before { sign_in purchased_order.user }
-
-      it 'should find the order by obfuscated ID' do
-        get :show, id: purchased_order.to_param
-
-        expect(assigns(:order).id).to eq purchased_order.id
-      end
-
-      it 'should not find an order by regular ID' do
-        expect { get :show, id: purchased_order.id }.to raise_error(ActiveRecord::RecordNotFound)
-      end
-    end
-
-    context 'when rendering template' do
-      let(:user) { FactoryGirl.create(:user) }
-
-      before { sign_in user }
-
-      context 'when not purchased order' do
-        let(:order) { FactoryGirl.create(:order, user: user) }
-
-        it 'should render checkout page successfully' do
-          get :show, id: order.to_param
-
-          expect(response).to be_successful
-          expect(response).to render_template :checkout_step2
-          expect(assigns(:order)).to eq order
-          expect(assigns(:page_title)).to eq 'Checkout'
-        end
-
-        it 'should render checkout page successfully' do
-          get :edit, id: order.to_param
-
-          expect(response).to be_successful
-          expect(response).to render_template :checkout_step1
-          expect(assigns(:order)).to eq order
-          expect(assigns(:page_title)).to eq 'Checkout'
-        end
-      end
-
-      context 'when pending order' do
-        let(:order) { FactoryGirl.create(:pending_order, user: user) }
-
-        it 'should render checkout page successfully' do
-          get :show, id: order.to_param
-
-          expect(response).to be_successful
-          expect(response).to render_template :checkout_step2
-          expect(assigns(:order)).to eq order
-          expect(assigns(:page_title)).to eq 'Checkout'
-        end
-
-        it 'should render checkout page successfully' do
-          get :edit, id: order.to_param
-
-          expect(response).to be_successful
-          expect(response).to render_template :checkout_step1
-          expect(assigns(:order)).to eq order
-          expect(assigns(:page_title)).to eq 'Checkout'
-        end
-      end
-
-      context 'when purchased order' do
-        let(:order) { FactoryGirl.create(:purchased_order, user: user) }
-
-        it 'should render order show page successfully' do
-          get :show, id: order.to_param
-
-          expect(response).to be_successful
-          expect(response).to render_template :show
-          expect(assigns(:order)).to eq order
-          expect(assigns(:page_title)).to eq 'Receipt'
-        end
-      end
-    end
-  end
-
-  describe '#purchased' do
-    before(:each) do
-      sign_in purchased_order.user
-    end
-
-    it 'finds the order by obfuscated ID' do
-      get :purchased, id: purchased_order.to_param
-      assigns(:order).id.should eq purchased_order.id
-    end
-
-    it 'does not find an order by regular ID' do
-      expect { get :purchased, id: purchased_order.id }.to raise_error(ActiveRecord::RecordNotFound)
-    end
-  end
-
-  describe '#declined' do
-    before(:each) do
-      sign_in purchased_order.user
-    end
-
-    it 'finds the order by obfuscated ID' do
-      get :declined, id: purchased_order.to_param
-      assigns(:order).id.should eq purchased_order.id
-    end
-
-    it 'does not find an order by regular ID' do
-      expect { get :declined, id: purchased_order.id }.to raise_error(ActiveRecord::RecordNotFound)
-    end
-  end
-
-  describe 'POST #pay_by_cheque' do
-    let(:user) { FactoryGirl.create(:user) }
-    let(:order) { FactoryGirl.create(:order, user: user) }
-    let!(:cart) { FactoryGirl.create(:cart_with_items, user: user) }
-
-    before { sign_in user }
-
-    context 'when success' do
-      it 'should update order state, empty cart and redirect to order show page with success message' do
-        Effective::OrdersMailer.deliveries.clear
-
-        post :pay_by_cheque, id: order.to_param
-
-        expect(assigns(:order).pending?).to be_truthy
-        expect(Effective::Cart.first).to be_nil
-        flash[:success].present?.should eq true
-        response.should render_template(:pay_by_cheque)
-        Effective::OrdersMailer.deliveries.length.should eq 1
-      end
-    end
-
-    context 'when failed' do
-      before { Effective::Order.any_instance.stub(:save).and_return(false) }
-
-      it 'should not empty cart and redirect to order show page with danger message' do
-        Effective::OrdersMailer.deliveries.clear
-        post :pay_by_cheque, id: order.to_param
-
-        expect(response).to be_redirect
-        expect(response).to redirect_to EffectiveOrders::Engine.routes.url_helpers.order_path(order)
-        expect(Effective::Cart.first.empty?).to be_falsey
-        flash[:danger].present?.should eq true
-        Effective::OrdersMailer.deliveries.length.should eq 0
-      end
-    end
-  end
-end