killbill-paypal-express 4.0.0 → 4.1.0

data/lib/paypal_express/api.rb

@@ -16,6 +16,7 @@ module Killbill #:nodoc:
               ::Killbill::PaypalExpress::PaypalExpressResponse)
 
         @ip = ::Killbill::Plugin::ActiveMerchant::Utils.ip
+        @private_api = ::Killbill::PaypalExpress::PrivatePaymentPlugin.new
       end
 
       def on_event(event)
@@ -56,20 +57,73 @@ module Killbill #:nodoc:
       end
 
       def purchase_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
-        # Pass extra parameters for the gateway here
-        options = {}
-
-        add_required_options(kb_payment_transaction_id, kb_payment_method_id, context, options)
-
-        properties        = merge_properties(properties, options)
-
-        # Can't use default implementation: the purchase signature is for one-off payments only
-        #super(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
-        gateway_call_proc = Proc.new do |gateway, linked_transaction, payment_source, amount_in_cents, options|
-          gateway.reference_transaction(amount_in_cents, options)
+        payment_processor_account_id = find_value_from_properties(properties, 'payment_processor_account_id')
+
+        # Callback from the plugin itself (HPP flow)
+        if find_value_from_properties(properties, 'from_hpp') == 'true'
+          token = find_value_from_properties(properties, 'token')
+
+          response = @response_model.create(:api_call                     => :build_form_descriptor,
+                                            :kb_account_id                => kb_account_id,
+                                            :kb_payment_id                => kb_payment_id,
+                                            :kb_payment_transaction_id    => kb_payment_transaction_id,
+                                            :transaction_type             => :PURCHASE,
+                                            :authorization                => token,
+                                            :payment_processor_account_id => payment_processor_account_id,
+                                            :kb_tenant_id                 => context.tenant_id,
+                                            :success                      => true,
+                                            :created_at                   => Time.now.utc,
+                                            :updated_at                   => Time.now.utc,
+                                            :message                      => { :payment_plugin_status => :PENDING }.to_json)
+          transaction          = response.to_transaction_info_plugin(nil)
+          transaction.amount   = amount
+          transaction.currency = currency
+          transaction
+        else
+          options = {}
+          add_required_options(kb_payment_transaction_id, kb_payment_method_id, context, options)
+
+          # We have a baid on file
+          if options[:token]
+            gateway_call_proc = Proc.new do |gateway, linked_transaction, payment_source, amount_in_cents, options|
+              # Can't use default implementation: the purchase signature is for one-off payments only
+              gateway.reference_transaction(amount_in_cents, options)
+            end
+          else
+            # One-off payment
+            options[:token]    = find_value_from_properties(properties, 'token') || find_last_token(kb_account_id, context.tenant_id)
+            gateway_call_proc  = Proc.new do |gateway, linked_transaction, payment_source, amount_in_cents, options|
+              gateway.purchase(amount_in_cents, options)
+            end
+          end
+
+          # Populate the Payer id if missing
+          options[:payer_id] = find_value_from_properties(properties, 'payer_id')
+          begin
+            options[:payer_id] ||= find_payer_id(options[:token],
+                                                 kb_account_id,
+                                                 context.tenant_id,
+                                                 properties_to_hash(properties))
+          rescue => e
+            # Maybe invalid token?
+            response = @response_model.create(:api_call                     => :purchase,
+                                              :kb_account_id                => kb_account_id,
+                                              :kb_payment_id                => kb_payment_id,
+                                              :kb_payment_transaction_id    => kb_payment_transaction_id,
+                                              :transaction_type             => :PURCHASE,
+                                              :authorization                => nil,
+                                              :payment_processor_account_id => payment_processor_account_id,
+                                              :kb_tenant_id                 => context.tenant_id,
+                                              :success                      => false,
+                                              :created_at                   => Time.now.utc,
+                                              :updated_at                   => Time.now.utc,
+                                              :message                      => { :payment_plugin_status => :CANCELED, :exception_class => e.class.to_s, :exception_message => e.message }.to_json)
+            return response.to_transaction_info_plugin(nil)
+          end
+
+          properties = merge_properties(properties, options)
+          dispatch_to_gateways(:purchase, kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context, gateway_call_proc)
         end
-
-        dispatch_to_gateways(:purchase, kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context, gateway_call_proc)
       end
 
       def void_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, properties, context)
@@ -105,11 +159,14 @@ module Killbill #:nodoc:
       end
 
       def get_payment_info(kb_account_id, kb_payment_id, properties, context)
-        # Pass extra parameters for the gateway here
-        options = {}
+        t_info_plugins = super(kb_account_id, kb_payment_id, properties, context)
 
-        properties = merge_properties(properties, options)
-        super(kb_account_id, kb_payment_id, properties, context)
+        # Completed purchases will have two rows in the responses table (one for api_call 'build_form_descriptor', one for api_call 'purchase')
+        # Other transaction types don't support the :PENDING state
+        is_purchase_pending = t_info_plugins.find { |t_info_plugin| t_info_plugin.transaction_type == :PURCHASE && t_info_plugin.status != :PENDING }.nil?
+        t_info_plugins_without_purchase_pending = t_info_plugins.reject { |t_info_plugin| t_info_plugin.transaction_type == :PURCHASE && t_info_plugin.status == :PENDING }
+
+        is_purchase_pending ? t_info_plugins: t_info_plugins_without_purchase_pending
       end
 
       def search_payments(search_key, offset, limit, properties, context)
@@ -121,25 +178,22 @@ module Killbill #:nodoc:
       end
 
       def add_payment_method(kb_account_id, kb_payment_method_id, payment_method_props, set_default, properties, context)
-        # token is passed via properties
-        token = find_value_from_properties(properties, 'token')
-        # token is passed from the json body
-        token = find_value_from_properties(payment_method_props.properties, 'token') if token.nil?
-        raise 'No token specified!' if token.nil?
-
-        # Go to Paypal to get the Payer id (GetExpressCheckoutDetails call)
-        options                      = properties_to_hash(properties)
-        payment_processor_account_id = options[:payment_processor_account_id] || :default
-        gateway                      = lookup_gateway(payment_processor_account_id, context.tenant_id)
-        gw_response                  = gateway.details_for(token)
-        response, transaction        = save_response_and_transaction(gw_response, :details_for, kb_account_id, context.tenant_id, payment_processor_account_id)
-        raise response.message unless response.success? and !response.payer_id.blank?
-
-        # Pass extra parameters for the gateway here
-        options = {
-            :paypal_express_token    => token,
-            :paypal_express_payer_id => response.payer_id
-        }
+        all_properties = (payment_method_props.nil? || payment_method_props.properties.nil? ? [] : payment_method_props.properties) + properties
+        token = find_value_from_properties(all_properties, 'token')
+
+        if token.nil?
+          # HPP flow
+          options = {
+              :skip_gw => true
+          }
+        else
+          # Go to Paypal to get the Payer id (GetExpressCheckoutDetails call)
+          payer_id = find_payer_id(token, kb_account_id, context.tenant_id, properties_to_hash(properties))
+          options  = {
+              :paypal_express_token    => token,
+              :paypal_express_payer_id => payer_id
+          }
+        end
 
         properties = merge_properties(properties, options)
         super(kb_account_id, kb_payment_method_id, payment_method_props, set_default, properties, context)
@@ -186,17 +240,49 @@ module Killbill #:nodoc:
       end
 
       def build_form_descriptor(kb_account_id, descriptor_fields, properties, context)
-        # Pass extra parameters for the gateway here
-        options           = {}
-        properties        = merge_properties(properties, options)
-
-        # Add your custom static hidden tags here
-        options           = {
-            #:token => config[:paypal-express][:token]
-        }
-        descriptor_fields = merge_properties(descriptor_fields, options)
+        jcontext = @kb_apis.create_context(context.tenant_id)
+
+        all_properties = descriptor_fields + properties
+        options = properties_to_hash(all_properties)
+
+        kb_account = ::Killbill::Plugin::ActiveMerchant::Utils::LazyEvaluator.new { @kb_apis.account_user_api.get_account_by_id(kb_account_id, jcontext) }
+        amount = (options[:amount] || '0').to_f
+        currency = options[:currency] || kb_account.currency
+
+        response = initiate_express_checkout(kb_account_id, amount, currency, all_properties, context)
+
+        descriptor = super(kb_account_id, descriptor_fields, properties, context)
+        descriptor.form_url = @private_api.to_express_checkout_url(response, context.tenant_id, options)
+        descriptor.form_method = 'GET'
+        descriptor.properties << build_property('token', response.token)
+
+        # By default, pending payments are not created for HPP
+        create_pending_payment = ::Killbill::Plugin::ActiveMerchant::Utils.normalized(options, :create_pending_payment)
+        if create_pending_payment
+          custom_props = hash_to_properties(:from_hpp => true,
+                                            :token    => response.token)
+          payment_external_key = ::Killbill::Plugin::ActiveMerchant::Utils.normalized(options, :payment_external_key)
+          transaction_external_key = ::Killbill::Plugin::ActiveMerchant::Utils.normalized(options, :transaction_external_key)
+
+          kb_payment_method = (@kb_apis.payment_api.get_account_payment_methods(kb_account_id, false, [], jcontext).find { |pm| pm.plugin_name == 'killbill-paypal-express' })
+          payment = @kb_apis.payment_api
+                            .create_purchase(kb_account.send(:__instance_object__),
+                                             kb_payment_method.id,
+                                             nil,
+                                             amount,
+                                             currency,
+                                             payment_external_key,
+                                             transaction_external_key,
+                                             custom_props,
+                                             jcontext)
+
+          descriptor.properties << build_property('kb_payment_id', payment.id)
+          descriptor.properties << build_property('kb_payment_external_key', payment.external_key)
+          descriptor.properties << build_property('kb_transaction_id', payment.transactions.first.id)
+          descriptor.properties << build_property('kb_transaction_external_key', payment.transactions.first.external_key)
+        end
 
-        super(kb_account_id, descriptor_fields, properties, context)
+        descriptor
       end
 
       def process_notification(notification, properties, context)
@@ -227,17 +313,59 @@ module Killbill #:nodoc:
 
       private
 
+      def find_last_token(kb_account_id, kb_tenant_id)
+        @response_model.last_token(kb_account_id, kb_tenant_id)
+      end
+
+      def find_payer_id(token, kb_account_id, kb_tenant_id, options = {})
+        raise 'Could not find the payer_id: the token is missing' if token.blank?
+
+        # Go to Paypal to get the Payer id (GetExpressCheckoutDetails call)
+        payment_processor_account_id = options[:payment_processor_account_id] || :default
+        gateway                      = lookup_gateway(payment_processor_account_id, kb_tenant_id)
+        gw_response                  = gateway.details_for(token)
+        response, transaction        = save_response_and_transaction(gw_response, :details_for, kb_account_id, kb_tenant_id, payment_processor_account_id)
+
+        raise response.message unless response.success?
+        raise "Could not find the payer_id for token #{token}" if response.payer_id.blank?
+
+        response.payer_id
+      end
+
       def add_required_options(kb_payment_transaction_id, kb_payment_method_id, context, options)
         payment_method = @payment_method_model.from_kb_payment_method_id(kb_payment_method_id, context.tenant_id)
 
-        options[:payer_id]     ||= payment_method.paypal_express_payer_id
-        options[:token]        ||= payment_method.paypal_express_token
-        options[:reference_id] ||= payment_method.token # baid
+        options[:payer_id]     ||= payment_method.paypal_express_payer_id.presence
+        options[:token]        ||= payment_method.paypal_express_token.presence
+        options[:reference_id] ||= payment_method.token.presence # baid
 
         options[:payment_type] ||= 'Any'
         options[:invoice_id]   ||= kb_payment_transaction_id
         options[:ip]           ||= @ip
       end
+
+      def initiate_express_checkout(kb_account_id, amount, currency, properties, context)
+        properties_hash = properties_to_hash(properties)
+
+        with_baid = ::Killbill::Plugin::ActiveMerchant::Utils.normalized(properties_hash, :with_baid)
+
+        options = {}
+        options[:return_url] = ::Killbill::Plugin::ActiveMerchant::Utils.normalized(properties_hash, :return_url)
+        options[:cancel_return_url] = ::Killbill::Plugin::ActiveMerchant::Utils.normalized(properties_hash, :cancel_return_url)
+
+        amount_in_cents = amount.nil? ? nil : to_cents(amount, currency)
+        response = @private_api.initiate_express_checkout(kb_account_id,
+                                                          context.tenant_id.to_s,
+                                                          amount_in_cents,
+                                                          currency,
+                                                          with_baid,
+                                                          options)
+        unless response.success?
+          raise "Unable to initiate paypal express checkout: #{response.message}"
+        end
+
+        response
+      end
     end
   end
 end

data/lib/paypal_express/application.rb

@@ -67,6 +67,7 @@ post '/plugins/killbill-paypal-express/1.0/setup-checkout', :provides => 'json'
                                               kb_tenant_id,
                                               data['amount_in_cents'] || 0,
                                               data['currency'] || 'USD',
+                                              true,
                                               options
   unless response.success?
     status 500

data/lib/paypal_express/ext/active_merchant/active_merchant.rb

@@ -0,0 +1,18 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module PaypalCommonAPI
+
+      DUPLICATE_REQUEST_CODE = '11607'
+
+      alias_method :original_successful?, :successful?
+
+      # Note: this may need more thoughts when/if we want to support MsgSubID
+      # See https://developer.paypal.com/docs/classic/express-checkout/integration-guide/ECRelatedAPIOps/#idempotency
+      # For now, we just want to correctly handle a subsequent payment using a one-time token
+      # (error "A successful transaction has already been completed for this token.")
+      def successful?(response)
+        response[:error_codes] == DUPLICATE_REQUEST_CODE ? false : original_successful?(response)
+      end
+    end
+  end
+end

data/lib/paypal_express/models/response.rb

@@ -59,6 +59,14 @@ module Killbill #:nodoc:
               model)
       end
 
+      def self.last_token(kb_account_id, kb_tenant_id)
+        response = where(:api_call => 'initiate_express_checkout',
+                         :success => true,
+                         :kb_account_id => kb_account_id,
+                         :kb_tenant_id => kb_tenant_id).last
+        response.nil? ? nil : response.token
+      end
+
       def to_transaction_info_plugin(transaction=nil)
         t_info_plugin = super(transaction)
 

data/lib/paypal_express/private_api.rb

@@ -10,23 +10,23 @@ module Killbill #:nodoc:
       end
 
       # See https://cms.paypal.com/uk/cgi-bin/?cmd=_render-content&content_ID=developer/e_howto_api_ECReferenceTxns
-      def initiate_express_checkout(kb_account_id, kb_tenant_id, amount_in_cents=0, currency='USD', options = {})
-        payment_processor_account_id = (options[:payment_processor_account_id] || :default)
-
+      def initiate_express_checkout(kb_account_id, kb_tenant_id, amount_in_cents=0, currency='USD', with_baid=true, options = {})
         options[:currency]          ||= currency
 
         # Required arguments
         options[:return_url]        ||= 'http://www.example.com/success'
         options[:cancel_return_url] ||= 'http://www.example.com/sad_panda'
 
-        options[:billing_agreement]               ||= {}
-        options[:billing_agreement][:type]        ||= 'MerchantInitiatedBilling'
-        options[:billing_agreement][:description] ||= 'Kill Bill billing agreement'
+        if with_baid
+          options[:billing_agreement]               ||= {}
+          options[:billing_agreement][:type]        ||= 'MerchantInitiatedBilling'
+          options[:billing_agreement][:description] ||= 'Kill Bill billing agreement'
+        end
 
         # Go to Paypal (SetExpressCheckout call)
-        payment_processor_account_id              = options[:payment_processor_account_id] || :default
-        paypal_express_response                   = gateway(payment_processor_account_id, kb_tenant_id).setup_authorization(amount_in_cents, options)
-        response, transaction                     = save_response_and_transaction(paypal_express_response, :initiate_express_checkout, kb_account_id, kb_tenant_id, payment_processor_account_id)
+        payment_processor_account_id = options[:payment_processor_account_id] || :default
+        paypal_express_response      = gateway(payment_processor_account_id, kb_tenant_id).setup_authorization(amount_in_cents, options)
+        response, transaction        = save_response_and_transaction(paypal_express_response, :initiate_express_checkout, kb_account_id, kb_tenant_id, payment_processor_account_id)
 
         response
       end

data/pom.xml

@@ -26,7 +26,7 @@
     <groupId>org.kill-bill.billing.plugin.ruby</groupId>
     <artifactId>paypal-express-plugin</artifactId>
     <packaging>pom</packaging>
-    <version>4.0.0</version>
+    <version>4.1.0</version>
     <name>paypal-express-plugin</name>
     <url>http://github.com/killbill/killbill-paypal-express-plugin</url>
     <description>Plugin for accessing Paypal Express Checkout as a payment gateway</description>

data/spec/paypal_express/base_plugin_spec.rb

@@ -31,23 +31,6 @@ describe Killbill::PaypalExpress::PaymentPlugin do
     @plugin.stop_plugin
   end
 
-  it 'should generate forms correctly' do
-    kb_account_id = SecureRandom.uuid
-    kb_tenant_id  = SecureRandom.uuid
-    context       = @plugin.kb_apis.create_context(kb_tenant_id)
-    fields        = @plugin.hash_to_properties({
-                                                   :order_id => '1234',
-                                                   :amount   => 10
-                                               })
-    form          = @plugin.build_form_descriptor kb_account_id, fields, [], context
-
-    form.kb_account_id.should == kb_account_id
-    form.form_method.should == 'POST'
-    form.form_url.should == 'https://www.paypal.com/cgi-bin/webscr'
-
-    form_fields = @plugin.properties_to_hash(form.form_fields)
-  end
-
   it 'should receive notifications correctly' do
     description    = 'description'
 

data/spec/paypal_express/remote/baid_spec.rb

@@ -0,0 +1,287 @@
+require 'spec_helper'
+
+ActiveMerchant::Billing::Base.mode = :test
+
+describe Killbill::PaypalExpress::PaymentPlugin do
+
+  include ::Killbill::Plugin::ActiveMerchant::RSpec
+
+  # Share the BAID
+  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
+
+    @properties = []
+    @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)
+    token = response.token
+    print "\nPlease go to #{@plugin.to_express_checkout_url(response, @call_context.tenant_id)} 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
+
+    # Complete the setup process
+    @properties << build_property('token', token)
+    @pm = create_payment_method(::Killbill::PaypalExpress::PaypalExpressPaymentMethod, kb_account_id, @call_context.tenant_id, @properties)
+
+    # 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
+
+  before(:each) do
+    ::Killbill::PaypalExpress::PaypalExpressTransaction.delete_all
+    ::Killbill::PaypalExpress::PaypalExpressResponse.delete_all
+
+    kb_payment_id = SecureRandom.uuid
+    1.upto(6) do
+      @kb_payment = @plugin.kb_apis.proxied_services[:payment_api].add_payment(kb_payment_id)
+    end
+  end
+
+  it 'should be able to charge and refund' do
+    payment_response = @plugin.purchase_payment(@pm.kb_account_id, @kb_payment.id, @kb_payment.transactions[0].id, @pm.kb_payment_method_id, @amount, @currency, @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, @kb_payment.transactions[1].id, @pm.kb_payment_method_id, @amount, @currency, @properties, @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 == @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
+  end
+
+  it 'should be able to auth, capture and refund' do
+    payment_response = @plugin.authorize_payment(@pm.kb_account_id, @kb_payment.id, @kb_payment.transactions[0].id, @pm.kb_payment_method_id, @amount, @currency, @properties, @call_context)
+    payment_response.status.should eq(:PROCESSED), payment_response.gateway_error
+    payment_response.amount.should == @amount
+    payment_response.transaction_type.should == :AUTHORIZE
+
+    # 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 == :AUTHORIZE
+    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 multiple partial captures
+    partial_capture_amount = BigDecimal.new('10')
+    1.upto(3) do |i|
+      payment_response = @plugin.capture_payment(@pm.kb_account_id, @kb_payment.id, @kb_payment.transactions[i].id, @pm.kb_payment_method_id, partial_capture_amount, @currency, @properties, @call_context)
+      payment_response.status.should eq(:PROCESSED), payment_response.gateway_error
+      payment_response.amount.should == partial_capture_amount
+      payment_response.transaction_type.should == :CAPTURE
+
+      # Verify GET API
+      payment_infos = @plugin.get_payment_info(@pm.kb_account_id, @kb_payment.id, [], @call_context)
+      payment_infos.size.should == 1 + i
+      payment_infos[i].kb_payment_id.should == @kb_payment.id
+      payment_infos[i].transaction_type.should == :CAPTURE
+      payment_infos[i].amount.should == partial_capture_amount
+      payment_infos[i].currency.should == @currency
+      payment_infos[i].status.should == :PROCESSED
+      payment_infos[i].gateway_error.should == 'Success'
+      payment_infos[i].gateway_error_code.should be_nil
+    end
+
+    # Try a partial refund
+    refund_response = @plugin.refund_payment(@pm.kb_account_id, @kb_payment.id, @kb_payment.transactions[4].id, @pm.kb_payment_method_id, partial_capture_amount, @currency, @properties, @call_context)
+    refund_response.status.should eq(:PROCESSED), refund_response.gateway_error
+    refund_response.amount.should == partial_capture_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 == 5
+    payment_infos[4].kb_payment_id.should == @kb_payment.id
+    payment_infos[4].transaction_type.should == :REFUND
+    payment_infos[4].amount.should == partial_capture_amount
+    payment_infos[4].currency.should == @currency
+    payment_infos[4].status.should == :PROCESSED
+    payment_infos[4].gateway_error.should == 'Success'
+    payment_infos[4].gateway_error_code.should be_nil
+
+    # Try to capture again
+    payment_response = @plugin.capture_payment(@pm.kb_account_id, @kb_payment.id, @kb_payment.transactions[5].id, @pm.kb_payment_method_id, partial_capture_amount, @currency, @properties, @call_context)
+    payment_response.status.should eq(:PROCESSED), payment_response.gateway_error
+    payment_response.amount.should == partial_capture_amount
+    payment_response.transaction_type.should == :CAPTURE
+
+    # Verify GET API
+    payment_infos = @plugin.get_payment_info(@pm.kb_account_id, @kb_payment.id, [], @call_context)
+    payment_infos.size.should == 6
+    payment_infos[5].kb_payment_id.should == @kb_payment.id
+    payment_infos[5].transaction_type.should == :CAPTURE
+    payment_infos[5].amount.should == partial_capture_amount
+    payment_infos[5].currency.should == @currency
+    payment_infos[5].status.should == :PROCESSED
+    payment_infos[5].gateway_error.should == 'Success'
+    payment_infos[5].gateway_error_code.should be_nil
+  end
+
+  it 'should be able to auth and void' do
+    payment_response = @plugin.authorize_payment(@pm.kb_account_id, @kb_payment.id, @kb_payment.transactions[0].id, @pm.kb_payment_method_id, @amount, @currency, @properties, @call_context)
+    payment_response.status.should eq(:PROCESSED), payment_response.gateway_error
+    payment_response.amount.should == @amount
+    payment_response.transaction_type.should == :AUTHORIZE
+
+    # 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 == :AUTHORIZE
+    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_response = @plugin.void_payment(@pm.kb_account_id, @kb_payment.id, @kb_payment.transactions[1].id, @pm.kb_payment_method_id, @properties, @call_context)
+    payment_response.status.should eq(:PROCESSED), payment_response.gateway_error
+    payment_response.transaction_type.should == :VOID
+
+    # 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 == :AUTHORIZE
+    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 == @kb_payment.id
+    payment_infos[1].transaction_type.should == :VOID
+    payment_infos[1].amount.should be_nil
+    payment_infos[1].currency.should be_nil
+    payment_infos[1].status.should == :PROCESSED
+    payment_infos[1].gateway_error.should == 'Success'
+    payment_infos[1].gateway_error_code.should be_nil
+  end
+
+  it 'should be able to auth, partial capture and void' do
+    payment_response = @plugin.authorize_payment(@pm.kb_account_id, @kb_payment.id, @kb_payment.transactions[0].id, @pm.kb_payment_method_id, @amount, @currency, @properties, @call_context)
+    payment_response.status.should eq(:PROCESSED), payment_response.gateway_error
+    payment_response.amount.should == @amount
+    payment_response.transaction_type.should == :AUTHORIZE
+
+    # 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 == :AUTHORIZE
+    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
+
+    partial_capture_amount = BigDecimal.new('10')
+    payment_response = @plugin.capture_payment(@pm.kb_account_id, @kb_payment.id, @kb_payment.transactions[1].id, @pm.kb_payment_method_id, partial_capture_amount, @currency, @properties, @call_context)
+    payment_response.status.should eq(:PROCESSED), payment_response.gateway_error
+    payment_response.amount.should == partial_capture_amount
+    payment_response.transaction_type.should == :CAPTURE
+
+    # 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[1].kb_payment_id.should == @kb_payment.id
+    payment_infos[1].transaction_type.should == :CAPTURE
+    payment_infos[1].amount.should == partial_capture_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
+
+    payment_response = @plugin.void_payment(@pm.kb_account_id, @kb_payment.id, @kb_payment.transactions[2].id, @pm.kb_payment_method_id, @properties, @call_context)
+    payment_response.status.should eq(:PROCESSED), payment_response.gateway_error
+    payment_response.transaction_type.should == :VOID
+
+    # Verify GET API
+    payment_infos = @plugin.get_payment_info(@pm.kb_account_id, @kb_payment.id, [], @call_context)
+    payment_infos.size.should == 3
+    payment_infos[2].kb_payment_id.should == @kb_payment.id
+    payment_infos[2].transaction_type.should == :VOID
+    payment_infos[2].amount.should be_nil
+    payment_infos[2].currency.should be_nil
+    payment_infos[2].status.should == :PROCESSED
+    payment_infos[2].gateway_error.should == 'Success'
+    payment_infos[2].gateway_error_code.should be_nil
+  end
+
+  it 'should generate forms correctly' do
+    context = @plugin.kb_apis.create_context(@call_context.tenant_id)
+    fields  = @plugin.hash_to_properties(
+                 :order_id => '1234',
+                 :amount   => 12,
+              )
+
+    properties = @plugin.hash_to_properties(
+      :create_pending_payment => false
+    )
+
+    form = @plugin.build_form_descriptor(@pm.kb_account_id, fields, properties, context)
+
+    form.kb_account_id.should == @pm.kb_account_id
+    form.form_method.should   == 'GET'
+    form.form_url.should start_with('https://www.sandbox.paypal.com/cgi-bin/webscr')
+  end
+
+  private
+
+  def create_token(kb_account_id, kb_tenant_id)
+    private_plugin = ::Killbill::PaypalExpress::PrivatePaymentPlugin.new
+    response       = private_plugin.initiate_express_checkout(kb_account_id, kb_tenant_id)
+    response.success.should be_true
+    response
+  end
+end