killbill-paypal-express 1.0.1

data/lib/paypal_express/models/paypal_express_response.rb

@@ -0,0 +1,159 @@
+module Killbill::PaypalExpress
+  class PaypalExpressResponse < ActiveRecord::Base
+    has_one :paypal_express_transaction
+    attr_accessible :api_call,
+                    :kb_payment_id,
+                    :message,
+                    # transaction_id, authorization_id (reauthorization) or refund_transaction_id
+                    :authorization,
+                    :fraud_review,
+                    :test,
+                    :token,
+                    :payer_id,
+                    :billing_agreement_id,
+                    :payer_name,
+                    :payer_email,
+                    :payer_country,
+                    :contact_phone,
+                    :ship_to_address_name,
+                    :ship_to_address_company,
+                    :ship_to_address_address1,
+                    :ship_to_address_address2,
+                    :ship_to_address_city,
+                    :ship_to_address_state,
+                    :ship_to_address_country,
+                    :ship_to_address_zip,
+                    :ship_to_address_phone,
+                    :receiver_info_business,
+                    :receiver_info_receiver,
+                    :receiver_info_receiverid,
+                    :payment_info_transactionid,
+                    :payment_info_parenttransactionid,
+                    :payment_info_receiptid,
+                    :payment_info_transactiontype,
+                    :payment_info_paymenttype,
+                    :payment_info_paymentdate,
+                    :payment_info_grossamount,
+                    :payment_info_feeamount,
+                    :payment_info_taxamount,
+                    :payment_info_exchangerate,
+                    :payment_info_paymentstatus,
+                    :payment_info_pendingreason,
+                    :payment_info_reasoncode,
+                    :payment_info_protectioneligibility,
+                    :payment_info_protectioneligibilitytype,
+                    :payment_info_shipamount,
+                    :payment_info_shiphandleamount,
+                    :payment_info_shipdiscount,
+                    :payment_info_insuranceamount,
+                    :payment_info_subject,
+                    :avs_result_code,
+                    :avs_result_message,
+                    :avs_result_street_match,
+                    :avs_result_postal_match,
+                    :cvv_result_code,
+                    :cvv_result_message,
+                    :success
+
+    def self.from_response(api_call, kb_payment_id, response)
+      PaypalExpressResponse.new({
+                                  :api_call => api_call,
+                                  :kb_payment_id => kb_payment_id,
+                                  :message => response.message,
+                                  :authorization => response.authorization,
+                                  :fraud_review => response.fraud_review?,
+                                  :test => response.test?,
+                                  :token => response.token,
+                                  :payer_id => response.payer_id,
+                                  :billing_agreement_id => response.params['billing_agreement_id'],
+                                  :payer_name => response.name,
+                                  :payer_email => response.email,
+                                  :payer_country => response.payer_country,
+                                  :contact_phone => response.contact_phone,
+                                  :ship_to_address_name => response.address['name'],
+                                  :ship_to_address_company => response.address['company'],
+                                  :ship_to_address_address1 => response.address['address1'],
+                                  :ship_to_address_address2 => response.address['address2'],
+                                  :ship_to_address_city => response.address['city'],
+                                  :ship_to_address_state => response.address['state'],
+                                  :ship_to_address_country => response.address['country'],
+                                  :ship_to_address_zip => response.address['zip'],
+                                  :ship_to_address_phone => response.address['phone'],
+                                  :receiver_info_business => receiver_info(response)['Business'],
+                                  :receiver_info_receiver => receiver_info(response)['Receiver'],
+                                  :receiver_info_receiverid => receiver_info(response)['ReceiverID'],
+                                  :payment_info_transactionid => payment_info(response)['TransactionID'],
+                                  :payment_info_parenttransactionid => payment_info(response)['ParentTransactionID'],
+                                  :payment_info_receiptid => payment_info(response)['ReceiptID'],
+                                  :payment_info_transactiontype => payment_info(response)['TransactionType'],
+                                  :payment_info_paymenttype => payment_info(response)['PaymentType'],
+                                  :payment_info_paymentdate => payment_info(response)['PaymentDate'],
+                                  :payment_info_grossamount => payment_info(response)['GrossAmount'],
+                                  :payment_info_feeamount => payment_info(response)['FeeAmount'],
+                                  :payment_info_taxamount => payment_info(response)['TaxAmount'],
+                                  :payment_info_exchangerate => payment_info(response)['ExchangeRate'],
+                                  :payment_info_paymentstatus => payment_info(response)['PaymentStatus'],
+                                  :payment_info_pendingreason => payment_info(response)['PendingReason'],
+                                  :payment_info_reasoncode => payment_info(response)['ReasonCode'],
+                                  :payment_info_protectioneligibility => payment_info(response)['ProtectionEligibility'],
+                                  :payment_info_protectioneligibilitytype => payment_info(response)['ProtectionEligibilityType'],
+                                  :payment_info_shipamount => payment_info(response)['ShipAmount'],
+                                  :payment_info_shiphandleamount => payment_info(response)['ShipHandleAmount'],
+                                  :payment_info_shipdiscount => payment_info(response)['ShipDiscount'],
+                                  :payment_info_insuranceamount => payment_info(response)['InsuranceAmount'],
+                                  :payment_info_subject => payment_info(response)['Subject'],
+                                  :avs_result_code => response.avs_result.kind_of?(ActiveMerchant::Billing::AVSResult) ? response.avs_result.code : response.avs_result['code'],
+                                  :avs_result_message => response.avs_result.kind_of?(ActiveMerchant::Billing::AVSResult) ? response.avs_result.message : response.avs_result['message'],
+                                  :avs_result_street_match => response.avs_result.kind_of?(ActiveMerchant::Billing::AVSResult) ? response.avs_result.street_match : response.avs_result['street_match'],
+                                  :avs_result_postal_match => response.avs_result.kind_of?(ActiveMerchant::Billing::AVSResult) ? response.avs_result.postal_match : response.avs_result['postal_match'],
+                                  :cvv_result_code => response.cvv_result.kind_of?(ActiveMerchant::Billing::CVVResult) ? response.cvv_result.code : response.cvv_result['code'],
+                                  :cvv_result_message => response.cvv_result.kind_of?(ActiveMerchant::Billing::CVVResult) ? response.cvv_result.message : response.cvv_result['message'],
+                                  :success => response.success?
+                                })
+    end
+
+    def to_express_checkout_url
+      url = Killbill::PaypalExpress.test ? Killbill::PaypalExpress.paypal_sandbox_url : Killbill::PaypalExpress.paypal_production_url
+      "#{url}?cmd=_express-checkout&token=#{token}"
+    end
+
+    def to_payment_response
+      to_killbill_response Killbill::Plugin::PaymentResponse
+    end
+
+    def to_refund_response
+      to_killbill_response Killbill::Plugin::RefundResponse
+    end
+
+    private
+
+    def to_killbill_response(klass)
+      if paypal_express_transaction.nil?
+        # payment_info_grossamount is e.g. "100.00" - we need to convert it in cents
+        amount_in_cents = payment_info_grossamount ? (payment_info_grossamount.to_f * 100).to_i : nil
+        created_date = created_at
+      else
+        amount_in_cents = paypal_express_transaction.amount_in_cents
+        created_date = paypal_express_transaction.created_at
+      end
+
+      effective_date = created_date
+      status = message
+      gateway_error = nil
+      gateway_error_code = nil
+
+      klass.new(amount_in_cents, created_date, effective_date, status, gateway_error, gateway_error_code)
+    end
+
+    # Paypal has various response formats depending on the API call and the ActiveMerchant Paypal plugin doesn't try to
+    # unify them, hence the gymnastic here
+
+    def self.receiver_info(response)
+      response.params['ReceiverInfo'] || (response.params['PaymentTransactionDetails'] || {})['ReceiverInfo'] || {}
+    end
+
+    def self.payment_info(response)
+      response.params['PaymentInfo'] || (response.params['PaymentTransactionDetails'] || {})['PaymentInfo'] || {}
+    end
+  end
+end

data/lib/paypal_express/models/paypal_express_transaction.rb

@@ -0,0 +1,16 @@
+module Killbill::PaypalExpress
+  class PaypalExpressTransaction < ActiveRecord::Base
+    belongs_to :paypal_express_response
+    attr_accessible :amount_in_cents,
+                    :api_call,
+                    :kb_payment_id,
+                    :paypal_express_txn_id
+
+    def self.from_kb_payment_id(kb_payment_id)
+      paypal_express_transactions = find_all_by_api_call_and_kb_payment_id(:charge, kb_payment_id)
+      raise "Unable to find Paypal Express transaction id for payment #{kb_payment_id}" if paypal_express_transactions.empty?
+      raise "Killbill payment mapping to multiple Paypal Express transactions for payment #{kb_payment_id}" if paypal_express_transactions.size > 1
+      paypal_express_transactions[0]
+    end
+  end
+end

data/lib/paypal_express/paypal/gateway.rb

@@ -0,0 +1,26 @@
+module Killbill::PaypalExpress
+  class Gateway
+    include Singleton
+
+    def configure(config)
+      if config[:test]
+        ActiveMerchant::Billing::Base.mode = :test
+      end
+
+      if config[:log_file]
+        ActiveMerchant::Billing::PaypalExpressGateway.wiredump_device = File.open(config[:log_file], 'w')
+        ActiveMerchant::Billing::PaypalExpressGateway.wiredump_device.sync = true
+      end
+
+      @gateway = ActiveMerchant::Billing::PaypalExpressGateway.new({
+                                                                     :signature => config[:signature],
+                                                                     :login => config[:login],
+                                                                     :password => config[:password]
+                                                                   })
+    end
+
+    def method_missing(m, *args, &block)
+      @gateway.send(m, *args, &block)
+    end
+  end
+end

data/lib/paypal_express/paypal_express_utils.rb

@@ -0,0 +1,17 @@
+require 'socket'
+
+module Killbill::PaypalExpress
+  class Utils
+    def self.ip
+      first_public_ipv4 ? first_public_ipv4.ip_address : first_private_ipv4.ip_address
+    end
+
+    def self.first_private_ipv4
+      @@first_private_ipv4 ||= Socket.ip_address_list.detect{ |intf| intf.ipv4_private? }
+    end
+
+    def self.first_public_ipv4
+      @@first_public_ipv4 ||= Socket.ip_address_list.detect{ |intf| intf.ipv4? and !intf.ipv4_loopback? and !intf.ipv4_multicast? and !intf.ipv4_private? }
+    end
+  end
+end

data/lib/paypal_express/private_api.rb

@@ -0,0 +1,53 @@
+module Killbill::PaypalExpress
+  class PrivatePaymentPlugin
+    include Singleton
+
+    # 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, amount_in_cents=0, currency='USD', 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"
+
+      # Go to Paypal (SetExpressCheckout call)
+      paypal_express_response = gateway.setup_authorization amount_in_cents, options
+      response = save_response paypal_express_response, :initiate_express_checkout
+
+      if response.success?
+        # Create the payment method (not associated to a Killbill payment method yet)
+        Killbill::PaypalExpress::PaypalExpressPaymentMethod.create :kb_account_id => kb_account_id,
+                                                                   :kb_payment_method_id => nil,
+                                                                   :paypal_express_payer_id => nil,
+                                                                   :paypal_express_token => response.token
+      end
+
+      response
+    end
+
+    private
+
+    def save_response(paypal_express_response, api_call)
+      logger.warn "Unsuccessful #{api_call}: #{paypal_express_response.message}" unless paypal_express_response.success?
+
+      # Save the response to our logs
+      response = PaypalExpressResponse.from_response(api_call, nil, paypal_express_response)
+      response.save!
+      response
+    end
+
+    def gateway
+      # The gateway should have been configured when the plugin started
+      Killbill::PaypalExpress::Gateway.instance
+    end
+
+    def logger
+      # The logger should have been configured when the plugin started
+      Killbill::PaypalExpress.logger
+    end
+  end
+end

data/lib/paypal_express.rb

@@ -0,0 +1,129 @@
+require 'active_record'
+require 'activemerchant'
+require 'pathname'
+require 'sinatra'
+require 'singleton'
+require 'yaml'
+
+require 'killbill'
+require 'killbill/response/payment_method_response'
+require 'killbill/response/payment_response'
+require 'killbill/response/refund_response'
+
+require 'paypal_express/config/configuration'
+require 'paypal_express/config/properties'
+
+require 'paypal_express/paypal/gateway'
+
+require 'paypal_express/models/paypal_express_payment_method'
+require 'paypal_express/models/paypal_express_response'
+require 'paypal_express/models/paypal_express_transaction'
+
+require 'paypal_express/paypal_express_utils'
+
+require 'paypal_express/api'
+require 'paypal_express/private_api'
+
+
+# Thank you Rails for the following!
+
+class Object
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+end
+
+class Hash
+  # By default, only instances of Hash itself are extractable.
+  # Subclasses of Hash may implement this method and return
+  # true to declare themselves as extractable. If a Hash
+  # is extractable, Array#extract_options! pops it from
+  # the Array when it is the last element of the Array.
+  def extractable_options?
+    instance_of?(Hash)
+  end
+end
+
+class Array
+  # Extracts options from a set of arguments. Removes and returns the last
+  # element in the array if it's a hash, otherwise returns a blank hash.
+  #
+  #   def options(*args)
+  #     args.extract_options!
+  #   end
+  #
+  #   options(1, 2)        # => {}
+  #   options(1, 2, a: :b) # => {:a=>:b}
+  def extract_options!
+    if last.is_a?(Hash) && last.extractable_options?
+      pop
+    else
+      {}
+    end
+  end
+end
+
+class Module
+  def mattr_reader(*syms)
+    options = syms.extract_options!
+    syms.each do |sym|
+      raise NameError.new('invalid attribute name') unless sym =~ /^[_A-Za-z]\w*$/
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        @@#{sym} = nil unless defined? @@#{sym}
+
+        def self.#{sym}
+          @@#{sym}
+        end
+      EOS
+
+      unless options[:instance_reader] == false || options[:instance_accessor] == false
+        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+          def #{sym}
+            @@#{sym}
+          end
+        EOS
+      end
+    end
+  end
+
+  def mattr_writer(*syms)
+    options = syms.extract_options!
+    syms.each do |sym|
+      raise NameError.new('invalid attribute name') unless sym =~ /^[_A-Za-z]\w*$/
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+      EOS
+
+      unless options[:instance_writer] == false || options[:instance_accessor] == false
+        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+          def #{sym}=(obj)
+            @@#{sym} = obj
+          end
+        EOS
+      end
+    end
+  end
+
+  # Extends the module object with module and instance accessors for class attributes,
+  # just like the native attr* accessors for instance attributes.
+  #
+  #   module AppConfiguration
+  #     mattr_accessor :google_api_key
+  #
+  #     self.google_api_key = "123456789"
+  #   end
+  #
+  #   AppConfiguration.google_api_key # => "123456789"
+  #   AppConfiguration.google_api_key = "overriding the api key!"
+  #   AppConfiguration.google_api_key # => "overriding the api key!"
+  #
+  # To opt out of the instance writer method, pass <tt>instance_writer: false</tt>.
+  # To opt out of the instance reader method, pass <tt>instance_reader: false</tt>.
+  # To opt out of both instance methods, pass <tt>instance_accessor: false</tt>.
+  def mattr_accessor(*syms)
+    mattr_reader(*syms)
+    mattr_writer(*syms)
+  end
+end

data/pom.xml

@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+~ Copyright 2010-2013 Ning, Inc.
+~
+~  Ning licenses this file to you under the Apache License, version 2.0
+~  (the "License"); you may not use this file except in compliance with the
+~  License.  You may obtain a copy of the License at:
+~
+~     http://www.apache.org/licenses/LICENSE-2.0
+~
+~  Unless required by applicable law or agreed to in writing, software
+~  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+~  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+~  License for the specific language governing permissions and limitations
+~  under the License.
+-->
+
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <groupId>org.sonatype.oss</groupId>
+        <artifactId>oss-parent</artifactId>
+        <version>5</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>com.ning.killbill.ruby</groupId>
+    <artifactId>paypal-express-plugin</artifactId>
+    <packaging>pom</packaging>
+    <version>1.0.0</version>
+    <name>paypal-express-plugin</name>
+    <scm>
+        <connection>scm:git:git://github.com/killbill/killbill-paypal-express-plugin.git</connection>
+        <url>https://github.com/killbill/killbill-paypal-express-plugin/</url>
+        <developerConnection>scm:git:git@github.com:killbill/killbill-paypal-express-plugin.git</developerConnection>
+    </scm>
+</project>

data/release.sh

@@ -0,0 +1,11 @@
+VERSION=`grep -E '<version>([0-9]+\.[0-9]+\.[0-9]+)</version>' pom.xml | sed 's/[\t \n]*<version>\(.*\)<\/version>[\t \n]*/\1/'`
+ARTIFACT="$PWD/pkg/killbill-paypal-express-$VERSION.tar.gz"
+echo "Pushing $ARTIFACT to Maven Central"
+mvn gpg:sign-and-deploy-file \
+    -DgroupId=com.ning.killbill.ruby \
+    -DartifactId=paypal-express-plugin \
+    -Dversion=$VERSION \
+    -Dpackaging=tar.gz \
+    -DrepositoryId=ossrh-releases \
+    -Durl=https://oss.sonatype.org/service/local/staging/deploy/maven2/ \
+    -Dfile=$ARTIFACT

data/spec/paypal_express/base_plugin_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'logger'
+
+describe Killbill::PaypalExpress::PaymentPlugin do
+  before(:each) do
+    Dir.mktmpdir do |dir|
+      file = File.new(File.join(dir, 'paypal_express.yml'), "w+")
+      file.write(<<-eos)
+:paypal:
+  :signature: 'signature'
+  :login: 'login'
+  :password: 'password'
+:database:
+  :adapter: 'sqlite3'
+  :database: 'shouldntmatter.db'
+eos
+      file.close
+
+      @plugin = Killbill::PaypalExpress::PaymentPlugin.new
+      @plugin.root = File.dirname(file)
+      @plugin.logger = Logger.new(STDOUT)
+
+      # Start the plugin here - since the config file will be deleted
+      @plugin.start_plugin
+    end
+  end
+
+  it "should start and stop correctly" do
+    @plugin.stop_plugin
+  end
+end

data/spec/paypal_express/remote/integration_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+require 'logger'
+
+ActiveMerchant::Billing::Base.mode = :test
+
+describe Killbill::PaypalExpress::PaymentPlugin do
+  before(:each) do
+    @plugin = Killbill::PaypalExpress::PaymentPlugin.new
+    @plugin.root = File.expand_path(File.dirname(__FILE__) + '../../../../')
+
+    logger = Logger.new(STDOUT)
+    logger.level = Logger::DEBUG
+    @plugin.logger = logger
+
+    @plugin.start_plugin
+
+    @pm = create_payment_method
+  end
+
+  after(:each) do
+    @plugin.stop_plugin
+  end
+
+  it "should be able to charge and refund" do
+    amount_in_cents = 10000
+    currency = 'USD'
+    kb_payment_id = SecureRandom.uuid
+
+    payment_response = @plugin.process_payment @pm.kb_account_id, kb_payment_id, @pm.kb_payment_method_id, amount_in_cents, currency
+    payment_response.amount_in_cents.should == amount_in_cents
+    payment_response.status.should == "Success"
+
+    # Verify our table directly
+    response = Killbill::PaypalExpress::PaypalExpressResponse.find_by_api_call_and_kb_payment_id :charge, kb_payment_id
+    response.test.should be_true
+    response.success.should be_true
+    response.message.should == "Success"
+
+    # Check we can retrieve the payment
+    payment_response = @plugin.get_payment_info @pm.kb_account_id, kb_payment_id
+    payment_response.amount_in_cents.should == amount_in_cents
+    payment_response.status.should == "Success"
+
+    # Check we cannot refund an amount greater than the original charge
+    lambda { @plugin.process_refund @pm.kb_account_id, kb_payment_id, amount_in_cents + 1, currency }.should raise_error RuntimeError
+
+    refund_response = @plugin.process_refund @pm.kb_account_id, kb_payment_id, amount_in_cents, currency
+    refund_response.amount_in_cents.should == amount_in_cents
+    refund_response.status.should == "Success"
+
+    # Verify our table directly
+    response = Killbill::PaypalExpress::PaypalExpressResponse.find_by_api_call_and_kb_payment_id :refund, kb_payment_id
+    response.test.should be_true
+    response.success.should be_true
+
+    # Try another payment to verify the BAID
+    second_amount_in_cents = 9423
+    second_kb_payment_id = SecureRandom.uuid
+    payment_response = @plugin.process_payment @pm.kb_account_id, second_kb_payment_id, @pm.kb_payment_method_id, second_amount_in_cents, currency
+    payment_response.amount_in_cents.should == second_amount_in_cents
+    payment_response.status.should == "Success"
+
+    # Check we can refund it as well
+    refund_response = @plugin.process_refund @pm.kb_account_id, second_kb_payment_id, second_amount_in_cents, currency
+    refund_response.amount_in_cents.should == second_amount_in_cents
+    refund_response.status.should == "Success"
+
+    # it "should be able to create and retrieve payment methods"
+    # This should be in a separate scenario but since it's so hard to create a payment method (need manual intervention),
+    # we can't easily delete it
+    pms = @plugin.get_payment_methods @pm.kb_account_id
+    pms.size.should == 1
+    pms[0].external_payment_method_id.should == @pm.paypal_express_baid
+
+    pm_details = @plugin.get_payment_method_detail(@pm.kb_account_id, @pm.kb_payment_method_id)
+    pm_details.external_payment_method_id.should == @pm.paypal_express_baid
+
+    @plugin.delete_payment_method @pm.kb_account_id, @pm.kb_payment_method_id
+
+    @plugin.get_payment_methods(@pm.kb_account_id).size.should == 0
+    lambda { @plugin.get_payment_method_detail(@pm.kb_account_id, @pm.kb_payment_method_id) }.should raise_error RuntimeError
+  end
+
+  private
+
+  def create_payment_method
+    kb_account_id = SecureRandom.uuid
+    private_plugin = Killbill::PaypalExpress::PrivatePaymentPlugin.instance
+
+    # Initiate the setup process
+    response = private_plugin.initiate_express_checkout kb_account_id
+    response.success.should be_true
+    token = response.token
+
+    print "\nPlease go to #{response.to_express_checkout_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
+
+    # Complete the setup process
+    kb_payment_method_id = SecureRandom.uuid
+    info = Killbill::Plugin::PaymentMethodResponse.new nil, nil, [Killbill::Plugin::PaymentMethodProperty.new("token", token, false)]
+    response = @plugin.add_payment_method kb_account_id, kb_payment_method_id, info
+    response.should be_true
+
+    # Verify our table directly
+    payment_method = Killbill::PaypalExpress::PaypalExpressPaymentMethod.from_kb_account_id_and_token(kb_account_id, token)
+    payment_method.should_not be_nil
+    payment_method.paypal_express_payer_id.should_not be_nil
+    payment_method.paypal_express_baid.should_not be_nil
+    payment_method.kb_payment_method_id.should == kb_payment_method_id
+
+    payment_method
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,33 @@
+require 'bundler'
+require 'paypal_express'
+
+require 'rspec'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.tty = true
+  config.formatter = 'documentation'
+end
+
+require 'active_record'
+ActiveRecord::Base.establish_connection(
+  :adapter => 'sqlite3',
+  :database => 'test.db'
+)
+# Create the schema
+require File.expand_path(File.dirname(__FILE__) + '../../db/schema.rb')
+
+begin
+  require 'securerandom'
+  SecureRandom.uuid
+rescue LoadError, NoMethodError
+  # See http://jira.codehaus.org/browse/JRUBY-6176
+  module SecureRandom
+    def self.uuid
+      ary = self.random_bytes(16).unpack("NnnnnN")
+      ary[2] = (ary[2] & 0x0fff) | 0x4000
+      ary[3] = (ary[3] & 0x3fff) | 0x8000
+      "%08x-%04x-%04x-%04x-%04x%08x" % ary
+    end unless respond_to?(:uuid)
+  end
+end