killbill-paypal-express 4.1.2 → 4.1.3

data/spec/paypal_express/remote/baid_spec_helpers.rb

@@ -0,0 +1,55 @@
+require_relative 'browser_helpers'
+
+module Killbill
+  module PaypalExpress
+    module BaidSpecHelpers
+
+      include ::Killbill::PaypalExpress::BrowserHelpers
+
+      def baid_setup(payment_processor_account_id = nil)
+        @call_context = build_call_context
+
+        options = {:payment_processor_account_id => payment_processor_account_id}
+
+        @amount = BigDecimal.new('100')
+        @currency = 'USD'
+
+        kb_account_id = SecureRandom.uuid
+        external_key, kb_account_id = create_kb_account(kb_account_id, @plugin.kb_apis.proxied_services[:account_user_api])
+
+        # Initiate the setup process
+        response = create_token(kb_account_id, @call_context.tenant_id, options)
+        token = response.token
+
+        login_and_confirm @plugin.to_express_checkout_url(response, @call_context.tenant_id)
+
+        # Complete the setup process
+        @properties = []
+        @properties << build_property('token', token)
+        @pm = create_payment_method(::Killbill::PaypalExpress::PaypalExpressPaymentMethod, kb_account_id, @call_context.tenant_id, @properties)
+
+        verify_payment_method kb_account_id
+      end
+
+      private
+
+      def create_token(kb_account_id, kb_tenant_id, options)
+        private_plugin = ::Killbill::PaypalExpress::PrivatePaymentPlugin.new
+        response = private_plugin.initiate_express_checkout(kb_account_id, kb_tenant_id, @amount, @currency, true, options)
+        response.success.should be_true
+        response
+      end
+
+      def verify_payment_method(kb_account_id)
+        # Verify our table directly. Note that @pm.token is the baid
+        payment_methods = ::Killbill::PaypalExpress::PaypalExpressPaymentMethod.from_kb_account_id_and_token(@pm.token, kb_account_id, @call_context.tenant_id)
+        payment_methods.size.should == 1
+        payment_method = payment_methods.first
+        payment_method.should_not be_nil
+        payment_method.paypal_express_payer_id.should_not be_nil
+        payment_method.token.should == @pm.token
+        payment_method.kb_payment_method_id.should == @pm.kb_payment_method_id
+      end
+    end
+  end
+end

data/spec/paypal_express/remote/browser_helpers.rb

@@ -0,0 +1,72 @@
+require 'selenium-webdriver'
+
+module Killbill
+  module PaypalExpress
+    module BrowserHelpers
+      def login_and_confirm(url)
+        if ENV['BUYER_USERNAME'].blank? || ENV['BUYER_PASSWORD'].blank?
+          print "\nPlease go to #{url} to proceed and press any key to continue... Note: you need to log-in with a paypal sandbox account (create one here: https://developer.paypal.com/webapps/developer/applications/accounts)\n"
+          $stdin.gets
+        else
+          driver = Selenium::WebDriver.for :firefox
+          # Login page
+          driver.get url
+
+          wait = Selenium::WebDriver::Wait.new(:timeout => 15)
+          wait.until {
+            driver.switch_to.frame('injectedUl') rescue nil
+          }
+
+          email_element, pwd_element, login_element = wait.until {
+            email_element = driver.find_element(:id, 'email') rescue nil
+            pwd_element = driver.find_element(:id, 'password') rescue nil
+            login_element = driver.find_element(:id, 'btnLogin') rescue nil
+            if ready?(email_element, pwd_element, login_element)
+              [email_element, pwd_element, login_element]
+            else
+              # Find the element ids from the old UI
+              old_email_element = driver.find_element(:id, 'login_email') rescue nil
+              old_pwd_element = driver.find_element(:id, 'login_password') rescue nil
+              old_login_element = driver.find_element(:id, 'submitLogin') rescue nil
+              if ready?(old_email_element, old_pwd_element, old_login_element)
+                [old_email_element, old_pwd_element, old_login_element]
+              else
+                false
+              end
+            end
+          }
+          email_element.send_keys(ENV['BUYER_USERNAME'])
+          pwd_element.send_keys(ENV['BUYER_PASSWORD'])
+          login_element.click
+
+          # Confirmation page
+          driver.switch_to.default_content
+          confirm_element = wait.until {
+            confirm_element = driver.find_element(:id, 'confirmButtonTop') rescue nil
+            if ready?(confirm_element)
+              confirm_element
+            else
+              old_confirm_element = driver.find_element(:id, 'continue_abovefold') rescue nil
+              ready?(old_confirm_element) ? old_confirm_element : false
+            end
+          }
+
+          # Wait for page to load. Even if it is displayed and enabled, sometimes the element is still not clickable.
+          sleep 2
+          confirm_element.click
+
+          driver.quit
+        end
+      end
+
+      private
+
+      def ready?(*elements)
+        elements.each do |element|
+          return false unless element && element.displayed? && element.enabled?
+        end
+        true
+      end
+    end
+  end
+end

data/spec/paypal_express/remote/build_plugin_helpers.rb

@@ -0,0 +1,33 @@
+module Killbill
+  module PaypalExpress
+    module BuildPluginHelpers
+      def build_start_paypal_plugin(account_id = nil)
+        if account_id.nil?
+          plugin = build_plugin(::Killbill::PaypalExpress::PaymentPlugin, 'paypal_express')
+          start_plugin plugin
+        else
+          config = YAML.load_file('paypal_express.yml')
+          existing_credential = {:account_id => account_id}.merge config[:paypal_express]
+          second_credential = {:account_id => "#{account_id}_duplicate"}.merge config[:paypal_express]
+          config[:paypal_express] = [second_credential, existing_credential]
+          Dir.mktmpdir do |dir|
+            file_name = File.join(dir, 'paypal_express.yml')
+            File.open(file_name, 'w+') do |file|
+              YAML.dump(config, file)
+            end
+            plugin = build_plugin(::Killbill::PaypalExpress::PaymentPlugin, 'paypal_express', File.dirname(file_name))
+            start_plugin plugin
+          end
+        end
+      end
+
+      def start_plugin(plugin)
+        svcs = plugin.kb_apis.proxied_services
+        svcs[:payment_api] = PaypalExpressJavaPaymentApi.new(plugin)
+        plugin.kb_apis = ::Killbill::Plugin::KillbillApi.new('paypal_express', svcs)
+        plugin.start_plugin
+        plugin
+      end
+    end
+  end
+end

data/spec/paypal_express/remote/hpp_spec.rb

@@ -1,38 +1,16 @@
 require 'spec_helper'
+require_relative 'hpp_spec_helpers'
+require_relative 'build_plugin_helpers'
 
 ActiveMerchant::Billing::Base.mode = :test
 
-describe Killbill::PaypalExpress::PaymentPlugin do
-
-  include ::Killbill::Plugin::ActiveMerchant::RSpec
-
-  before(:all) do
-    @plugin = build_plugin(::Killbill::PaypalExpress::PaymentPlugin, 'paypal_express')
-    svcs = @plugin.kb_apis.proxied_services
-    svcs[:payment_api] = PaypalExpressJavaPaymentApi.new(@plugin)
-    @plugin.kb_apis = ::Killbill::Plugin::KillbillApi.new('paypal_express', svcs)
-    @plugin.start_plugin
-
-    @call_context = build_call_context
-
-    @amount = BigDecimal.new('100')
-    @currency = 'USD'
-    @form_fields  = @plugin.hash_to_properties(
-        :order_id => '1234',
-        :amount   => @amount,
-        :currency => @currency
-    )
-
-    kb_account_id = SecureRandom.uuid
-    create_kb_account(kb_account_id, @plugin.kb_apis.proxied_services[:account_user_api])
-
-    @pm = create_payment_method(::Killbill::PaypalExpress::PaypalExpressPaymentMethod, kb_account_id, @call_context.tenant_id)
-    verify_payment_method
-  end
+shared_examples 'hpp_spec_common' do
 
   before(:each) do
     ::Killbill::PaypalExpress::PaypalExpressTransaction.delete_all
     ::Killbill::PaypalExpress::PaypalExpressResponse.delete_all
+    # clean the payments before each spec to avoid one influences each other
+    @plugin.kb_apis.proxied_services[:payment_api].delete_all_payments
   end
 
   it 'should generate forms correctly' do
@@ -141,116 +119,204 @@ describe Killbill::PaypalExpress::PaymentPlugin do
     ::Killbill::PaypalExpress::PaypalExpressResponse.count.should == 1 + 9 * n
   end
 
-  private
+  it 'should generate forms and perform auth, capture and refund correctly' do
+    ::Killbill::PaypalExpress::PaypalExpressTransaction.count.should == 0
+    ::Killbill::PaypalExpress::PaypalExpressResponse.count.should == 0
 
-  def validate_form(form)
-    form.kb_account_id.should == @pm.kb_account_id
-    form.form_url.should start_with('https://www.sandbox.paypal.com/cgi-bin/webscr')
-    form.form_method.should == 'GET'
-  end
+    # Verify the authorization cannot go through without the token
+    authorize_with_missing_token
 
-  def validate_nil_form_property(form, key)
-    key_properties = form.properties.select { |prop| prop.key == key }
-    key_properties.size.should == 0
-  end
+    # Verify multiple payments can be triggered for the same payment method
+    n = 2
+    1.upto(n) do |i|
+      payment_external_key = SecureRandom.uuid
+      is_pending_payment_test = i % 2 == 1 ? false : true
+      properties = @plugin.hash_to_properties(
+          :transaction_external_key => payment_external_key,
+          # test both with and without pending payments
+          :create_pending_payment => is_pending_payment_test,
+          :payment_processor_account_id => @payment_processor_account_id,
+          :auth_mode => true
+      )
+      form = @plugin.build_form_descriptor(@pm.kb_account_id, @form_fields, properties, @call_context)
+      validate_form(form)
+      token = validate_form_property(form, 'token')
+      # Verify payments were created when create_pending_payment is true
+      @plugin.kb_apis.proxied_services[:payment_api].payments.size.should == i / 2
+      if is_pending_payment_test
+        kb_payment_id = validate_form_property(form, 'kb_payment_id')
+        validate_form_property(form, 'kb_transaction_external_key', payment_external_key)
+        @plugin.kb_apis.proxied_services[:payment_api].get_payment(kb_payment_id).transactions.first.external_key.should == payment_external_key
+        # Verify GET API
+        payment_infos = @plugin.get_payment_info(@pm.kb_account_id, kb_payment_id, properties, @call_context)
+        payment_infos.size.should == 1
+        payment_infos[0].kb_payment_id.should == kb_payment_id
+        payment_infos[0].transaction_type.should == :AUTHORIZE
+        payment_infos[0].amount.should be_nil
+        payment_infos[0].currency.should be_nil
+        payment_infos[0].status.should == :PENDING
+        payment_infos[0].gateway_error.should == '{"payment_plugin_status":"PENDING"}'
+        payment_infos[0].gateway_error_code.should be_nil
+        find_value_from_properties(payment_infos[0].properties, :payment_processor_account_id).should == @payment_processor_account_id
+      else
+        kb_payment_id = SecureRandom.uuid
+        validate_nil_form_property(form, 'kb_payment_id')
+        validate_nil_form_property(form, 'kb_transaction_external_key')
+      end
 
-  def validate_form_property(form, key, value=nil)
-    key_properties = form.properties.select { |prop| prop.key == key }
-    key_properties.size.should == 1
-    key = key_properties.first.value
-    value.nil? ? key.should_not(be_nil) : key.should == value
-    key
-  end
+      properties = []
+      properties << build_property(:token, token)
+      # Verify the payment cannot be authorized without the token being validated
+      authorize_with_invalid_token(properties)
+      # Go to PayPal to validate the token
+      validate_token(form)
 
-  def validate_token(form)
-    print "\nPlease go to #{form.form_url} to proceed and press any key to continue...
-Note: you need to log-in with a paypal sandbox account (create one here: https://developer.paypal.com/webapps/developer/applications/accounts)\n"
-    $stdin.gets
-  end
+      # Verify auth, capture and refund
+      authorize_capture_and_refund(kb_payment_id, payment_external_key, properties, @payment_processor_account_id)
+
+      # Verify no extra payment was created in Kill Bill by the plugin
+      @plugin.kb_apis.proxied_services[:payment_api].payments.size.should == (i / 2)
+
+      # Verify no token/baid was stored
+      verify_payment_method
+    end
 
-  def purchase_and_refund(kb_payment_id, purchase_payment_external_key, purchase_properties)
-    # Trigger the purchase
-    payment_response = @plugin.purchase_payment(@pm.kb_account_id, kb_payment_id, purchase_payment_external_key, @pm.kb_payment_method_id, @amount, @currency, purchase_properties, @call_context)
-    payment_response.status.should eq(:PROCESSED), payment_response.gateway_error
-    payment_response.amount.should == @amount
-    payment_response.transaction_type.should == :PURCHASE
-
-    # Verify GET API
-    payment_infos = @plugin.get_payment_info(@pm.kb_account_id, kb_payment_id, [], @call_context)
-    payment_infos.size.should == 1
-    payment_infos[0].kb_payment_id.should == kb_payment_id
-    payment_infos[0].transaction_type.should == :PURCHASE
-    payment_infos[0].amount.should == @amount
-    payment_infos[0].currency.should == @currency
-    payment_infos[0].status.should == :PROCESSED
-    payment_infos[0].gateway_error.should == 'Success'
-    payment_infos[0].gateway_error_code.should be_nil
-
-    # Try a full refund
-    refund_response = @plugin.refund_payment(@pm.kb_account_id, kb_payment_id, SecureRandom.uuid, @pm.kb_payment_method_id, @amount, @currency, [], @call_context)
-    refund_response.status.should eq(:PROCESSED), refund_response.gateway_error
-    refund_response.amount.should == @amount
-    refund_response.transaction_type.should == :REFUND
-
-    # Verify GET API
-    payment_infos = @plugin.get_payment_info(@pm.kb_account_id, kb_payment_id, [], @call_context)
-    payment_infos.size.should == 2
-    payment_infos[0].kb_payment_id.should == kb_payment_id
-    payment_infos[0].transaction_type.should == :PURCHASE
-    payment_infos[0].amount.should == @amount
-    payment_infos[0].currency.should == @currency
-    payment_infos[0].status.should == :PROCESSED
-    payment_infos[0].gateway_error.should == 'Success'
-    payment_infos[0].gateway_error_code.should be_nil
-    payment_infos[1].kb_payment_id.should.should == kb_payment_id
-    payment_infos[1].transaction_type.should == :REFUND
-    payment_infos[1].amount.should == @amount
-    payment_infos[1].currency.should == @currency
-    payment_infos[1].status.should == :PROCESSED
-    payment_infos[1].gateway_error.should == 'Success'
-    payment_infos[1].gateway_error_code.should be_nil
+    # Each loop triggers one successful auth, one successful capture and one successful refund
+    ::Killbill::PaypalExpress::PaypalExpressTransaction.count.should == 3 * n
+    ::Killbill::PaypalExpress::PaypalExpressResponse.count.should == 1 + 15 * n / 2 + 7 * n % 2
   end
 
-  def purchase_with_missing_token
-    failed_purchase([], :CANCELED, 'Could not find the payer_id: the token is missing', 'RuntimeError')
+  it 'should perform auth and void correctly' do
+    ::Killbill::PaypalExpress::PaypalExpressTransaction.count.should == 0
+    ::Killbill::PaypalExpress::PaypalExpressResponse.count.should == 0
+
+    # Verify multiple payments can be triggered for the same payment method
+    n = 2
+    1.upto(n) do |i|
+      payment_external_key = SecureRandom.uuid
+      is_pending_payment_test = i % 2 == 1 ? false : true
+      properties = @plugin.hash_to_properties(
+          :transaction_external_key => payment_external_key,
+          :create_pending_payment => is_pending_payment_test,
+          :auth_mode => true,
+          :payment_processor_account_id => @payment_processor_account_id
+      )
+      form = @plugin.build_form_descriptor(@pm.kb_account_id, @form_fields, properties, @call_context)
+      validate_form(form)
+      token = validate_form_property(form, 'token')
+      if is_pending_payment_test
+        kb_payment_id = validate_form_property(form, 'kb_payment_id')
+      else
+        kb_payment_id = SecureRandom.uuid
+      end
+
+      # Go to PayPal to validate the token
+      validate_token(form)
+
+      properties = []
+      properties << build_property('token', token)
+
+      authorize_and_void(kb_payment_id, payment_external_key, properties, @payment_processor_account_id)
+
+      # Verify no extra payment was created in Kill Bill by the plugin
+      @plugin.kb_apis.proxied_services[:payment_api].payments.size.should == i / 2
+    end
+
+    # Each loop triggers one successful authorize and one successful void
+    ::Killbill::PaypalExpress::PaypalExpressTransaction.count.should == 2 * n
+    ::Killbill::PaypalExpress::PaypalExpressResponse.count.should == 9 * n / 2 + 5 * n % 2
   end
 
-  def purchase_with_invalid_token(purchase_properties)
-    failed_purchase(purchase_properties, :CANCELED, "Could not find the payer_id for token #{properties_to_hash(purchase_properties)[:token]}", 'RuntimeError')
+  it 'should not capture the same transaction twice with full amount' do
+    ::Killbill::PaypalExpress::PaypalExpressTransaction.count.should == 0
+    ::Killbill::PaypalExpress::PaypalExpressResponse.count.should == 0
+
+    payment_external_key = SecureRandom.uuid
+    properties = @plugin.hash_to_properties(
+        :transaction_external_key => payment_external_key,
+        :create_pending_payment => true,
+        :auth_mode => true
+    )
+
+    form = @plugin.build_form_descriptor(@pm.kb_account_id, @form_fields, properties, @call_context)
+    validate_form(form)
+    kb_payment_id = validate_form_property(form, 'kb_payment_id')
+    validate_form_property(form, 'kb_transaction_external_key', payment_external_key)
+    token = validate_form_property(form, 'token')
+
+    properties = []
+    properties << build_property('token', token)
+    properties << build_property('auth_mode', 'true')
+
+    validate_token(form)
+
+    authorize_and_double_capture(kb_payment_id, payment_external_key, properties)
   end
 
-  def subsequent_purchase(purchase_properties)
-    failed_purchase(purchase_properties, :ERROR, 'A successful transaction has already been completed for this token.')
+  it 'should find the payment processor id from the initial_express_call' do
+    ::Killbill::PaypalExpress::PaypalExpressTransaction.count.should == 0
+    ::Killbill::PaypalExpress::PaypalExpressResponse.count.should == 0
+
+    properties = @plugin.hash_to_properties(
+        :transaction_external_key => SecureRandom.uuid,
+        :create_pending_payment => true,
+        :auth_mode => true,
+        :payment_processor_account_id => @payment_processor_account_id
+    )
+    form = @plugin.build_form_descriptor(@pm.kb_account_id, @form_fields, properties, @call_context)
+    token = validate_form_property(form, 'token')
+    @plugin.send(:find_payment_processor_id_from_initial_call, @pm.kb_account_id, @call_context.tenant_id, token).should == @payment_processor_account_id
+
+    properties = @plugin.hash_to_properties(
+        :transaction_external_key => SecureRandom.uuid,
+        :auth_mode => true,
+        :payment_processor_account_id => @payment_processor_account_id
+    )
+    form = @plugin.build_form_descriptor(@pm.kb_account_id, @form_fields, properties, @call_context)
+    token = validate_form_property(form, 'token')
+    @plugin.send(:find_payment_processor_id_from_initial_call, @pm.kb_account_id, @call_context.tenant_id, token).should == @payment_processor_account_id
+
+    properties = @plugin.hash_to_properties(
+        :transaction_external_key => SecureRandom.uuid,
+        :create_pending_payment => true,
+        :payment_processor_account_id => @payment_processor_account_id
+    )
+    form = @plugin.build_form_descriptor(@pm.kb_account_id, @form_fields, properties, @call_context)
+    token = validate_form_property(form, 'token')
+    @plugin.send(:find_payment_processor_id_from_initial_call, @pm.kb_account_id, @call_context.tenant_id, token).should == @payment_processor_account_id
+
+    properties = @plugin.hash_to_properties(
+        :transaction_external_key => SecureRandom.uuid,
+        :payment_processor_account_id => @payment_processor_account_id
+    )
+    form = @plugin.build_form_descriptor(@pm.kb_account_id, @form_fields, properties, @call_context)
+    token = validate_form_property(form, 'token')
+    @plugin.send(:find_payment_processor_id_from_initial_call, @pm.kb_account_id, @call_context.tenant_id, token).should == @payment_processor_account_id
   end
+end
 
-  def failed_purchase(purchase_properties, status, msg, gateway_error_code=nil)
-    kb_payment_id = SecureRandom.uuid
-
-    payment_response = @plugin.purchase_payment(@pm.kb_account_id, kb_payment_id, SecureRandom.uuid, @pm.kb_payment_method_id, @amount, @currency, purchase_properties, @call_context)
-    payment_response.status.should eq(status), payment_response.gateway_error
-    payment_response.amount.should be_nil
-    payment_response.transaction_type.should == :PURCHASE
-
-    # Verify GET API
-    payment_infos = @plugin.get_payment_info(@pm.kb_account_id, kb_payment_id, [], @call_context)
-    payment_infos.size.should == 1
-    payment_infos[0].kb_payment_id.should == kb_payment_id
-    payment_infos[0].transaction_type.should == :PURCHASE
-    payment_infos[0].amount.should be_nil
-    payment_infos[0].currency.should be_nil
-    payment_infos[0].status.should == status
-    payment_infos[0].gateway_error.should == msg
-    payment_infos[0].gateway_error_code.should == gateway_error_code
+describe Killbill::PaypalExpress::PaymentPlugin do
+  include ::Killbill::Plugin::ActiveMerchant::RSpec
+  include ::Killbill::PaypalExpress::BuildPluginHelpers
+  include ::Killbill::PaypalExpress::HppSpecHelpers
+
+  context 'hpp test with a single account' do
+    before(:all) do
+      @payment_processor_account_id = 'default'
+      @plugin = build_start_paypal_plugin
+      hpp_setup
+    end
+
+    include_examples 'hpp_spec_common'
   end
 
-  def verify_payment_method
-    # Verify our table directly
-    payment_methods = ::Killbill::PaypalExpress::PaypalExpressPaymentMethod.from_kb_account_id(@pm.kb_account_id, @call_context.tenant_id)
-    payment_methods.size.should == 1
-    payment_method = payment_methods.first
-    payment_method.should_not be_nil
-    payment_method.paypal_express_payer_id.should be_nil
-    payment_method.token.should be_nil
-    payment_method.kb_payment_method_id.should == @pm.kb_payment_method_id
+  context 'hpp test with multiple accounts' do
+    before(:all) do
+      @payment_processor_account_id = 'paypal_test_account'
+      @plugin = build_start_paypal_plugin @payment_processor_account_id
+      hpp_setup
+    end
+
+    include_examples 'hpp_spec_common'
   end
 end