killbill 3.1.11 → 3.1.12

data/lib/killbill/helpers/active_merchant/private_payment_plugin.rb

@@ -3,8 +3,10 @@ module Killbill
     module ActiveMerchant
       require 'action_controller'
       require 'action_view'
+      require 'active_merchant'
       require 'active_support'
       require 'cgi'
+      require 'offsite_payments'
 
       class PrivatePaymentPlugin < ::Killbill::Plugin::Payment
 
@@ -13,7 +15,7 @@ module Killbill
         include ::ActionController::RequestForgeryProtection
         include ::ActionView::Context
         include ::ActionView::Helpers::FormTagHelper
-        include ::ActiveMerchant::Billing::Integrations::ActionViewHelper
+        include ::OffsitePayments::ActionViewHelper
 
         # For RequestForgeryProtection
         attr_reader :session
@@ -33,7 +35,7 @@ module Killbill
         #
         # Additionally, you can have a :html key which will be passed through to the link_to helper
         def payment_link_for(name, order_id, account_id, service, options = {})
-          integration_module = ::ActiveMerchant::Billing::Integrations.const_get(service.to_s.camelize)
+          integration_module = ::OffsitePayments.integration(service.to_s.camelize)
           service_class      = integration_module.const_get('Helper')
 
           link_options = options.delete(:html) || {}
@@ -69,36 +71,13 @@ module Killbill
           output_buffer
         end
 
-        protected
+        def save_response_and_transaction(gw_response, api_call, kb_account_id, kb_tenant_id, payment_processor_account_id, kb_payment_id=nil, kb_payment_transaction_id=nil, transaction_type=nil, amount_in_cents=0, currency=nil)
+          logger.warn "Unsuccessful #{api_call}: #{gw_response.message}" unless gw_response.success?
 
-        def reset_output_buffer
-          @output_buffer = ''
-        end
+          response, transaction = @response_model.create_response_and_transaction(@identifier, @transaction_model, api_call, kb_account_id, kb_payment_id, kb_payment_transaction_id, transaction_type, payment_processor_account_id, kb_tenant_id, gw_response, amount_in_cents, currency, {}, @response_model)
 
-        def save_response(response, api_call)
-          save_response_and_transaction(response, api_call)[0]
-        end
+          logger.debug "Recorded transaction: #{transaction.inspect}" unless transaction.nil?
 
-        def save_response_and_transaction(response, api_call, kb_payment_id=nil, amount_in_cents=0, currency=nil)
-          logger.warn "Unsuccessful #{api_call}: #{response.message}" unless response.success?
-
-          # Save the response to our logs
-          response = @response_model.from_response(api_call, kb_payment_id, response)
-          response.save!
-
-          transaction = nil
-          txn_id      = response.txn_id
-          if response.success and !kb_payment_id.blank? and !txn_id.blank?
-            # Record the transaction
-            transaction = response.send("create_#{@identifier}_transaction!",
-                                        :amount_in_cents => amount_in_cents,
-                                        :currency        => currency,
-                                        :api_call        => api_call,
-                                        :kb_payment_id   => kb_payment_id,
-                                        :txn_id          => txn_id)
-
-            logger.debug "Recorded transaction: #{transaction.inspect}"
-          end
           return response, transaction
         end
 
@@ -106,13 +85,21 @@ module Killbill
           ::Killbill::Plugin::ActiveMerchant.kb_apis
         end
 
-        def gateway
-          ::Killbill::Plugin::ActiveMerchant.gateway
+        def gateway(payment_processor_account_id=:default)
+          gateway = ::Killbill::Plugin::ActiveMerchant.gateways[payment_processor_account_id.to_sym]
+          raise "Unable to lookup gateway for payment_processor_account_id #{payment_processor_account_id}, gateways: #{::Killbill::Plugin::ActiveMerchant.gateways}" if gateway.nil?
+          gateway
         end
 
         def logger
           ::Killbill::Plugin::ActiveMerchant.logger
         end
+
+        protected
+
+        def reset_output_buffer
+          @output_buffer = ''
+        end
       end
     end
   end

data/lib/killbill/helpers/active_merchant/sinatra.rb

@@ -22,9 +22,14 @@ module Killbill
 
         after do
           # return DB connections to the Pool if required
-          ::ActiveRecord::Base.connection.close
+          pool = ::ActiveRecord::Base.connection_pool
+          if pool.active_connection?
+            connection = ::ActiveRecord::Base.connection
+            pool.remove(connection)
+            connection.disconnect!
+          end
         end
       end
     end
   end
-end
+end

data/lib/killbill/helpers/active_merchant/utils.rb

@@ -17,6 +17,18 @@ module Killbill
           no_hyphens.insert(8, "-").insert(13, "-").insert(18, "-").insert(23, "-")
         end
 
+        def self.ip
+          first_public_ipv4 ? first_public_ipv4.ip_address : first_private_ipv4.ip_address
+        end
+
+        def self.first_private_ipv4
+          Socket.ip_address_list.detect { |intf| intf.ipv4_private? }
+        end
+
+        def self.first_public_ipv4
+          Socket.ip_address_list.detect { |intf| intf.ipv4? and !intf.ipv4_loopback? and !intf.ipv4_multicast? and !intf.ipv4_private? }
+        end
+
         class KBWiredumpDevice < IO
 
           # Required for compatibility, but unused

data/spec/killbill/helpers/killbill_spec_helper_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Killbill::Plugin::ActiveMerchant::RSpec do
+  include Killbill::Plugin::ActiveMerchant::RSpec
+
+  it 'should build payment method properties' do
+    overridden_city = SecureRandom.uuid
+
+    props1 = build_pm_properties
+    props2 = build_pm_properties(nil, {:city => overridden_city})
+    props3 = build_pm_properties(nil, {:city => overridden_city, :foo => :bar})
+
+    props1.size.should == props2.size
+    props3.size.should == props1.size + 1
+
+    city1 = props1.find { |p| p.key == 'city' }
+    city2 = props2.find { |p| p.key == 'city' }
+    city3 = props3.find { |p| p.key == 'city' }
+    city1.value.should_not == city2.value
+    city2.value.should == city3.value
+
+    (props3.find { |p| p.key == :foo }).value.should == :bar
+  end
+end

data/spec/killbill/helpers/payment_method_spec.rb

@@ -149,6 +149,11 @@ describe Killbill::Plugin::ActiveMerchant::ActiveRecord::PaymentMethod do
     expect { ::Killbill::Test::TestPaymentMethod.from_kb_payment_method_id(SecureRandom.uuid, kb_tenant_id) }.to raise_error
     ::Killbill::Test::TestPaymentMethod.from_kb_payment_method_id(kb_payment_method_id, kb_tenant_id).kb_payment_method_id.should == kb_payment_method_id
 
+    # Retrieve by account id and token
+    pms = ::Killbill::Test::TestPaymentMethod.from_kb_account_id_and_token(token, kb_account_id, kb_tenant_id)
+    pms.size.should == 1
+    pms[0].kb_payment_method_id.should == kb_payment_method_id
+
     # Delete the payment method and verify we cannot find it anymore
     ::Killbill::Test::TestPaymentMethod.mark_as_deleted!(kb_payment_method_id, kb_tenant_id)
     ::Killbill::Test::TestPaymentMethod.from_kb_account_id(kb_account_id, kb_tenant_id).size.should == 0

data/spec/killbill/helpers/payment_plugin_spec.rb

@@ -10,7 +10,10 @@ describe Killbill::Plugin::ActiveMerchant::PaymentPlugin do
       file = File.new(File.join(dir, 'test.yml'), "w+")
       file.write(<<-eos)
 :test:
-  :test: true
+  - :account_id: default
+    :test: true
+  - :account_id: something_non_standard
+    :test: true
 # As defined by spec_helper.rb
 :database:
   :adapter: 'sqlite3'
@@ -49,6 +52,12 @@ describe Killbill::Plugin::ActiveMerchant::PaymentPlugin do
     property.value = 'true'
     @properties    = [property]
 
+    @ppai                 = ::Killbill::Plugin::Model::PluginProperty.new
+    @ppai.key             = 'payment_processor_account_id'
+    @ppai.value           = 'something_non_standard'
+    @properties_with_ppai = @properties.dup
+    @properties_with_ppai << @ppai
+
     token                            = ::Killbill::Plugin::Model::PluginProperty.new
     token.key                        = 'token'
     token.value                      = SecureRandom.uuid
@@ -101,9 +110,28 @@ describe Killbill::Plugin::ActiveMerchant::PaymentPlugin do
     @plugin.get_payment_methods(@kb_account_id, true, @properties, @call_context).size.should == 0
   end
 
+  it 'should support different payment_processor_account_ids' do
+    @plugin.get_payment_methods(@kb_account_id, true, @properties, @call_context).size.should == 0
+
+    @plugin.add_payment_method(@kb_account_id, @kb_payment_method_id, @payment_method_props, true, @properties, @call_context)
+    @plugin.get_payment_methods(@kb_account_id, true, @properties, @call_context).size.should == 1
+    ::Killbill::Test::TestPaymentMethod.where(:kb_payment_method_id => @kb_payment_method_id).first.token.should == @payment_method_props.properties[0].value
+
+    authorization_id = SecureRandom.uuid
+    @payment_api.add_payment(@kb_payment_id, authorization_id, SecureRandom.uuid, :AUTHORIZE)
+    authorization = @plugin.authorize_payment(@kb_account_id, @kb_payment_id, authorization_id, @kb_payment_method_id, @amount_in_cents, @currency, @properties_with_ppai, @call_context)
+    verify_transaction_info_plugin(authorization, authorization_id, :AUTHORIZE, 1, @ppai.value)
+
+    capture_id = SecureRandom.uuid
+    @payment_api.add_payment(@kb_payment_id, capture_id, SecureRandom.uuid, :CAPTURE)
+    # We omit the payment_processor_account_id to verify we can retrieve it
+    capture = @plugin.capture_payment(@kb_account_id, @kb_payment_id, capture_id, @kb_payment_method_id, @amount_in_cents, @currency, @properties, @call_context)
+    verify_transaction_info_plugin(capture, capture_id, :CAPTURE, 2, @ppai.value)
+  end
+
   private
 
-  def verify_transaction_info_plugin(t_info_plugin, kb_transaction_id, type, transaction_nb)
+  def verify_transaction_info_plugin(t_info_plugin, kb_transaction_id, type, transaction_nb, payment_processor_account_id='default')
     t_info_plugin.kb_payment_id.should == @kb_payment_id
     t_info_plugin.kb_transaction_payment_id.should == kb_transaction_id
     t_info_plugin.transaction_type.should == type
@@ -116,6 +144,9 @@ describe Killbill::Plugin::ActiveMerchant::PaymentPlugin do
     end
     t_info_plugin.status.should == :PROCESSED
 
+    # Verify we routed to the right gateway
+    (t_info_plugin.properties.find { |kv| kv.key.to_s == 'payment_processor_account_id' }).value.to_s.should == payment_processor_account_id
+
     transactions = @plugin.get_payment_info(@kb_account_id, @kb_payment_id, [], @call_context)
     transactions.size.should == transaction_nb
     transactions[transaction_nb - 1].to_json.should == t_info_plugin.to_json

data/spec/killbill/helpers/private_payment_plugin_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+require 'spec/killbill/helpers/payment_method_spec'
+require 'spec/killbill/helpers/response_spec'
+require 'spec/killbill/helpers/transaction_spec'
+
+describe Killbill::Plugin::ActiveMerchant::PrivatePaymentPlugin do
+
+  before(:each) do
+    @order_id   = SecureRandom.uuid
+    @account_id = SecureRandom.uuid
+    @options    = {:amount => 120, :country => 'US', :forward_url => 'http://kill-bill.org', :html => {:authenticity_token => false}}
+    @session    = {:foo => :bar}
+
+    setup_public_plugin
+
+    @plugin = Killbill::Plugin::ActiveMerchant::PrivatePaymentPlugin.new(:test,
+                                                                         ::Killbill::Test::TestPaymentMethod,
+                                                                         ::Killbill::Test::TestTransaction,
+                                                                         ::Killbill::Test::TestResponse,
+                                                                         @session)
+    @plugin.session.should == @session
+  end
+
+  it 'should build payment links' do
+    link = @plugin.payment_link_for('Pay!', @order_id, @account_id, :bogus, @options)
+    link.should == "<a account=\"#{@account_id}\" amount=\"#{@options[:amount]}\" authenticity_token=\"false\" href=\"http://www.bogus.com?order=#{@order_id}&amp;account=#{@account_id}&amp;amount=#{@options[:amount]}\">Pay!</a>"
+  end
+
+  it 'should build payment forms' do
+    form = @plugin.payment_form_for(@order_id, @account_id, :bogus, @options) do |service|
+      service.token = 'Pay!'
+    end
+    form.should == "<form accept-charset=\"UTF-8\" action=\"http://www.bogus.com\" disable_authenticity_token=\"true\" method=\"post\"><div style=\"display:none\"></div>
+Pay!
+<input id=\"order\" name=\"order\" type=\"hidden\" value=\"#{@order_id}\" />
+<input id=\"account\" name=\"account\" type=\"hidden\" value=\"#{@account_id}\" />
+<input id=\"amount\" name=\"amount\" type=\"hidden\" value=\"#{@options[:amount]}\" />
+</form>"
+  end
+
+  it 'should save responses and transactions' do
+    response, transaction = @plugin.save_response_and_transaction(::ActiveMerchant::Billing::Response.new(true, 'OK'), :custom_thinggy, @account_id, SecureRandom.uuid, :default, SecureRandom.uuid, SecureRandom.uuid, :op, 1242, 'USD')
+
+    response.api_call.should == :custom_thinggy
+    transaction.transaction_type.should == :op
+  end
+
+  it 'should access global variables' do
+    @plugin.kb_apis.is_a?(::Killbill::Plugin::KillbillApi).should be_true
+    @plugin.gateway.is_a?(::Killbill::Plugin::ActiveMerchant::Gateway).should be_true
+    @plugin.logger.respond_to?(:info).should be_true
+  end
+
+  private
+
+  def setup_public_plugin
+    Dir.mktmpdir do |dir|
+      file = File.new(File.join(dir, 'test.yml'), 'w+')
+      file.write(<<-eos)
+:test:
+  :test: true
+# As defined by spec_helper.rb
+:database:
+  :adapter: 'sqlite3'
+  :database: 'test.db'
+      eos
+      file.close
+
+      plugin          = ::Killbill::Plugin::ActiveMerchant::PaymentPlugin.new(Proc.new { |config| nil },
+                                                                              :test,
+                                                                              ::Killbill::Test::TestPaymentMethod,
+                                                                              ::Killbill::Test::TestTransaction,
+                                                                              ::Killbill::Test::TestResponse)
+      payment_api     = ::Killbill::Plugin::ActiveMerchant::RSpec::FakeJavaPaymentApi.new
+      plugin.kb_apis  = ::Killbill::Plugin::KillbillApi.new('test', {:payment_api => payment_api})
+      plugin.logger   = Logger.new(STDOUT)
+      plugin.conf_dir = File.dirname(file)
+
+      # Start the plugin here - since the config file will be deleted
+      plugin.start_plugin
+    end
+  end
+end

data/spec/killbill/helpers/response_spec.rb

@@ -20,24 +20,26 @@ describe Killbill::Plugin::ActiveMerchant::ActiveRecord::Response do
   end
 
   it 'should construct responses correctly' do
-    api_call                  = 'for debugging only'
-    kb_account_id             = SecureRandom.uuid
-    kb_payment_id             = SecureRandom.uuid
-    kb_payment_transaction_id = SecureRandom.uuid
-    transaction_type          = :PURCHASE
-    kb_tenant_id              = SecureRandom.uuid
-    response                  = ::ActiveMerchant::Billing::Response.new(true, 'Message', {}, {
+    api_call                     = 'for debugging only'
+    kb_account_id                = SecureRandom.uuid
+    kb_payment_id                = SecureRandom.uuid
+    kb_payment_transaction_id    = SecureRandom.uuid
+    transaction_type             = :PURCHASE
+    payment_processor_account_id = 'petit_poucet'
+    kb_tenant_id                 = SecureRandom.uuid
+    response                     = ::ActiveMerchant::Billing::Response.new(true, 'Message', {}, {
         :authorization => SecureRandom.uuid,
         :avs_result    => ::ActiveMerchant::Billing::AVSResult.new(:code => 'P')
     })
 
-    r = ::Killbill::Test::TestResponse.from_response(api_call, kb_account_id, kb_payment_id, kb_payment_transaction_id, transaction_type, kb_tenant_id, response, {}, ::Killbill::Test::TestResponse)
+    r = ::Killbill::Test::TestResponse.from_response(api_call, kb_account_id, kb_payment_id, kb_payment_transaction_id, transaction_type, payment_processor_account_id, kb_tenant_id, response, {}, ::Killbill::Test::TestResponse)
     r.api_call.should == api_call
-    r.kb_account_id.should ==kb_account_id
-    r.kb_payment_id.should ==kb_payment_id
-    r.kb_payment_transaction_id.should ==kb_payment_transaction_id
-    r.transaction_type.should ==transaction_type
-    r.kb_tenant_id.should ==kb_tenant_id
+    r.kb_account_id.should == kb_account_id
+    r.kb_payment_id.should == kb_payment_id
+    r.kb_payment_transaction_id.should == kb_payment_transaction_id
+    r.transaction_type.should == transaction_type
+    r.payment_processor_account_id.should == payment_processor_account_id
+    r.kb_tenant_id.should == kb_tenant_id
     r.message.should == response.message
     r.authorization.should == response.authorization
     r.fraud_review.should == response.fraud_review?
@@ -63,26 +65,27 @@ describe Killbill::Plugin::ActiveMerchant::ActiveRecord::Response do
     ptip.gateway_error_code.should be_nil
     ptip.first_payment_reference_id.should be_nil
     ptip.second_payment_reference_id.should be_nil
-    ptip.properties.size.should == 11
+    ptip.properties.size.should == 12
   end
 
   it 'should create responses and transactions correctly' do
-    api_call                  = 'for debugging only'
-    kb_account_id             = SecureRandom.uuid
-    kb_payment_id             = SecureRandom.uuid
-    kb_payment_transaction_id = SecureRandom.uuid
-    transaction_type          = :PURCHASE
-    kb_tenant_id              = SecureRandom.uuid
-    success_response          = ::ActiveMerchant::Billing::Response.new(true, 'Message', {}, {
+    api_call                     = 'for debugging only'
+    kb_account_id                = SecureRandom.uuid
+    kb_payment_id                = SecureRandom.uuid
+    kb_payment_transaction_id    = SecureRandom.uuid
+    transaction_type             = :PURCHASE
+    payment_processor_account_id = 'petit_poucet'
+    kb_tenant_id                 = SecureRandom.uuid
+    success_response             = ::ActiveMerchant::Billing::Response.new(true, 'Message', {}, {
         :authorization => SecureRandom.uuid,
         :avs_result    => ::ActiveMerchant::Billing::AVSResult.new(:code => 'P')
     })
-    failure_response          = ::ActiveMerchant::Billing::Response.new(false, 'Message', {}, {
+    failure_response             = ::ActiveMerchant::Billing::Response.new(false, 'Message', {}, {
         :authorization => SecureRandom.uuid,
         :avs_result    => ::ActiveMerchant::Billing::AVSResult.new(:code => 'P')
     })
 
-    response, transaction = ::Killbill::Test::TestResponse.create_response_and_transaction('test', ::Killbill::Test::TestTransaction, api_call, kb_account_id, kb_payment_id, kb_payment_transaction_id, transaction_type, kb_tenant_id, success_response, 120, 'USD', {}, ::Killbill::Test::TestResponse)
+    response, transaction = ::Killbill::Test::TestResponse.create_response_and_transaction('test', ::Killbill::Test::TestTransaction, api_call, kb_account_id, kb_payment_id, kb_payment_transaction_id, transaction_type, payment_processor_account_id, kb_tenant_id, success_response, 120, 'USD', {}, ::Killbill::Test::TestResponse)
     found_response        = ::Killbill::Test::TestResponse.find(response.id)
     found_response.should == response
     found_response.test_transaction.should == transaction
@@ -90,11 +93,31 @@ describe Killbill::Plugin::ActiveMerchant::ActiveRecord::Response do
     found_transaction.should == transaction
     found_transaction.test_response.should == response
 
-    response, transaction = ::Killbill::Test::TestResponse.create_response_and_transaction('test', ::Killbill::Test::TestTransaction, api_call, kb_account_id, kb_payment_id, kb_payment_transaction_id, transaction_type, kb_tenant_id, failure_response, 120, 'USD', {}, ::Killbill::Test::TestResponse)
+    response, transaction = ::Killbill::Test::TestResponse.create_response_and_transaction('test', ::Killbill::Test::TestTransaction, api_call, kb_account_id, kb_payment_id, kb_payment_transaction_id, transaction_type, payment_processor_account_id, kb_tenant_id, failure_response, 120, 'USD', {}, ::Killbill::Test::TestResponse)
     transaction.should be_nil
     found_response = ::Killbill::Test::TestResponse.find(response.id)
     found_response.should == response
     found_response.test_transaction.should be_nil
+
+    # Lookup responses for kb_payment_id
+    responses = ::Killbill::Test::TestResponse.responses_from_kb_payment_id(transaction_type, kb_payment_id, kb_tenant_id)
+    responses.size.should == 2
+    responses[0].success.should be_true
+    responses[1].success.should be_false
+
+    # Lookup responses for kb_payment_transaction_id
+    responses = ::Killbill::Test::TestResponse.responses_from_kb_payment_transaction_id(transaction_type, kb_payment_transaction_id, kb_tenant_id)
+    responses.size.should == 2
+    responses[0].success.should be_true
+    responses[1].success.should be_false
+
+    # Dummy queries
+    ::Killbill::Test::TestResponse.responses_from_kb_payment_id(:foo, kb_payment_id, kb_tenant_id).size.should == 0
+    ::Killbill::Test::TestResponse.responses_from_kb_payment_id(transaction_type, SecureRandom.uuid, kb_tenant_id).size.should == 0
+    ::Killbill::Test::TestResponse.responses_from_kb_payment_id(transaction_type, kb_payment_id, SecureRandom.uuid).size.should == 0
+    ::Killbill::Test::TestResponse.responses_from_kb_payment_transaction_id(:foo, kb_payment_transaction_id, kb_tenant_id).size.should == 0
+    ::Killbill::Test::TestResponse.responses_from_kb_payment_transaction_id(transaction_type, SecureRandom.uuid, kb_tenant_id).size.should == 0
+    ::Killbill::Test::TestResponse.responses_from_kb_payment_transaction_id(transaction_type, kb_payment_transaction_id, SecureRandom.uuid).size.should == 0
   end
 
   it 'should generate the right SQL query' do

data/spec/killbill/helpers/streamy_result_set_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'spec/killbill/helpers/payment_method_spec'
+
+describe Killbill::Plugin::ActiveMerchant::ActiveRecord do
+
+  before(:all) do
+    ::Killbill::Test::TestPaymentMethod.delete_all
+  end
+
+  it 'should stream results per batch' do
+    1.upto(35) do
+      ::Killbill::Test::TestPaymentMethod.create(:kb_account_id        => SecureRandom.uuid,
+                                                 :kb_payment_method_id => SecureRandom.uuid,
+                                                 :kb_tenant_id         => SecureRandom.uuid,
+                                                 :token                => SecureRandom.uuid)
+    end
+    ::Killbill::Test::TestPaymentMethod.count.should == 35
+
+    enum = ::Killbill::Plugin::ActiveMerchant::ActiveRecord::StreamyResultSet.new(40, 10) do |offset, limit|
+      ::Killbill::Test::TestPaymentMethod.where('kb_payment_method_id is not NULL')
+                                         .order('id ASC')
+                                         .offset(offset)
+                                         .limit(limit)
+    end
+
+    i = 0
+    enum.each do |results|
+      if i < 3
+        results.size.should == 10
+      elsif i == 3
+        results.size.should == 5
+      else
+        fail 'Too many results'
+      end
+      i += 1
+    end
+  end
+end