killbill 3.1.8 → 3.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1564801f1c0cf35922d6784c77c6bad9a0e16cb0
-  data.tar.gz: f3f0d953fb91af7b5bf848ed44bad0d12f485c0b
+  metadata.gz: fecf6eec986317ba4b930aea485670c18fbc88b2
+  data.tar.gz: 642dbcbe75183170bfe68b07925653bf51855a29
 SHA512:
-  metadata.gz: 287c4cbadcce9715807704728cc7a718e521bf4ec2ef807749c81a036b381a8ed680ccb21aa4d6c280cb93dfd4be369426534ff11bd35b87a2bd71060435adb3
-  data.tar.gz: 22c5ca459cf77f5e096f76688c5fb0283076255a641ef2259be3c52e71dc8d7bdca31a6f8ea6ca11a7e25bd310460091cbd2d002ab4a3ba9e51080b72fc4de35
+  metadata.gz: 900a0cb3ce17d6060cac359fe685fe42b593a492fa97b4f1a9c418255524c18415a67641c09092716a82827c17d3c905eedab1036f76f23c57a761967adda8be
+  data.tar.gz: f03f0c261d3390cae2246a9a31464a0cc10ee5093ca414d8381eb8d1a300d4706df5aed100de725f3496a24c6871f39dcd2d774765c5c35b288cf8b5490fa700

data/Jarfile

@@ -1,8 +1,8 @@
-jar 'org.kill-bill.billing:killbill-api', '0.9.8'
+jar 'org.kill-bill.billing:killbill-api', '0.9.9'
 jar 'org.kill-bill.billing.plugin:killbill-plugin-api-notification', '0.7.4'
 jar 'org.kill-bill.billing.plugin:killbill-plugin-api-payment', '0.7.4'
 jar 'org.kill-bill.billing.plugin:killbill-plugin-api-currency', '0.7.4'
 jar 'org.kill-bill.billing.plugin:killbill-plugin-api-retry', '0.7.4'
 jar 'org.kill-bill.billing.plugin:killbill-plugin-api-invoice', '0.7.4'
-jar 'org.kill-bill.billing:killbill-util:tests', '0.11.3'
+jar 'org.kill-bill.billing:killbill-util:tests', '0.11.9'
 jar 'javax.servlet:javax.servlet-api', '3.0.1'

data/NEWS

@@ -1,3 +1,7 @@
+3.1.9
+    Fix memory leak in database connection handling
+    Change void implementation to be more generic (and work with Cybersource)
+
 3.1.8
     Make ActiveMerchant HTTP backend configurable, add support for Typhoeus
     generator:

data/VERSION

@@ -1 +1 @@
-3.1.8
+3.1.9

data/generators/active_merchant/templates/config.yml.rb

@@ -16,3 +16,4 @@
 #  :jndi: 'killbill/osgi/jdbc'
 #  :driver: 'com.mysql.jdbc.Driver'
 #  :connection_alive_sql: 'select 1'
+#  :pool: 250

data/lib/killbill/helpers/active_merchant/active_record/models/payment_method.rb

@@ -4,6 +4,7 @@ module Killbill
       module ActiveRecord
         require 'active_record'
         require 'active_merchant'
+        require 'time'
         require 'killbill/helpers/active_merchant/active_record/models/helpers'
 
         class PaymentMethod < ::ActiveRecord::Base
@@ -15,6 +16,8 @@ module Killbill
           @@quotes_cache = build_quotes_cache
 
           def self.from_response(kb_account_id, kb_payment_method_id, kb_tenant_id, cc_or_token, response, options, extra_params = {}, model = PaymentMethod)
+            # See Response#from_response
+            current_time = Time.now.utc
             model.new({
                           :kb_account_id        => kb_account_id,
                           :kb_payment_method_id => kb_payment_method_id,
@@ -31,7 +34,9 @@ module Killbill
                           :city                 => (options[:billing_address] || {})[:city],
                           :state                => (options[:billing_address] || {})[:state],
                           :zip                  => (options[:billing_address] || {})[:zip],
-                          :country              => (options[:billing_address] || {})[:country]
+                          :country              => (options[:billing_address] || {})[:country],
+                          :created_at           => current_time,
+                          :updated_at           => current_time
                       }.merge!(extra_params))
           end
 

data/lib/killbill/helpers/active_merchant/active_record/models/response.rb

@@ -5,6 +5,7 @@ module Killbill
         require 'active_record'
         require 'active_merchant'
         require 'money'
+        require 'time'
         require 'killbill/helpers/active_merchant/active_record/models/helpers'
 
         class Response < ::ActiveRecord::Base
@@ -14,6 +15,8 @@ module Killbill
           self.abstract_class = true
 
           def self.from_response(api_call, kb_account_id, kb_payment_id, kb_payment_transaction_id, transaction_type, kb_tenant_id, response, extra_params = {}, model = Response)
+            # Under high load, Rails sometimes fails to set timestamps. Unclear why...
+            current_time = Time.now.utc
             model.new({
                           :api_call                  => api_call,
                           :kb_account_id             => kb_account_id,
@@ -31,7 +34,9 @@ module Killbill
                           :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?
+                          :success                   => response.success?,
+                          :created_at                => current_time,
+                          :updated_at                => current_time
                       }.merge!(extra_params))
           end
 
@@ -62,7 +67,10 @@ module Killbill
                                                       :kb_payment_transaction_id  => kb_payment_transaction_id,
                                                       :transaction_type           => transaction_type,
                                                       :txn_id                     => txn_id,
-                                                      "#{identifier}_response_id" => response.id)
+                                                      "#{identifier}_response_id" => response.id,
+                                                      # See Response#from_response
+                                                      :created_at                 => response.created_at,
+                                                      :updated_at                 => response.updated_at)
                   transaction.save!(shared_activerecord_options)
                 rescue => e
                   exception = e

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

@@ -38,6 +38,10 @@ module Killbill
 
           @gateway.send(m, *args, &block)
         end
+
+        def respond_to?(method, include_private=false)
+          @gateway.respond_to?(method, include_private) || super
+        end
       end
     end
   end

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

@@ -107,6 +107,38 @@ module Killbill
             @accounts.find { |account| account.external_key == external_key.to_s }
           end
         end
+
+        class FakeJavaPaymentApi
+          attr_accessor :payments
+
+          def initialize
+            @payments = []
+          end
+
+          # For testing
+          def add_payment(kb_payment_id=SecureRandom.uuid, kb_payment_transaction_id=SecureRandom.uuid, kb_payment_transaction_external_key=SecureRandom.uuid, transaction_type=:PURCHASE)
+            kb_payment = get_payment kb_payment_id
+            if kb_payment.nil?
+              kb_payment              = ::Killbill::Plugin::Model::Payment.new
+              kb_payment.id           = kb_payment_id
+              kb_payment.transactions = []
+              @payments << kb_payment
+            end
+
+            kb_payment_transaction                  = ::Killbill::Plugin::Model::PaymentTransaction.new
+            kb_payment_transaction.id               = kb_payment_transaction_id
+            kb_payment_transaction.transaction_type = transaction_type
+            kb_payment_transaction.external_key     = kb_payment_transaction_external_key
+            kb_payment_transaction.created_date     = Java::org.joda.time.DateTime.new(Java::org.joda.time.DateTimeZone::UTC)
+            kb_payment.transactions << kb_payment_transaction
+
+            kb_payment
+          end
+
+          def get_payment(id, with_plugin_info=false, properties=[], context=nil)
+            @payments.find { |payment| payment.id == id.to_s }
+          end
+        end
       end
     end
   end

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

@@ -31,32 +31,45 @@ module Killbill
 
         # return DB connections to the Pool if required
         def after_request
-          ::ActiveRecord::Base.connection.close
+          pool = ::ActiveRecord::Base.connection_pool
+          return unless pool.active_connection?
+
+          connection = ::ActiveRecord::Base.connection
+          pool.remove(connection)
+          connection.disconnect!
+
+          @logger.debug "after_request: pool.active_connection? = #{pool.active_connection?}, connection.active? = #{connection.active?}, pool.connections.size = #{pool.connections.size}, connections = #{pool.connections.inspect}"
         end
 
         def authorize_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+          kb_transaction  = get_kb_transaction(kb_payment_id, kb_payment_transaction_id, context.tenant_id)
           amount_in_cents = to_cents(amount, currency)
 
           options               = properties_to_hash(properties)
-          options[:order_id]    ||= kb_payment_transaction_id
+          options[:order_id]    ||= kb_transaction.external_key
           options[:currency]    ||= currency.to_s.upcase
           options[:description] ||= "Kill Bill authorization for #{kb_payment_transaction_id}"
 
           # Retrieve the payment method
           payment_source        = get_payment_source(kb_payment_method_id, properties, options, context)
 
+          before_gateway(kb_transaction, nil, payment_source, amount_in_cents, currency, options)
+
           # Go to the gateway
           gw_response           = gateway.authorize(amount_in_cents, payment_source, options)
           response, transaction = save_response_and_transaction(gw_response, :authorize, kb_account_id, context.tenant_id, kb_payment_id, kb_payment_transaction_id, :AUTHORIZE, amount_in_cents, currency)
 
+          after_gateway(response, transaction, gw_response)
+
           response.to_transaction_info_plugin(transaction)
         end
 
         def capture_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+          kb_transaction  = get_kb_transaction(kb_payment_id, kb_payment_transaction_id, context.tenant_id)
           amount_in_cents = to_cents(amount, currency)
 
           options               = properties_to_hash(properties)
-          options[:order_id]    ||= kb_payment_transaction_id
+          options[:order_id]    ||= kb_transaction.external_key
           options[:currency]    ||= currency.to_s.upcase
           options[:description] ||= "Kill Bill capture for #{kb_payment_transaction_id}"
 
@@ -64,79 +77,116 @@ module Killbill
           # TODO We use the last AUTH transaction at the moment, is it good enough?
           authorization         = @transaction_model.authorizations_from_kb_payment_id(kb_payment_id, context.tenant_id).last.txn_id
 
+          before_gateway(kb_transaction, authorization, nil, amount_in_cents, currency, options)
+
           # Go to the gateway
           gw_response           = gateway.capture(amount_in_cents, authorization, options)
           response, transaction = save_response_and_transaction(gw_response, :capture, kb_account_id, context.tenant_id, kb_payment_id, kb_payment_transaction_id, :CAPTURE, amount_in_cents, currency)
 
+          after_gateway(response, transaction, gw_response)
+
           response.to_transaction_info_plugin(transaction)
         end
 
         def purchase_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+          kb_transaction  = get_kb_transaction(kb_payment_id, kb_payment_transaction_id, context.tenant_id)
           amount_in_cents = to_cents(amount, currency)
 
           options               = properties_to_hash(properties)
-          options[:order_id]    ||= kb_payment_transaction_id
+          options[:order_id]    ||= kb_transaction.external_key
           options[:currency]    ||= currency.to_s.upcase
           options[:description] ||= "Kill Bill purchase for #{kb_payment_transaction_id}"
 
           # Retrieve the payment method
           payment_source        = get_payment_source(kb_payment_method_id, properties, options, context)
 
+          before_gateway(kb_transaction, nil, payment_source, amount_in_cents, currency, options)
+
           # Go to the gateway
           gw_response           = gateway.purchase(amount_in_cents, payment_source, options)
           response, transaction = save_response_and_transaction(gw_response, :purchase, kb_account_id, context.tenant_id, kb_payment_id, kb_payment_transaction_id, :PURCHASE, amount_in_cents, currency)
 
+          after_gateway(response, transaction, gw_response)
+
           response.to_transaction_info_plugin(transaction)
         end
 
         def void_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, properties, context)
+          kb_transaction = get_kb_transaction(kb_payment_id, kb_payment_transaction_id, context.tenant_id)
+
           options               = properties_to_hash(properties)
+          options[:order_id]    ||= kb_transaction.external_key
           options[:description] ||= "Kill Bill void for #{kb_payment_transaction_id}"
 
-          # Retrieve the authorization
-          # TODO We use the last AUTH transaction at the moment, is it good enough?
-          authorization         = @transaction_model.authorizations_from_kb_payment_id(kb_payment_id, context.tenant_id).last.txn_id
+          # If an authorization is being voided, we're performing an 'auth_reversal', otherwise,
+          # we're voiding an unsettled capture or purchase (which often needs to happen within 24 hours).
+          last_transaction      = @transaction_model.purchases_from_kb_payment_id(kb_payment_id, context.tenant_id).last
+          if last_transaction.nil?
+            last_transaction = @transaction_model.captures_from_kb_payment_id(kb_payment_id, context.tenant_id).last
+            if last_transaction.nil?
+              last_transaction = @transaction_model.authorizations_from_kb_payment_id(kb_payment_id, context.tenant_id).last
+              if last_transaction.nil?
+                raise ArgumentError.new("Kill Bill payment #{kb_payment_id} has no auth, capture or purchase, thus cannot be voided")
+              end
+            end
+          end
+          authorization = last_transaction.txn_id
 
-          # Go to the gateway
-          gw_response           = gateway.void(authorization, options)
+          before_gateway(kb_transaction, last_transaction, nil, nil, nil, options)
+
+          # Go to the gateway - while some gateways implementations are smart and have void support 'auth_reversal' and 'void' (e.g. Litle),
+          # others (e.g. CyberSource) implement different methods
+          gw_response           = last_transaction.transaction_type == 'AUTHORIZE' && gateway.respond_to?(:auth_reversal) ? gateway.auth_reversal(last_transaction.amount_in_cents, authorization, options) : gateway.void(authorization, options)
           response, transaction = save_response_and_transaction(gw_response, :void, kb_account_id, context.tenant_id, kb_payment_id, kb_payment_transaction_id, :VOID)
 
+          after_gateway(response, transaction, gw_response)
+
           response.to_transaction_info_plugin(transaction)
         end
 
         def credit_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+          kb_transaction  = get_kb_transaction(kb_payment_id, kb_payment_transaction_id, context.tenant_id)
           amount_in_cents = to_cents(amount, currency)
 
           options               = properties_to_hash(properties)
-          options[:order_id]    ||= kb_payment_transaction_id
+          options[:order_id]    ||= kb_transaction.external_key
           options[:currency]    ||= currency.to_s.upcase
           options[:description] ||= "Kill Bill credit for #{kb_payment_transaction_id}"
 
           # Retrieve the payment method
           payment_source        = get_payment_source(kb_payment_method_id, properties, options, context)
 
+          before_gateway(kb_transaction, nil, payment_source, amount_in_cents, currency, options)
+
           # Go to the gateway
           gw_response           = gateway.credit(amount_in_cents, payment_source, options)
           response, transaction = save_response_and_transaction(gw_response, :credit, kb_account_id, context.tenant_id, kb_payment_id, kb_payment_transaction_id, :CREDIT, amount_in_cents, currency)
 
+          after_gateway(response, transaction, gw_response)
+
           response.to_transaction_info_plugin(transaction)
         end
 
         def refund_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+          kb_transaction  = get_kb_transaction(kb_payment_id, kb_payment_transaction_id, context.tenant_id)
           amount_in_cents = to_cents(amount, currency)
 
           options               = properties_to_hash(properties)
-          options[:order_id]    ||= kb_payment_transaction_id
+          options[:order_id]    ||= kb_transaction.external_key
           options[:currency]    ||= currency.to_s.upcase
           options[:description] ||= "Kill Bill refund for #{kb_payment_transaction_id}"
 
           # Find a transaction to refund
           transaction           = @transaction_model.find_candidate_transaction_for_refund(kb_payment_id, context.tenant_id, amount_in_cents)
 
+          before_gateway(kb_transaction, transaction, nil, amount_in_cents, currency, options)
+
           # Go to the gateway
           gw_response           = gateway.refund(amount_in_cents, transaction.txn_id, options)
           response, transaction = save_response_and_transaction(gw_response, :refund, kb_account_id, context.tenant_id, kb_payment_id, kb_payment_transaction_id, :REFUND, amount_in_cents, currency)
 
+          after_gateway(response, transaction, gw_response)
+
           response.to_transaction_info_plugin(transaction)
         end
 
@@ -352,6 +402,22 @@ module Killbill
 
         # Utilities
 
+        def get_kb_transaction(kb_payment_id, kb_payment_transaction_id, kb_tenant_id)
+          kb_payment     = @kb_apis.payment_api.get_payment(kb_payment_id, false, [], @kb_apis.create_context(kb_tenant_id))
+          kb_transaction = kb_payment.transactions.find { |t| t.id == kb_payment_transaction_id }
+          # This should never happen...
+          raise ArgumentError.new("Unable to find Kill Bill transaction for id #{kb_payment_transaction_id}") if kb_transaction.nil?
+          kb_transaction
+        end
+
+        def before_gateway(kb_transaction, transaction, payment_source, amount_in_cents, currency, options)
+          # Can be used to implement idempotency for example: lookup the payment in the gateway
+          # and pass options[:skip_gw] if the payment has already been through
+        end
+
+        def after_gateway(response, transaction, gw_response)
+        end
+
         def to_cents(amount, currency)
           # Use Money to compute the amount in cents, as it depends on the currency (1 cent of BTC is 1 Satoshi, not 0.01 BTC)
           ::Monetize.from_numeric(amount, currency).cents.to_i
@@ -401,8 +467,8 @@ module Killbill
           prop.nil? ? nil : prop.value
         end
 
-        def account_currency(kb_account_id)
-          account = @kb_apis.account_user_api.get_account_by_id(kb_account_id, @kb_apis.create_context)
+        def account_currency(kb_account_id, kb_tenant_id)
+          account = @kb_apis.account_user_api.get_account_by_id(kb_account_id, @kb_apis.create_context(kb_tenant_id))
           account.currency
         end
 

data/spec/killbill/helpers/connection_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Killbill::Plugin::ActiveMerchant::Utils do
+
+  it 'should close pool' do
+    # Rails' pooling is really just a glorified mapping between threads and connections
+    pool = ::ActiveRecord::Base.connection_pool
+
+    # Verify the reaper is a no-op. Management is in our hands
+    pool.reaper.frequency.should be_nil
+
+    # spec_helper created the table, so there is one active connection for that thread already
+    pool.active_connection?.should be_true
+    pool.connections.size.should == 1
+
+    # Fetch the underlying connection object. This shouldn't create any new connection.
+    # See activerecord-4.1.5/lib/active_record/connection_handling.rb, which proxies to
+    # the connection_handler from activerecord-4.1.5/lib/active_record/connection_adapters/abstract/connection_pool.rb
+    connection = ::ActiveRecord::Base.connection
+    pool.connections.size.should == 1
+    pool.connections[0].should == connection
+
+    # connection is an ActiveRecord::ConnectionAdapters::AbstractAdapter object, specific to the driver.
+    # For both straight JDBC and JNDI, it is an ActiveRecord::ConnectionAdapters::MysqlAdapter,
+    # subclass of ActiveRecord::ConnectionAdapters::JdbcAdapter (activerecord-jdbc-adapter-1.3.9/lib/arjdbc/jdbc/adapter.rb).
+    # The underlying connection is managed by ActiveRecord::ConnectionAdapters::JdbcConnection, which does the JDBC or JNDI lookup
+    # and proxies to Java (https://github.com/jruby/activerecord-jdbc-adapter/blob/master/src/java/arjdbc/jdbc/RubyJdbcConnection.java).
+    connection.active?.should be_true
+
+    # Tell Rails not to re-use this connection. We don't want them to stick in Rails hand.
+    # Instead, we want to force a checkout next time (put into c3p0's hands).
+    pool.remove(connection)
+    pool.active_connection?.should be_false
+    pool.connections.size.should == 0
+
+    # ActiveRecord connection management interface is defined in
+    # activerecord-4.1.5/lib/active_record/connection_adapters/abstract_adapter.rb
+    # Don't use ::ActiveRecord::Base.connection.close, which put the connection back into the pool.
+    connection.disconnect!
+
+    connection.active?.should be_false
+  end
+end

data/spec/killbill/helpers/payment_plugin_spec.rb

@@ -23,6 +23,8 @@ describe Killbill::Plugin::ActiveMerchant::PaymentPlugin do
                                                                                    ::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.logger.level = Logger::INFO
       @plugin.conf_dir     = File.dirname(file)
@@ -66,26 +68,32 @@ describe Killbill::Plugin::ActiveMerchant::PaymentPlugin do
     ::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, @call_context)
     verify_transaction_info_plugin(authorization, authorization_id, :AUTHORIZE, 1)
 
     capture_id = SecureRandom.uuid
+    @payment_api.add_payment(@kb_payment_id, capture_id, SecureRandom.uuid, :CAPTURE)
     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)
 
     purchase_id = SecureRandom.uuid
+    @payment_api.add_payment(@kb_payment_id, purchase_id, SecureRandom.uuid, :PURCHASE)
     purchase    = @plugin.purchase_payment(@kb_account_id, @kb_payment_id, purchase_id, @kb_payment_method_id, @amount_in_cents, @currency, @properties, @call_context)
     verify_transaction_info_plugin(purchase, purchase_id, :PURCHASE, 3)
 
     void_id = SecureRandom.uuid
+    @payment_api.add_payment(@kb_payment_id, void_id, SecureRandom.uuid, :VOID)
     void    = @plugin.void_payment(@kb_account_id, @kb_payment_id, void_id, @kb_payment_method_id, @properties, @call_context)
     verify_transaction_info_plugin(void, void_id, :VOID, 4)
 
     credit_id = SecureRandom.uuid
+    @payment_api.add_payment(@kb_payment_id, credit_id, SecureRandom.uuid, :CREDIT)
     credit    = @plugin.credit_payment(@kb_account_id, @kb_payment_id, credit_id, @kb_payment_method_id, @amount_in_cents, @currency, @properties, @call_context)
     verify_transaction_info_plugin(credit, credit_id, :CREDIT, 5)
 
     refund_id = SecureRandom.uuid
+    @payment_api.add_payment(@kb_payment_id, refund_id, SecureRandom.uuid, :REFUND)
     refund    = @plugin.refund_payment(@kb_account_id, @kb_payment_id, refund_id, @kb_payment_method_id, @amount_in_cents, @currency, @properties, @call_context)
     verify_transaction_info_plugin(refund, refund_id, :REFUND, 6)
 

data/spec/killbill/helpers/response_spec.rb

@@ -58,9 +58,6 @@ describe Killbill::Plugin::ActiveMerchant::ActiveRecord::Response do
     # No associated transaction
     ptip.amount.should be_nil
     ptip.currency.should be_nil
-    # Row not created
-    ptip.created_date.should be_nil
-    ptip.effective_date.should be_nil
     ptip.status.should == :PROCESSED
     ptip.gateway_error.should == 'Message'
     ptip.gateway_error_code.should be_nil

data/spec/spec_helper.rb

@@ -13,6 +13,7 @@ require 'killbill/payment_test'
 require 'killbill/notification_test'
 require 'killbill/helpers/active_merchant'
 require 'killbill/helpers/active_merchant/active_record/models/helpers'
+require 'killbill/helpers/active_merchant/killbill_spec_helper'
 
 require 'killbill/ext/active_merchant/typhoeus_connection'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: killbill
 version: !ruby/object:Gem::Version
-  version: 3.1.8
+  version: 3.1.9
 platform: ruby
 authors:
 - Kill Bill core team
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-08-31 00:00:00.000000000 Z
+date: 2014-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sinatra
@@ -404,6 +404,7 @@ files:
 - spec/killbill/base_plugin_spec.rb
 - spec/killbill/config_test.ru
 - spec/killbill/gen_conversions_spec.rb
+- spec/killbill/helpers/connection_spec.rb
 - spec/killbill/helpers/payment_method_spec.rb
 - spec/killbill/helpers/payment_plugin_spec.rb
 - spec/killbill/helpers/response_spec.rb
@@ -454,6 +455,7 @@ test_files:
 - spec/killbill/base_plugin_spec.rb
 - spec/killbill/config_test.ru
 - spec/killbill/gen_conversions_spec.rb
+- spec/killbill/helpers/connection_spec.rb
 - spec/killbill/helpers/payment_method_spec.rb
 - spec/killbill/helpers/payment_plugin_spec.rb
 - spec/killbill/helpers/response_spec.rb