killbill 3.1.3 → 3.1.4

data/lib/killbill/payment.rb

@@ -7,27 +7,35 @@ module Killbill
       class OperationUnsupportedByGatewayError < NotImplementedError
       end
 
-      def process_payment(kb_account_id, kb_payment_id, kb_payment_method_id, amount, currency, properties, context)
+      def authorize_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
         raise OperationUnsupportedByGatewayError
       end
 
-      def get_payment_info(kb_account_id, kb_payment_id, properties, context)
+      def capture_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
         raise OperationUnsupportedByGatewayError
       end
 
-      def search_payments(search_key, offset, limit, properties, context)
+      def purchase_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+        raise OperationUnsupportedByGatewayError
+      end
+
+      def void_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, properties, context)
+        raise OperationUnsupportedByGatewayError
+      end
+
+      def credit_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
         raise OperationUnsupportedByGatewayError
       end
 
-      def process_refund(kb_account_id, kb_payment_id, refund_amount, currency, properties, context)
+      def refund_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
         raise OperationUnsupportedByGatewayError
       end
 
-      def get_refund_info(kb_account_id, kb_payment_id, properties, context)
+      def get_payment_info(kb_account_id, kb_payment_id, properties, context)
         raise OperationUnsupportedByGatewayError
       end
 
-      def search_refunds(search_key, offset, limit, properties, context)
+      def search_payments(search_key, offset, limit, properties, context)
         raise OperationUnsupportedByGatewayError
       end
 
@@ -58,6 +66,14 @@ module Killbill
       def reset_payment_methods(kb_account_id, payment_methods, properties, context)
         raise OperationUnsupportedByGatewayError
       end
+
+      def build_form_descriptor(kb_account_id, descriptor_fields, properties, context)
+        raise OperationUnsupportedByGatewayError
+      end
+
+      def process_notification(notification, properties, context)
+        raise OperationUnsupportedByGatewayError
+      end
     end
   end
 end

data/lib/killbill/rake_task.rb

@@ -15,14 +15,17 @@ module Killbill
             opts[:plugin_name],                         # Plugin name, e.g. 'klogger'
             opts[:gem_name],                            # Gem file name, e.g. 'klogger-1.0.0.gem'
             opts[:gemfile_name] || "Gemfile",           # Gemfile name
-            opts[:gemfile_lock_name] || "Gemfile.lock") # Gemfile.lock name
+            opts[:gemfile_lock_name] || "Gemfile.lock", # Gemfile.lock name
+            opts[:verbose] || false)
         .install
       end
     end
 
-    def initialize(base_name, plugin_name, gem_name, gemfile_name, gemfile_lock_name)
+    def initialize(base_name, plugin_name, gem_name, gemfile_name, gemfile_lock_name, verbose)
+      @verbose = verbose
+
       @logger = Logger.new(STDOUT)
-      @logger.level = Logger::INFO
+      @logger.level = @verbose ? Logger::DEBUG : Logger::INFO
 
       @base_name = base_name
       @plugin_name = plugin_name
@@ -53,26 +56,30 @@ module Killbill
       # Rely on the Gemfile definition, if it exists, to get all dependencies
       # (we assume the Gemfile includes the plugin gemspec, as it should).
       # Otherwise, use only the plugin gemspec.
-      @specs ||= @gemfile_definition ? @gemfile_definition.specs : [@plugin_gemspec]
+      # When using the Gemfile definition, don't include the :development group -- should this be configurable?
+      @specs ||= @gemfile_definition ? @gemfile_definition.specs_for([:default]) : [@plugin_gemspec]
     end
 
     def install
       namespace :killbill do
         desc "Validate plugin tree"
         # The killbill.properties file is required, but not the config.ru one
-        task :validate => killbill_properties_file do
+        task :validate, [:verbose] => killbill_properties_file do |t, args|
+          set_verbosity(args)
           validate
         end
 
         # Build the .tar.gz and .zip packages
-        task :package => :stage
+        task :package, [:verbose] => :stage
         package_task = Rake::PackageTask.new(name, version) do |p|
           p.need_tar_gz = true
           p.need_zip = true
         end
 
         desc "Stage all dependencies"
-        task :stage => :validate do
+        task :stage, [:verbose] => :validate do |t, args|
+          set_verbosity(args)
+
           stage_dependencies
           stage_extra_files
 
@@ -80,6 +87,32 @@ module Killbill
           package_task.package_files = Rake::FileList.new("#{@package_dir.basename}/**/*")
         end
 
+        desc "Deploy the plugin to Kill Bill"
+        task :deploy, [:force, :plugin_dir, :verbose] => :stage do |t, args|
+          set_verbosity(args)
+
+          plugins_dir = Pathname.new("#{args.plugin_dir || '/var/tmp/bundles/plugins/ruby'}").expand_path
+          mkdir_p plugins_dir, :verbose => @verbose
+
+          plugin_path = Pathname.new("#{plugins_dir}/#{name}")
+          if plugin_path.exist?
+            if args.force == "true"
+              @logger.info "Deleting previous plugin deployment #{plugin_path}"
+              rm_rf plugin_path, :verbose => @verbose
+            else
+              raise "Cowardly not deleting previous plugin deployment #{plugin_path} - override with rake killbill:deploy[true]"
+            end
+          end
+
+          cp_r @package_dir, plugins_dir, :verbose => @verbose
+
+          Rake::FileList.new("#{@base}/*.yml").each do |config_file|
+            config_file_path = Pathname.new("#{plugin_path}/#{version}/#{File.basename(config_file)}").expand_path
+            @logger.info "Deploying #{config_file} to #{config_file_path}"
+            cp config_file, config_file_path, :verbose => @verbose
+          end
+        end
+
         desc "List all dependencies"
         task :dependency => :validate do
           print_dependencies
@@ -94,8 +127,13 @@ module Killbill
 
     private
 
+    def set_verbosity(args)
+      return unless args.verbose == 'true'
+      @verbose = true
+      @logger.level = Logger::DEBUG
+    end
+
     def validate
-      @plugin_gem_file    = find_plugin_gem
       @gemfile_definition = find_gemfile
     end
 
@@ -121,21 +159,25 @@ module Killbill
       Bundler.load_gemspec(spec_path)
     end
 
-    def find_plugin_gem
-      if @gem_name
-        # Absolute path?
-        plugin_gem_file = Pathname.new(@gem_name).expand_path
-        # Relative path to the base?
-        plugin_gem_file = @base.join(@gem_name).expand_path unless plugin_gem_file.file?
-        raise "Unable to find your plugin gem in #{@base}. Did you build it (`rake build')?" unless plugin_gem_file.file?
-      else
-        plugin_gem_files = Dir[File.join(@base, "**/#{name}-#{version}.gem")]
+    def find_plugin_gem(spec)
+      gem_name        = spec.file_name
+      # spec.loaded_from is the path to the gemspec file
+      base            = Pathname.new(File.dirname(spec.loaded_from)).expand_path
+
+      # Try in the base directory first
+      plugin_gem_file = Pathname.new(gem_name).expand_path
+      plugin_gem_file = base.join(gem_name).expand_path unless plugin_gem_file.file?
+
+      # Try in subdirectories next
+      unless plugin_gem_file.file?
+        plugin_gem_files = Dir[File.join(base, "**/#{spec.file_name}")]
         @logger.debug "Gem candidates found: #{plugin_gem_files}"
-        raise "Unable to find your plugin gem in #{@base}. Did you build it? (`rake build')" unless plugin_gem_files.size >= 1
         # Take the first one, assume the other ones are from build directories (e.g. pkg)
-        plugin_gem_file = plugin_gem_files.first
+        plugin_gem_file = Pathname.new(plugin_gem_files.first).expand_path unless plugin_gem_files.empty?
       end
 
+      raise "Unable to find #{gem_name} in #{base}. Did you build it? (`rake build')" unless plugin_gem_file.file?
+
       @logger.debug "Found #{plugin_gem_file}"
       Pathname.new(plugin_gem_file).expand_path
     end
@@ -159,34 +201,54 @@ module Killbill
 
     def stage_dependencies
       # Create the target directory
-      mkdir_p @target_dir.to_s
+      mkdir_p @target_dir.to_s, :verbose => @verbose
 
       @logger.debug "Installing all gem dependencies to #{@target_dir}"
       # We can't simply use Bundler::Installer unfortunately, because we can't tell it to copy the gems for cached ones
       # (it will default to using Bundler::Source::Path references to the gemspecs on "install").
       specs.each do |spec|
-        # For the plugin itself, install it manually (the cache path is likely to be wrong)
-        next if spec.name == name and spec.version == version
-        @logger.debug "Staging #{spec.name} (#{spec.version}) from #{spec.cache_file}"
-        begin
-          Gem::Installer.new(spec.cache_file, {:force => true, :install_dir => @target_dir}).install
-        rescue => e
-          @logger.warn "Unable to stage #{spec.name} (#{spec.version}) from #{spec.cache_file}: #{e}"
+        plugin_gem_file = Pathname.new(spec.cache_file).expand_path
+        if plugin_gem_file.file?
+          @logger.debug "Staging #{spec.name} (#{spec.version}) from #{plugin_gem_file}"
+        else
+          plugin_gem_file = find_plugin_gem(spec)
+          @logger.info "Staging custom gem #{spec.full_name} from #{plugin_gem_file}"
         end
+
+        do_install_gem(plugin_gem_file, spec.name, spec.version)
       end
+    end
 
-      @logger.debug "Staging #{name} (#{version}) from #{@plugin_gem_file}"
-      Gem::Installer.new(@plugin_gem_file, {:force => true, :install_dir => @target_dir}).install
+    def do_install_gem(path, name, version)
+      gem_installer                       = Gem::Installer.new(path,
+                                                               {
+                                                                   :force       => true,
+                                                                   :install_dir => @target_dir,
+                                                                   # Should be redundant with the tweaks below
+                                                                   :development => false,
+                                                                   :wrappers    => true
+                                                               })
+
+      # Tweak the spec file as there are a lot of things we don't care about
+      gem_installer.spec.executables      = nil
+      gem_installer.spec.extensions       = nil
+      gem_installer.spec.extra_rdoc_files = nil
+      gem_installer.spec.test_files       = nil
+
+      gem_installer.install
+    rescue => e
+      @logger.warn "Unable to stage #{name} (#{version}) from #{path}: #{e}"
+      raise e
     end
 
     def stage_extra_files
       unless killbill_properties_file.nil?
         @logger.debug "Staging #{killbill_properties_file} to #{@plugin_root_target_dir}"
-        cp killbill_properties_file, @plugin_root_target_dir
+        cp killbill_properties_file, @plugin_root_target_dir, :verbose => @verbose
       end
       unless config_ru_file.nil?
         @logger.debug "Staging #{config_ru_file} to #{@plugin_root_target_dir}"
-        cp config_ru_file, @plugin_root_target_dir
+        cp config_ru_file, @plugin_root_target_dir, :verbose => @verbose
       end
     end
 

data/spec/killbill/helpers/payment_method_spec.rb

@@ -16,6 +16,145 @@ describe Killbill::Plugin::ActiveMerchant::ActiveRecord::PaymentMethod do
     ::Killbill::Test::TestPaymentMethod.delete_all
   end
 
+  it 'should construct payment methods correctly' do
+    kb_account_id        = SecureRandom.uuid
+    kb_payment_method_id = SecureRandom.uuid
+    kb_tenant_id         = SecureRandom.uuid
+    response             = ::ActiveMerchant::Billing::Response.new(true, nil, {}, {:authorization => SecureRandom.uuid})
+    options              = {
+        :billing_address => {
+            :address1 => SecureRandom.uuid,
+            :address2 => SecureRandom.uuid,
+            :city     => SecureRandom.uuid,
+            :state    => SecureRandom.uuid,
+            :zip      => SecureRandom.uuid,
+            :country  => SecureRandom.uuid
+        }
+    }
+    cc                   = ::ActiveMerchant::Billing::CreditCard.new(
+        :first_name => 'Steve',
+        :last_name  => 'Smith',
+        :month      => '9',
+        :year       => '2010',
+        :brand      => 'visa',
+        :number     => '4242424242424242'
+    )
+    token                = SecureRandom.uuid
+
+    # Test storage of CC details
+    pm                   = ::Killbill::Test::TestPaymentMethod.from_response(kb_account_id, kb_payment_method_id, kb_tenant_id, cc, response, options, {}, ::Killbill::Test::TestPaymentMethod)
+    pm.kb_account_id.should == kb_account_id
+    pm.kb_payment_method_id.should == kb_payment_method_id
+    pm.kb_tenant_id.should == kb_tenant_id
+    pm.token.should == response.authorization
+    pm.cc_first_name.should == cc.first_name
+    pm.cc_last_name.should == cc.last_name
+    pm.cc_type.should == cc.brand
+    pm.cc_exp_month.should == cc.month.to_i
+    pm.cc_exp_year.should == cc.year.to_i
+    pm.cc_last_4.should == cc.last_digits.to_i
+    pm.address1.should == options[:billing_address][:address1]
+    pm.address2.should == options[:billing_address][:address2]
+    pm.city.should == options[:billing_address][:city]
+    pm.state.should == options[:billing_address][:state]
+    pm.zip.should == options[:billing_address][:zip]
+    pm.country.should == options[:billing_address][:country]
+    # Verify conversions
+    verify_conversion_to_kb_objects(pm, kb_account_id, kb_payment_method_id, response.authorization)
+
+    # Test storage of CC details with no billing address
+    pm = ::Killbill::Test::TestPaymentMethod.from_response(kb_account_id, kb_payment_method_id, kb_tenant_id, cc, response, {}, {}, ::Killbill::Test::TestPaymentMethod)
+    pm.kb_account_id.should == kb_account_id
+    pm.kb_payment_method_id.should == kb_payment_method_id
+    pm.kb_tenant_id.should == kb_tenant_id
+    pm.token.should == response.authorization
+    pm.cc_first_name.should == cc.first_name
+    pm.cc_last_name.should == cc.last_name
+    pm.cc_type.should == cc.brand
+    pm.cc_exp_month.should == cc.month.to_i
+    pm.cc_exp_year.should == cc.year.to_i
+    pm.cc_last_4.should == cc.last_digits.to_i
+    pm.address1.should be_nil
+    pm.address2.should be_nil
+    pm.city.should be_nil
+    pm.state.should be_nil
+    pm.zip.should be_nil
+    pm.country.should be_nil
+    # Verify conversions
+    verify_conversion_to_kb_objects(pm, kb_account_id, kb_payment_method_id, response.authorization)
+
+    # Test storage of token
+    pm = ::Killbill::Test::TestPaymentMethod.from_response(kb_account_id, kb_payment_method_id, kb_tenant_id, token, response, options, {}, ::Killbill::Test::TestPaymentMethod)
+    pm.kb_account_id.should == kb_account_id
+    pm.kb_payment_method_id.should == kb_payment_method_id
+    pm.kb_tenant_id.should == kb_tenant_id
+    pm.token.should == token
+    pm.cc_first_name.should be_nil
+    pm.cc_last_name.should be_nil
+    pm.cc_type.should be_nil
+    pm.cc_exp_month.should be_nil
+    pm.cc_exp_year.should be_nil
+    pm.cc_last_4.should be_nil
+    pm.address1.should == options[:billing_address][:address1]
+    pm.address2.should == options[:billing_address][:address2]
+    pm.city.should == options[:billing_address][:city]
+    pm.state.should == options[:billing_address][:state]
+    pm.zip.should == options[:billing_address][:zip]
+    pm.country.should == options[:billing_address][:country]
+    # Verify conversions
+    verify_conversion_to_kb_objects(pm, kb_account_id, kb_payment_method_id, token)
+
+    # Test storage of token with no billing address
+    pm = ::Killbill::Test::TestPaymentMethod.from_response(kb_account_id, kb_payment_method_id, kb_tenant_id, token, response, {}, {}, ::Killbill::Test::TestPaymentMethod)
+    pm.kb_account_id.should == kb_account_id
+    pm.kb_payment_method_id.should == kb_payment_method_id
+    pm.kb_tenant_id.should == kb_tenant_id
+    pm.token.should == token
+    pm.cc_first_name.should be_nil
+    pm.cc_last_name.should be_nil
+    pm.cc_type.should be_nil
+    pm.cc_exp_month.should be_nil
+    pm.cc_exp_year.should be_nil
+    pm.cc_last_4.should be_nil
+    pm.address1.should be_nil
+    pm.address2.should be_nil
+    pm.city.should be_nil
+    pm.state.should be_nil
+    pm.zip.should be_nil
+    pm.country.should be_nil
+    # Verify conversions
+    verify_conversion_to_kb_objects(pm, kb_account_id, kb_payment_method_id, token)
+  end
+
+  it 'should store and retrieve payment methods correctly' do
+    kb_account_id        = SecureRandom.uuid
+    kb_payment_method_id = SecureRandom.uuid
+    kb_tenant_id         = SecureRandom.uuid
+    response             = ::ActiveMerchant::Billing::Response.new(true, nil, {}, {:authorization => SecureRandom.uuid})
+    token                = SecureRandom.uuid
+    pm = ::Killbill::Test::TestPaymentMethod.from_response(kb_account_id, kb_payment_method_id, kb_tenant_id, token, response, {}, {}, ::Killbill::Test::TestPaymentMethod)
+    pm.save!
+
+    # Retrieve by account id
+    ::Killbill::Test::TestPaymentMethod.from_kb_account_id(kb_account_id, nil).size.should == 0
+    ::Killbill::Test::TestPaymentMethod.from_kb_account_id(kb_account_id, SecureRandom.uuid).size.should == 0
+    ::Killbill::Test::TestPaymentMethod.from_kb_account_id(SecureRandom.uuid, kb_tenant_id).size.should == 0
+    pms = ::Killbill::Test::TestPaymentMethod.from_kb_account_id(kb_account_id, kb_tenant_id)
+    pms.size.should == 1
+    pms[0].kb_payment_method_id.should == kb_payment_method_id
+
+    # Retrieve by payment method id
+    expect { ::Killbill::Test::TestPaymentMethod.from_kb_payment_method_id(kb_payment_method_id, nil) }.to raise_error
+    expect { ::Killbill::Test::TestPaymentMethod.from_kb_payment_method_id(kb_payment_method_id, SecureRandom.uuid) }.to raise_error
+    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
+
+    # 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
+    expect { ::Killbill::Test::TestPaymentMethod.from_kb_payment_method_id(kb_payment_method_id, kb_tenant_id) }.to raise_error
+  end
+
   it 'should generate the right SQL query' do
     # Check count query (search query numeric)
     expected_query = "SELECT COUNT(DISTINCT \"test_payment_methods\".\"id\") FROM \"test_payment_methods\"  WHERE ((((((((((((((\"test_payment_methods\".\"kb_account_id\" = '1234' OR \"test_payment_methods\".\"kb_payment_method_id\" = '1234') OR \"test_payment_methods\".\"token\" = '1234') OR \"test_payment_methods\".\"cc_type\" = '1234') OR \"test_payment_methods\".\"state\" = '1234') OR \"test_payment_methods\".\"zip\" = '1234') OR \"test_payment_methods\".\"cc_first_name\" LIKE '%1234%') OR \"test_payment_methods\".\"cc_last_name\" LIKE '%1234%') OR \"test_payment_methods\".\"address1\" LIKE '%1234%') OR \"test_payment_methods\".\"address2\" LIKE '%1234%') OR \"test_payment_methods\".\"city\" LIKE '%1234%') OR \"test_payment_methods\".\"country\" LIKE '%1234%') OR \"test_payment_methods\".\"cc_exp_month\" = 1234) OR \"test_payment_methods\".\"cc_exp_year\" = 1234) OR \"test_payment_methods\".\"cc_last_4\" = 1234) AND \"test_payment_methods\".\"kb_tenant_id\" = '11-22-33'  ORDER BY \"test_payment_methods\".\"id\""
@@ -100,4 +239,18 @@ describe Killbill::Plugin::ActiveMerchant::ActiveRecord::PaymentMethod do
     pagination.total_nb_records.should == results.size
     results
   end
+
+  def verify_conversion_to_kb_objects(pm, kb_account_id, kb_payment_method_id, external_payment_method_id)
+    # Verify conversion to PaymentMethodPlugin
+    pmp = pm.to_payment_method_plugin
+    pmp.kb_payment_method_id.should == kb_payment_method_id
+    pmp.external_payment_method_id.should == external_payment_method_id
+    pmp.properties.size.should == 12
+
+    # Verify conversion to PaymentMethodInfoPlugin
+    pmip = pm.to_payment_method_info_plugin
+    pmip.account_id.should == kb_account_id
+    pmip.payment_method_id.should == kb_payment_method_id
+    pmip.external_payment_method_id.should == external_payment_method_id
+  end
 end

data/spec/killbill/helpers/response_spec.rb

@@ -16,24 +16,74 @@ describe Killbill::Plugin::ActiveMerchant::ActiveRecord::Response do
     ::Killbill::Test::TestResponse.delete_all
   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', {}, {
+        :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.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.message.should == response.message
+    r.authorization.should == response.authorization
+    r.fraud_review.should == response.fraud_review?
+    r.test.should == response.test
+    r.avs_result_code.should == 'P'
+    r.avs_result_message.should == 'Postal code matches, but street address not verified.'
+    r.avs_result_street_match.should be_nil
+    r.avs_result_postal_match.should == 'Y'
+    r.cvv_result_code.should be_nil
+    r.cvv_result_message.should be_nil
+    r.success.should == response.success?
+
+    # Verify conversion to PaymentTransactionInfoPlugin
+    ptip = r.to_transaction_info_plugin
+    ptip.kb_payment_id.should == kb_payment_id
+    ptip.kb_transaction_payment_id.should == kb_payment_transaction_id
+    ptip.transaction_type.should == transaction_type
+    # 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
+    ptip.first_payment_reference_id.should be_nil
+    ptip.second_payment_reference_id.should be_nil
+    ptip.properties.size.should == 11
+  end
+
   it 'should generate the right SQL query' do
     # Check count query (search query numeric)
-    expected_query = "SELECT COUNT(DISTINCT \"test_responses\".\"id\") FROM \"test_responses\"  WHERE (((\"test_responses\".\"kb_payment_id\" = '1234' OR \"test_responses\".\"message\" = '1234') OR \"test_responses\".\"authorization\" = '1234') OR \"test_responses\".\"fraud_review\" = '1234') AND \"test_responses\".\"api_call\" = 'charge' AND \"test_responses\".\"success\" = 't' AND \"test_responses\".\"kb_tenant_id\" = '11-22-33'  ORDER BY \"test_responses\".\"id\""
+    expected_query = "SELECT COUNT(DISTINCT \"test_responses\".\"id\") FROM \"test_responses\"  WHERE ((((\"test_responses\".\"kb_payment_id\" = '1234' OR \"test_responses\".\"kb_payment_transaction_id\" = '1234') OR \"test_responses\".\"message\" = '1234') OR \"test_responses\".\"authorization\" = '1234') OR \"test_responses\".\"fraud_review\" = '1234') AND \"test_responses\".\"success\" = 't' AND \"test_responses\".\"kb_tenant_id\" = '11-22-33'  ORDER BY \"test_responses\".\"id\""
     # Note that Kill Bill will pass a String, even for numeric types
-    ::Killbill::Test::TestResponse.search_query('charge', '1234', '11-22-33').to_sql.should == expected_query
+    ::Killbill::Test::TestResponse.search_query('1234', '11-22-33').to_sql.should == expected_query
 
     # Check query with results (search query numeric)
-    expected_query = "SELECT  DISTINCT \"test_responses\".* FROM \"test_responses\"  WHERE (((\"test_responses\".\"kb_payment_id\" = '1234' OR \"test_responses\".\"message\" = '1234') OR \"test_responses\".\"authorization\" = '1234') OR \"test_responses\".\"fraud_review\" = '1234') AND \"test_responses\".\"api_call\" = 'charge' AND \"test_responses\".\"success\" = 't' AND \"test_responses\".\"kb_tenant_id\" = '11-22-33'  ORDER BY \"test_responses\".\"id\" LIMIT 10 OFFSET 0"
+    expected_query = "SELECT  DISTINCT \"test_responses\".* FROM \"test_responses\"  WHERE ((((\"test_responses\".\"kb_payment_id\" = '1234' OR \"test_responses\".\"kb_payment_transaction_id\" = '1234') OR \"test_responses\".\"message\" = '1234') OR \"test_responses\".\"authorization\" = '1234') OR \"test_responses\".\"fraud_review\" = '1234') AND \"test_responses\".\"success\" = 't' AND \"test_responses\".\"kb_tenant_id\" = '11-22-33'  ORDER BY \"test_responses\".\"id\" LIMIT 10 OFFSET 0"
     # Note that Kill Bill will pass a String, even for numeric types
-    ::Killbill::Test::TestResponse.search_query('charge', '1234', '11-22-33', 0, 10).to_sql.should == expected_query
+    ::Killbill::Test::TestResponse.search_query('1234', '11-22-33', 0, 10).to_sql.should == expected_query
 
     # Check count query (search query string)
-    expected_query = "SELECT COUNT(DISTINCT \"test_responses\".\"id\") FROM \"test_responses\"  WHERE (((\"test_responses\".\"kb_payment_id\" = 'XXX' OR \"test_responses\".\"message\" = 'XXX') OR \"test_responses\".\"authorization\" = 'XXX') OR \"test_responses\".\"fraud_review\" = 'XXX') AND \"test_responses\".\"api_call\" = 'charge' AND \"test_responses\".\"success\" = 't' AND \"test_responses\".\"kb_tenant_id\" = '11-22-33'  ORDER BY \"test_responses\".\"id\""
-    ::Killbill::Test::TestResponse.search_query('charge', 'XXX', '11-22-33').to_sql.should == expected_query
+    expected_query = "SELECT COUNT(DISTINCT \"test_responses\".\"id\") FROM \"test_responses\"  WHERE ((((\"test_responses\".\"kb_payment_id\" = 'XXX' OR \"test_responses\".\"kb_payment_transaction_id\" = 'XXX') OR \"test_responses\".\"message\" = 'XXX') OR \"test_responses\".\"authorization\" = 'XXX') OR \"test_responses\".\"fraud_review\" = 'XXX') AND \"test_responses\".\"success\" = 't' AND \"test_responses\".\"kb_tenant_id\" = '11-22-33'  ORDER BY \"test_responses\".\"id\""
+    ::Killbill::Test::TestResponse.search_query('XXX', '11-22-33').to_sql.should == expected_query
 
     # Check query with results (search query string)
-    expected_query = "SELECT  DISTINCT \"test_responses\".* FROM \"test_responses\"  WHERE (((\"test_responses\".\"kb_payment_id\" = 'XXX' OR \"test_responses\".\"message\" = 'XXX') OR \"test_responses\".\"authorization\" = 'XXX') OR \"test_responses\".\"fraud_review\" = 'XXX') AND \"test_responses\".\"api_call\" = 'charge' AND \"test_responses\".\"success\" = 't' AND \"test_responses\".\"kb_tenant_id\" = '11-22-33'  ORDER BY \"test_responses\".\"id\" LIMIT 10 OFFSET 0"
-    ::Killbill::Test::TestResponse.search_query('charge', 'XXX', '11-22-33', 0, 10).to_sql.should == expected_query
+    expected_query = "SELECT  DISTINCT \"test_responses\".* FROM \"test_responses\"  WHERE ((((\"test_responses\".\"kb_payment_id\" = 'XXX' OR \"test_responses\".\"kb_payment_transaction_id\" = 'XXX') OR \"test_responses\".\"message\" = 'XXX') OR \"test_responses\".\"authorization\" = 'XXX') OR \"test_responses\".\"fraud_review\" = 'XXX') AND \"test_responses\".\"success\" = 't' AND \"test_responses\".\"kb_tenant_id\" = '11-22-33'  ORDER BY \"test_responses\".\"id\" LIMIT 10 OFFSET 0"
+    ::Killbill::Test::TestResponse.search_query('XXX', '11-22-33', 0, 10).to_sql.should == expected_query
   end
 
   it 'should search all fields' do
@@ -45,13 +95,6 @@ describe Killbill::Plugin::ActiveMerchant::ActiveRecord::Response do
                                                      :kb_tenant_id  => '11-22-33',
                                                      :success       => true
 
-    # Wrong api_call
-    ignored1 = ::Killbill::Test::TestResponse.create :api_call      => 'add_payment_method',
-                                                     :kb_account_id => '55-66-77-88',
-                                                     :kb_payment_id => pm.kb_payment_id,
-                                                     :kb_tenant_id  => '11-22-33',
-                                                     :success       => true
-
     # Not successful
     ignored2 = ::Killbill::Test::TestResponse.create :api_call      => 'charge',
                                                      :kb_account_id => '55-66-77-88',