spree_paypal_express 1.1.0

data/spec/controllers/checkout_controller_spec.rb

@@ -0,0 +1,323 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+module Spree
+  describe CheckoutController do
+    render_views
+    let(:token) { "EC-2OPN7UJGFWK9OYFV" }
+    let(:order) { FactoryGirl.create(:ppx_order_with_totals, :state => "payment", :shipping_method => shipping_method) }
+    let(:shipping_method) { FactoryGirl.create(:shipping_method, :zone => Spree::Zone.find_by_name('North America'))  }
+    let(:order_total) { (order.total * 100).to_i }
+    let(:gateway_provider) { mock(ActiveMerchant::Billing::PaypalExpressGateway) }
+    let(:paypal_gateway) { mock(BillingIntegration::PaypalExpress, :id => 123, :preferred_review => false, :preferred_no_shipping => true, :provider => gateway_provider, :preferred_currency => "US", :preferred_allow_guest_checkout => true
+    ) }
+
+    let(:details_for_response) { mock(ActiveMerchant::Billing::PaypalExpressResponse, :success? => true,
+            :params => {"payer" => order.user.email, "payer_id" => "FWRVKNRRZ3WUC"}, :address => {}) }
+
+    let(:purchase_response) { mock(ActiveMerchant::Billing::PaypalExpressResponse, :success? => true, :authorization => 'ABC123456789',
+        :params => {"payer" => order.user.email, "payer_id" => "FWRVKNRRZ3WUC", "gross_amount" => order_total, "payment_status" => "Completed"},
+        :avs_result => "F",
+        :to_yaml => "fake") }
+
+
+    before do
+      Spree::Auth::Config.set(:registration_step => false)
+      controller.stub(:current_order => order, :check_authorization => true, :current_user => order.user)
+      order.stub(:checkout_allowed? => true, :completed? => false)
+      order.update!
+    end
+
+    it "should understand paypal routes" do
+      pending("Unknown how to make this work within the scope of an engine again")
+
+      assert_routing("/orders/#{order.number}/checkout/paypal_payment", {:controller => "checkout", :action => "paypal_payment", :order_id => order.number })
+      assert_routing("/orders/#{order.number}/checkout/paypal_confirm", {:controller => "checkout", :action => "paypal_confirm", :order_id => order.number })
+    end
+
+    context "paypal_checkout" do
+      #feature not implemented
+    end
+
+    context "paypal_payment without auto_capture" do
+      let(:redirect_url) { "https://www.sandbox.paypal.com/cgi-bin/webscr?cmd=_express-checkout&token=#{token}&useraction=commit" }
+
+      before { Spree::Config.set(:auto_capture => false) }
+
+      it "should setup an authorize transaction and redirect to sandbox" do
+        PaymentMethod.should_receive(:find).at_least(1).with('123').and_return(paypal_gateway)
+
+        gateway_provider.should_receive(:redirect_url_for).with(token, {:review => false}).and_return redirect_url
+        paypal_gateway.provider.should_receive(:setup_authorization).with(order_total, anything()).and_return(mock(:success? => true, :token => token))
+
+        get :paypal_payment, {:order_id => order.number, :payment_method_id => "123" }
+
+        response.should redirect_to "https://www.sandbox.paypal.com/cgi-bin/webscr?cmd=_express-checkout&token=#{assigns[:ppx_response].token}&useraction=commit"
+      end
+
+    end
+
+    context "paypal_payment with auto_capture" do
+      let(:redirect_url) { "https://www.sandbox.paypal.com/cgi-bin/webscr?cmd=_express-checkout&token=#{token}&useraction=commit" }
+
+      before { Spree::Config.set(:auto_capture => true) }
+
+      it "should setup a purchase transaction and redirect to sandbox" do
+        PaymentMethod.should_receive(:find).at_least(1).with("123").and_return(paypal_gateway)
+
+        gateway_provider.should_receive(:redirect_url_for).with(token, {:review => false}).and_return redirect_url
+        paypal_gateway.provider.should_receive(:setup_purchase).with(order_total, anything()).and_return(mock(:success? => true, :token => token))
+
+        get :paypal_payment, {:order_id => order.number, :payment_method_id => "123" }
+
+        response.should redirect_to "https://www.sandbox.paypal.com/cgi-bin/webscr?cmd=_express-checkout&token=#{assigns[:ppx_response].token}&useraction=commit"
+      end
+
+    end
+
+    context "paypal_confirm" do
+      before do
+        PaymentMethod.should_receive(:find).at_least(1).with("123").and_return(paypal_gateway)
+        order.stub!(:payment_method).and_return paypal_gateway
+      end
+
+      context "with auto_capture and no review" do
+        before do
+          Spree::Config.set(:auto_capture => true)
+          paypal_gateway.stub(:preferred_review => false)
+        end
+
+        it "should capture payment" do
+          paypal_gateway.provider.should_receive(:details_for).with(token).and_return(details_for_response)
+
+          paypal_gateway.provider.should_receive(:purchase).with(order_total, anything()).and_return(purchase_response)
+
+          get :paypal_confirm, {:order_id => order.number, :payment_method_id => "123", :token => token, :PayerID => "FWRVKNRRZ3WUC" }
+
+          response.should redirect_to spree.order_path(order)
+
+          order.reload
+          order.state.should == "complete"
+          order.completed_at.should_not be_nil
+          order.payments.size.should == 1
+          order.payment_state.should == "paid"
+        end
+      end
+
+      context "with review" do
+        before do
+           paypal_gateway.stub(:preferred_review => true, :payment_profiles_supported? => true)
+           order.stub_chain(:payment, :payment_method, :payment_profiles_supported? => true)
+           order.stub_chain(:payment, :source, :type => 'Spree:PaypalAccount')
+         end
+
+        it "should render review" do
+          paypal_gateway.provider.should_receive(:details_for).with(token).and_return(details_for_response)
+
+          get :paypal_confirm, {:order_id => order.number, :payment_method_id => "123", :token => token, :PayerID => "FWRVKNRRZ3WUC" }
+
+          response.should render_template("shared/paypal_express_confirm")
+          order.state.should == "confirm"
+        end
+
+        it "order state should not change on multiple call" do
+          paypal_gateway.provider.should_receive(:details_for).twice.with(token).and_return(details_for_response)
+
+          get :paypal_confirm, {:order_id => order.number, :payment_method_id => "123", :token => token, :PayerID => "FWRVKNRRZ3WUC" }
+          get :paypal_confirm, {:order_id => order.number, :payment_method_id => "123", :token => token, :PayerID => "FWRVKNRRZ3WUC" }
+          order.state.should == "confirm"
+        end
+      end
+
+      context "with review and shipping update" do
+        before do
+          paypal_gateway.stub(:preferred_review => true)
+          paypal_gateway.stub(:preferred_no_shipping => false)
+          paypal_gateway.stub(:payment_profiles_supported? => true)
+          order.stub_chain(:payment, :payment_method, :payment_profiles_supported? => true)
+          order.stub_chain(:payment, :source, :type => 'Spree:PaypalAccount')
+          details_for_response.stub(:params => details_for_response.params.merge({'first_name' => 'Dr.', 'last_name' => 'Evil'}),
+            :address => {'address1' => 'Apt. 187', 'address2'=> 'Some Str.', 'city' => 'Chevy Chase', 'country' => 'US', 'zip' => '20815', 'state' => 'MD' })
+
+        end
+
+        it "should update ship_address and render review" do
+          paypal_gateway.provider.should_receive(:details_for).with(token).and_return(details_for_response)
+
+          get :paypal_confirm, {:order_id => order.number, :payment_method_id => "123", :token => token, :PayerID => "FWRVKNRRZ3WUC" }
+
+          order.ship_address.address1.should == "Apt. 187"
+          order.state.should == "confirm"
+          response.should render_template("shared/paypal_express_confirm")
+        end
+      end
+
+      context "with un-successful repsonse" do
+        before { details_for_response.stub(:success? => false) }
+
+        it "should log error and redirect to payment step" do
+          paypal_gateway.provider.should_receive(:details_for).with(token).and_return(details_for_response)
+
+          controller.should_receive(:gateway_error).with(details_for_response)
+
+          get :paypal_confirm, {:order_id => order.number, :payment_method_id => "123", :token => token, :PayerID => "FWRVKNRRZ3WUC" }
+
+          response.should redirect_to spree.edit_order_checkout_path(order, :state => 'payment')
+        end
+      end
+
+    end
+
+    context "paypal_finish" do
+      let(:paypal_account) { stub_model(PaypalAccount, :payer_id => "FWRVKNRRZ3WUC", :email => order.email ) }
+      let(:authorize_response) { mock(ActiveMerchant::Billing::PaypalExpressResponse, :success? => true, :authorization => 'ABC123456789',
+            :params => {"payer" => order.user.email, "payer_id" => "FWRVKNRRZ3WUC", "gross_amount" => order_total, "payment_status" => "Pending"},
+            :avs_result => "F",
+            :to_yaml => "fake") }
+
+      before do
+        PaymentMethod.should_receive(:find).at_least(1).with("123").and_return(paypal_gateway)
+        PaypalAccount.should_receive(:find_by_payer_id).with("FWRVKNRRZ3WUC").and_return(paypal_account)
+      end
+
+      context "with auto_capture" do
+        before { Spree::Config.set(:auto_capture => true) }
+
+        it "should capture payment" do
+
+          paypal_gateway.provider.should_receive(:purchase).with(order_total, anything()).and_return(purchase_response)
+
+          get :paypal_finish, {:order_id => order.number, :payment_method_id => "123", :token => token, :PayerID => "FWRVKNRRZ3WUC" }
+
+          response.should redirect_to spree.order_path(order)
+
+          order.reload
+          order.update!
+          order.payments.size.should == 1
+          order.payment_state.should == "paid"
+        end
+      end
+
+      context "with auto_capture and pending(echeck) response" do
+        before do
+          Spree::Config.set(:auto_capture => true)
+          purchase_response.params["payment_status"] = "pending"
+        end
+
+        it "should authorize payment" do
+
+          paypal_gateway.provider.should_receive(:purchase).with(order_total, anything()).and_return(purchase_response)
+
+          get :paypal_finish, {:order_id => order.number, :payment_method_id => "123", :token => token, :PayerID => "FWRVKNRRZ3WUC" }
+
+          response.should redirect_to spree.order_path(order)
+
+          order.reload
+          order.update!
+          order.payments.size.should == 1
+          order.payment_state.should == "balance_due"
+          order.payment.state.should == "pending"
+        end
+      end
+
+      context "without auto_capture" do
+        before { Spree::Config.set(:auto_capture => false) }
+
+        it "should authorize payment" do
+
+          paypal_gateway.provider.should_receive(:authorize).with(order_total, anything()).and_return(authorize_response)
+
+          get :paypal_finish, {:order_id => order.number, :payment_method_id => "123", :token => token, :PayerID => "FWRVKNRRZ3WUC" }
+
+          response.should redirect_to spree.order_path(order)
+
+          order.reload
+          order.update!
+          order.payments.size.should == 1
+          order.payment_state.should == "balance_due"
+          order.payment.state.should == "pending"
+        end
+      end
+
+      context "with un-successful repsonse" do
+        before do
+          Spree::Config.set(:auto_capture => true)
+          purchase_response.stub(:success? => false)
+        end
+
+        it "should log error and redirect to payment step" do
+          paypal_gateway.provider.should_receive(:purchase).with(order_total, anything()).and_return(purchase_response)
+
+          controller.should_receive(:gateway_error).with(purchase_response)
+
+          get :paypal_finish, {:order_id => order.number, :payment_method_id => "123", :token => token, :PayerID => "FWRVKNRRZ3WUC" }
+
+          response.should redirect_to spree.edit_order_checkout_path(order, :state => 'payment')
+
+          order.reload
+          order.update!
+          order.payments.size.should == 1
+          order.payment_state.should == "failed"
+          order.payment.state.should == "failed"
+        end
+      end
+
+    end
+
+    context "#fixed_opts" do
+
+      it "returns hash containing basic settings" do
+        I18n.locale = :fr
+        opts = controller.send(:fixed_opts)
+        opts[:header_image].should == "http://demo.spreecommerce.com/assets/admin/bg/spree_50.png"
+        opts[:locale].should == "fr"
+      end
+
+    end
+
+    context "order_opts" do
+
+      it "should return hash containing basic order details" do
+        opts = controller.send(:order_opts, order, paypal_gateway.id, 'payment')
+
+        opts.class.should == Hash
+        opts[:money].should == order_total
+        opts[:subtotal].should == (order.item_total * 100).to_i
+        opts[:order_id].should == order.number
+        opts[:custom].should == order.number
+        opts[:handling].should == 0
+        opts[:shipping].should == (order.ship_total * 100).to_i
+
+        opts[:return_url].should == spree.paypal_confirm_order_checkout_url(order, :payment_method_id => paypal_gateway.id, :host => "test.host")
+        opts[:cancel_return_url].should == spree.edit_order_checkout_url(order, :state => 'payment', :host => "test.host")
+
+        opts[:items].size.should > 0
+        opts[:items].size.should == order.line_items.count
+      end
+
+      it "should include credits in returned hash" do
+        order_total #need here so variable is set before credit is created.
+        order.adjustments.create(:label => "Credit", :amount => -1)
+        order.update!
+
+        opts = controller.send(:order_opts, order, paypal_gateway.id, 'payment')
+
+        opts.class.should == Hash
+        opts[:money].should == order_total - 100
+        opts[:subtotal].should == ((order.item_total * 100) + (order.adjustments.select{|c| c.amount < 0}.sum(&:amount) * 100)).to_i
+
+        opts[:items].size.should == order.line_items.count + 1
+      end
+
+
+    end
+
+    describe "#paypal_site_opts" do
+      it "returns opts to allow guest checkout" do
+        controller.should_receive(:payment_method).at_least(1).and_return(paypal_gateway)
+
+        opts = controller.send(:paypal_site_opts)
+        opts[:allow_guest_checkout].should be_true
+      end
+    end
+  end
+end

data/spec/factories/address_factory.rb

@@ -0,0 +1,13 @@
+Factory.define :ppx_address do |f|
+  f.firstname 'John'
+  f.lastname 'Doe'
+  f.address1 '10 Lovely Street'
+  f.address2 'Northwest'
+  f.city   "Herndon"
+  f.state  { |state| state.association(:ppx_state) }
+  f.zipcode '20170'
+  f.country { |country| country.association(:country) }
+  f.phone '123-456-7890'
+  f.state_name "maryland"
+  f.alternative_phone "123-456-7899"
+end

data/spec/factories/order_factory.rb

@@ -0,0 +1,11 @@
+Factory.define(:ppx_order) do |record|
+  # associations:
+  record.association(:user, :factory => :user)
+  record.association(:bill_address, :factory => :address)
+  record.association(:shipping_method, :factory => :shipping_method)
+  record.ship_address { |ship_address| Factory(:ppx_address, :city => "Chevy Chase", :zipcode => "20815") }
+end
+
+Factory.define :ppx_order_with_totals, :parent => :order do |f|
+  f.after_create { |order| FactoryGirl.create(:line_item, :order => order, :price => 10) and order.line_items.reload }
+end

data/spec/factories/ppx_factory.rb

@@ -0,0 +1,5 @@
+FactoryGirl.define do
+  factory :ppx, :class => Spree::BillingIntegration::PaypalExpress, :parent => :payment_method do
+    name 'Paypal'
+  end
+end

data/spec/factories/state_factory.rb

@@ -0,0 +1,5 @@
+Factory.define :md_state do |f|
+  f.name 'Maryland'
+  f.abbr 'MD'
+  f.country { |country| country.association(:country) }
+end

data/spec/models/billing_integration/paypal_express_base_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+describe Spree::BillingIntegration::PaypalExpressBase do
+  let(:order) do
+    order = Spree::Order.new(:bill_address => Spree::Address.new,
+                             :ship_address => Spree::Address.new)
+  end
+
+  let(:gateway) do
+    gateway = Spree::BillingIntegration::PaypalExpressBase.new({:environment => 'test', :active => true, :preferred_currency => "EUR"}, :without_protection => true)
+    gateway.stub :source_required => true
+    gateway.stub :provider => mock('paypal provider')
+    gateway.stub :find_authorization => mock('authorization', :params => authorization_params)
+    gateway
+  end
+
+  let(:authorization_params) { {'transaction_id' => '123'} }
+  let(:provider) { gateway.provider }
+
+  let(:account) do
+    stub_model(Spree::PaypalAccount)
+  end
+
+  let(:payment) do
+    payment = Spree::Payment.new
+    payment.source = account
+    payment.order = order
+    payment.payment_method = gateway
+    payment.amount = 10.0
+    payment
+  end
+
+  let(:amount_in_cents) { payment.amount.to_f * 100 }
+
+  let!(:success_response) do
+    mock('success_response', :success? => true,
+                             :authorization => '123',
+                             :avs_result => { 'code' => 'avs-code' })
+  end
+
+  let(:failed_response) { mock('gateway_response', :success? => false) }
+
+  before(:each) do
+    # So it doesn't create log entries every time a processing method is called
+    payment.log_entries.stub(:create)
+  end
+
+  describe "#capture" do
+    before { payment.state = 'pending' }
+
+    context "when payment_profiles_supported = true" do
+      before { gateway.stub :payment_profiles_supported? => true }
+
+       context "if sucessful" do
+         before do
+           provider.should_receive(:capture).with(amount_in_cents, '123', :currency => 'EUR').and_return(success_response)
+         end
+
+         it "should store the response_code" do
+           payment.capture!
+           payment.response_code.should == '123'
+         end
+       end
+
+       context "if unsucessful" do
+         before do
+           gateway.should_receive(:capture).with(payment, account, anything).and_return(failed_response)
+         end
+
+         it "should not make payment complete" do
+           lambda { payment.capture! }.should raise_error(Spree::Core::GatewayError)
+           payment.state.should == "failed"
+         end
+       end
+     end
+
+     context "when payment_profiles_supported = false" do
+       before do
+         payment.stub :response_code => '123'
+         gateway.stub :payment_profiles_supported? => false
+       end
+
+       context "if sucessful" do
+         before do
+           provider.should_receive(:capture).with(amount_in_cents, '123', anything).and_return(success_response)
+         end
+
+         it "should store the response_code" do
+           payment.capture!
+           payment.response_code.should == '123'
+         end
+       end
+
+       context "if unsucessful" do
+         before do
+           provider.should_receive(:capture).with(amount_in_cents, '123', anything).and_return(failed_response)
+         end
+
+         it "should not make payment complete" do
+           lambda { payment.capture! }.should raise_error(Spree::Core::GatewayError)
+           payment.state.should == "failed"
+         end
+       end
+
+     end
+  end
+
+  describe "#credit" do
+    before { payment.stub :response_code => '123' }
+    context "when payment_profiles_supported = true" do
+      before { gateway.stub :payment_profiles_supported? => true }
+
+
+      it "should receive correct params" do
+        provider.should_receive(:credit).with(1000, '123', :currency => 'EUR').and_return(success_response)
+        payment.credit!(10.0)
+        payment.response_code.should == '123'
+      end
+    end
+
+    context "when payment_profiles_supported = false" do
+      before do
+        payment.stub :response_code => '123'
+        gateway.stub :payment_profiles_supported? => false
+      end
+
+      it "should receive correct params" do
+        provider.should_receive(:credit).with(amount_in_cents, '123', :currency => 'EUR').and_return(success_response)
+        payment.credit!(10.0)
+        payment.response_code.should == '123'
+      end
+
+    end
+  end
+end