killbill-braintree_blue 0.0.1

data/lib/braintree_blue/api.rb

@@ -0,0 +1,178 @@
+module Killbill #:nodoc:
+  module BraintreeBlue #:nodoc:
+    class PaymentPlugin < ::Killbill::Plugin::ActiveMerchant::PaymentPlugin
+
+      def initialize
+        gateway_builder = Proc.new do |config|
+          # Change this if needed
+          ::ActiveMerchant::Billing::BraintreeBlueGateway.new :merchant_id => config[:merchant_id],
+                                                              :public_key  => config[:public_key],
+                                                              :private_key => config[:private_key]        
+	end
+
+        super(gateway_builder,
+              :braintree_blue,
+              ::Killbill::BraintreeBlue::BraintreeBluePaymentMethod,
+              ::Killbill::BraintreeBlue::BraintreeBlueTransaction,
+              ::Killbill::BraintreeBlue::BraintreeBlueResponse)
+      end
+
+      def authorize_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+        # Pass extra parameters for the gateway here
+        options = { }
+        
+        options.merge(get_merchant_id(currency))
+          
+        properties = merge_properties(properties, options)
+        super(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+      end
+
+      def capture_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {}
+        options.merge(get_merchant_id(currency))
+        properties = merge_properties(properties, options)
+        super(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+      end
+
+      def purchase_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {}
+        options.merge(get_merchant_id(currency))
+        properties = merge_properties(properties, options)
+        super(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+      end
+
+      def void_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {}
+        options.merge(get_merchant_id(currency))
+        properties = merge_properties(properties, options)
+        super(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, properties, context)
+      end
+
+      def credit_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {}
+        options.merge(get_merchant_id(currency))
+        properties = merge_properties(properties, options)
+        super(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+      end
+
+      def refund_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {}
+        options.merge(get_merchant_id(currency))
+        properties = merge_properties(properties, options)
+        super(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+      end
+
+      def get_payment_info(kb_account_id, kb_payment_id, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {}
+        properties = merge_properties(properties, options)
+        super(kb_account_id, kb_payment_id, properties, context)
+      end
+
+      def search_payments(search_key, offset, limit, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {}
+        options.merge(get_merchant_id(currency))
+        properties = merge_properties(properties, options)
+        super(search_key, offset, limit, properties, context)
+      end
+
+      def add_payment_method(kb_account_id, kb_payment_method_id, payment_method_props, set_default, properties, context)
+	       braintree_customer_id = BraintreeBluePaymentMethod.braintree_customer_id_from_kb_account_id(kb_account_id, context.tenant_id)
+
+        options = {
+            :customer => braintree_customer_id,
+            :company => kb_account_id
+	       }
+        properties = merge_properties(properties, options)
+        super(kb_account_id, kb_payment_method_id, payment_method_props, set_default, properties, context)
+      end
+
+      def delete_payment_method(kb_account_id, kb_payment_method_id, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {}
+        properties = merge_properties(properties, options)
+        super(kb_account_id, kb_payment_method_id, properties, context)
+      end
+
+      def get_payment_method_detail(kb_account_id, kb_payment_method_id, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {}
+        properties = merge_properties(properties, options)
+        super(kb_account_id, kb_payment_method_id, properties, context)
+      end
+
+      def set_default_payment_method(kb_account_id, kb_payment_method_id, properties, context)
+        # TODO
+      end
+
+      def get_payment_methods(kb_account_id, refresh_from_gateway, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {}
+        properties = merge_properties(properties, options)
+        super(kb_account_id, refresh_from_gateway, properties, context)
+      end
+
+      def search_payment_methods(search_key, offset, limit, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {}
+        properties = merge_properties(properties, options)
+        super(search_key, offset, limit, properties, context)
+      end
+
+      def reset_payment_methods(kb_account_id, payment_methods, properties, context)
+        super
+      end
+
+      def build_form_descriptor(kb_account_id, descriptor_fields, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {}
+        properties = merge_properties(properties, options)
+
+        # Add your custom static hidden tags here
+        options = {
+            #:token => config[:braintree_blue][:token]
+        }
+        descriptor_fields = merge_properties(descriptor_fields, options)
+
+        super(kb_account_id, descriptor_fields, properties, context)
+      end
+
+      def process_notification(notification, properties, context)
+        # Pass extra parameters for the gateway here
+        options = {}       
+        properties = merge_properties(properties, options)
+
+        super(notification, properties, context) do |gw_notification, service|
+          # Retrieve the payment
+          # gw_notification.kb_payment_id =
+          #
+          # Set the response body
+          # gw_notification.entity =
+        end
+      end
+        
+      def get_merchant_id(currency)
+        
+        options = {}
+        if (config[:braintree_blue][:multicurrency]) 
+            case currency
+                when "USD"
+                    options = { :merchant_account_id => config[:multicurrency][:USD] }
+                when "EUR"
+                    options = { :merchant_account_id => config[:multicurrency][:EUR] }
+                when "PLN"
+                    options = { :merchant_account_id => config[:multicurrency][:PLN] }
+            end
+        end
+        options     
+      end
+    
+    end
+  end
+end

data/lib/braintree_blue/application.rb

@@ -0,0 +1,80 @@
+# -- encoding : utf-8 --
+
+set :views, File.expand_path(File.dirname(__FILE__) + '/views')
+
+include Killbill::Plugin::ActiveMerchant::Sinatra
+
+configure do
+  # Usage: rackup -Ilib -E test
+  if development? or test?
+    # Make sure the plugin is initialized
+    plugin              = ::Killbill::BraintreeBlue::PaymentPlugin.new
+    plugin.logger       = Logger.new(STDOUT)
+    plugin.logger.level = Logger::INFO
+    plugin.conf_dir     = File.dirname(File.dirname(__FILE__)) + '/..'
+    plugin.start_plugin
+  end
+end
+
+helpers do
+  def plugin(session = {})
+    ::Killbill::BraintreeBlue::PrivatePaymentPlugin.new(session)
+  end
+end
+
+# curl -v http://127.0.0.1:9292/plugins/killbill-braintree_blue/form
+get '/plugins/killbill-braintree_blue/form', :provides => 'html' do
+  order_id   = request.GET['order_id']
+  account_id = request.GET['account_id']
+  options    = {
+      :amount           => request.GET['amount'],
+      :currency         => request.GET['currency'],
+      :test             => request.GET['test'],
+      :credential2      => request.GET['credential2'],
+      :credential3      => request.GET['credential3'],
+      :credential4      => request.GET['credential4'],
+      :country          => request.GET['country'],
+      :account_name     => request.GET['account_name'],
+      :transaction_type => request.GET['transaction_type'],
+      :authcode         => request.GET['authcode'],
+      :notify_url       => request.GET['notify_url'],
+      :return_url       => request.GET['return_url'],
+      :redirect_param   => request.GET['redirect_param'],
+      :forward_url      => request.GET['forward_url']
+  }
+
+  @form = plugin(session).payment_form_for(order_id, account_id, :braintree_blue, options) do |service|
+    # Add your custom hidden tags here, e.g.
+    #service.token = config[:braintree_blue][:token]
+    submit_tag 'Submit'
+  end
+
+  erb :form
+end
+
+# curl -v http://127.0.0.1:9292/plugins/killbill-braintree_blue/1.0/pms/1
+get '/plugins/killbill-braintree_blue/1.0/pms/:id', :provides => 'json' do
+  if pm = ::Killbill::BraintreeBlue::BraintreeBluePaymentMethod.find_by_id(params[:id].to_i)
+    pm.to_json
+  else
+    status 404
+  end
+end
+
+# curl -v http://127.0.0.1:9292/plugins/killbill-braintree_blue/1.0/transactions/1
+get '/plugins/killbill-braintree_blue/1.0/transactions/:id', :provides => 'json' do
+  if transaction = ::Killbill::BraintreeBlue::BraintreeBlueTransaction.find_by_id(params[:id].to_i)
+    transaction.to_json
+  else
+    status 404
+  end
+end
+
+# curl -v http://127.0.0.1:9292/plugins/killbill-braintree_blue/1.0/responses/1
+get '/plugins/killbill-braintree_blue/1.0/responses/:id', :provides => 'json' do
+  if transaction = ::Killbill::BraintreeBlue::BraintreeBlueResponse.find_by_id(params[:id].to_i)
+    transaction.to_json
+  else
+    status 404
+  end
+end

data/lib/braintree_blue/models/payment_method.rb

@@ -0,0 +1,55 @@
+module Killbill #:nodoc:
+  module BraintreeBlue #:nodoc:
+    class BraintreeBluePaymentMethod < ::Killbill::Plugin::ActiveMerchant::ActiveRecord::PaymentMethod
+
+      self.table_name = 'braintree_blue_payment_methods'
+
+      def self.from_response(kb_account_id, kb_payment_method_id, kb_tenant_id, cc_or_token, response, options, extra_params = {}, model = ::Killbill::BraintreeBlue::BraintreeBluePaymentMethod)
+
+        braintree_customer_id = self.braintree_customer_id_from_kb_account_id(kb_account_id, kb_tenant_id)
+
+        unless braintree_customer_id.blank?
+          card_response     = response.responses.first.params
+          customer_response = response.responses.last.params
+        else
+          card_response     = response.params['braintree_customer']['credit_cards'][0]
+          customer_response = response.params['braintree_customer']
+        end
+
+        super(kb_account_id,
+              kb_payment_method_id,
+              kb_tenant_id,
+              cc_or_token,
+              response,
+              options,
+              {
+                  :braintree_customer_id => customer_response['id'],
+                  :token              	 => customer_response['id'],
+                  :cc_type               => card_response['card_type'],
+                  :cc_exp_month          => card_response['expiration_date'].split('/').first,
+                  :cc_exp_year           => card_response['expiration_date'].split('/').last,
+                  :cc_last_4             => card_response['last_4'],
+                  :cc_first_name         => customer_response['first_name'],
+                  :cc_last_name          => customer_response['last_name']
+              }.merge!(extra_params),
+              model)
+      end
+
+      def self.search_where_clause(t, search_key)
+        super.or(t[:braintree_customer_id].eq(search_key))
+      end
+
+      def self.braintree_customer_id_from_kb_account_id(kb_account_id, tenant_id)
+        pms = from_kb_account_id(kb_account_id, tenant_id)
+        return nil if pms.empty?
+
+        braintree_customer_ids = Set.new
+        pms.each { |pm| braintree_customer_ids << pm.braintree_customer_id }
+        raise "No Braintree customer id found for account #{kb_account_id}" if braintree_customer_ids.empty?
+        raise "Kill Bill account #{kb_account_id} mapping to multiple Braintree customers: #{braintree_customer_ids}" if braintree_customer_ids.size > 1
+        braintree_customer_ids.first
+      end
+
+    end
+  end
+end

data/lib/braintree_blue/models/response.rb

@@ -0,0 +1,47 @@
+module Killbill #:nodoc:
+  module BraintreeBlue #:nodoc:
+    class BraintreeBlueResponse < ::Killbill::Plugin::ActiveMerchant::ActiveRecord::Response
+
+      self.table_name = 'braintree_blue_responses'
+
+      has_one :braintree_blue_transaction
+
+      def self.from_response(api_call, kb_account_id, kb_payment_id, kb_payment_transaction_id, transaction_type, payment_processor_account_id, kb_tenant_id, response, extra_params = {}, model = ::Killbill::BraintreeBlue::BraintreeBlueResponse)
+	
+        super(api_call,
+              kb_account_id,
+              kb_payment_id,
+              kb_payment_transaction_id,
+              transaction_type,
+              payment_processor_account_id,
+              kb_tenant_id,
+              response,
+              {
+		          :params_braintree_customer_id => extract(response, 'braintree_customer','id'),
+		          :params_braintree_customer_first_name => extract(response, 'braintree_customer','first_name'),
+		          :params_braintree_customer_last_name => extract(response, 'braintree_customer','last_name'),
+		          :params_braintree_customer_email => extract(response, 'braintree_customer','email'),
+		          :params_braintree_customer_customer_vault_id => extract(response, 'braintree_customer','customer_vault_id'),
+		          :params_braintree_customer_credit_card_token => extract(response, 'braintree_customer','credit_card_token'),
+                  :params_braintree_customer_credit_card_bin             => extract(response, 'card_response','bin'),
+                  :params_braintree_customer_credit_card_expiration_date => extract(response, 'card_response','expiration_date'),
+                  :params_braintree_customer_credit_card_last_4          => extract(response, 'card_response','last_4'),
+                  :params_braintree_customer_credit_card_card_type       => extract(response, 'card_response','card_type'),
+                  :params_braintree_customer_credit_card_masked_number   => extract(response, 'card_response','masked_number')
+              }.merge!(extra_params),
+              model)
+      end
+        
+      def self.search_where_clause(t, search_key)
+        where_clause = t[:params_braintree_customer_id].eq(search_key)
+                   .or(t[:params_braintree_customer_credit_card_token].eq(search_key))
+
+        # Only search successful payments and refunds
+        where_clause = where_clause.and(t[:success].eq(true))
+
+        super.or(where_clause)
+      end 
+        
+    end
+  end
+end

data/lib/braintree_blue/models/transaction.rb

@@ -0,0 +1,11 @@
+module Killbill #:nodoc:
+  module BraintreeBlue #:nodoc:
+    class BraintreeBlueTransaction < ::Killbill::Plugin::ActiveMerchant::ActiveRecord::Transaction
+
+      self.table_name = 'braintree_blue_transactions'
+
+      belongs_to :braintree_blue_response
+
+    end
+  end
+end

data/lib/braintree_blue/private_api.rb

@@ -0,0 +1,13 @@
+module Killbill #:nodoc:
+  module BraintreeBlue #:nodoc:
+    class PrivatePaymentPlugin < ::Killbill::Plugin::ActiveMerchant::PrivatePaymentPlugin
+      def initialize(session = {})
+        super(:braintree_blue,
+              ::Killbill::BraintreeBlue::BraintreeBluePaymentMethod,
+              ::Killbill::BraintreeBlue::BraintreeBlueTransaction,
+              ::Killbill::BraintreeBlue::BraintreeBlueResponse,
+              session)
+      end
+    end
+  end
+end

data/lib/braintree_blue/views/form.erb

@@ -0,0 +1,8 @@
+<!DOCTYPE html>
+<html>
+<body>
+
+<%= @form %>
+
+</body>
+</html>

data/lib/braintree_blue.rb

@@ -0,0 +1,25 @@
+require 'openssl'
+require 'action_controller'
+require 'active_record'
+require 'action_view'
+require 'active_merchant'
+require 'active_support'
+require 'bigdecimal'
+require 'money'
+require 'monetize'
+require 'offsite_payments'
+require 'pathname'
+require 'sinatra'
+require 'singleton'
+require 'yaml'
+
+require 'killbill'
+require 'killbill/helpers/active_merchant'
+
+require 'braintree_blue/api'
+require 'braintree_blue/private_api'
+
+require 'braintree_blue/models/payment_method'
+require 'braintree_blue/models/response'
+require 'braintree_blue/models/transaction'
+

data/pom.xml

@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+~ Copyright 2014 The Billing Project, LLC
+~
+~  The Billing Project 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>org.kill-bill.billing.plugin.ruby</groupId>
+    <artifactId>braintree_blue-plugin</artifactId>
+    <packaging>pom</packaging>
+    <version>0.0.1</version>
+    <name>braintree_blue-plugin</name>
+    <url>http://github.com/killbill/killbill-braintree_blue-plugin</url>
+    <description>Plugin for accessing BraintreeBlue as a payment gateway</description>
+    <licenses>
+        <license>
+            <name>Apache License 2.0</name>
+            <url>http://www.apache.org/licenses/LICENSE-2.0.html</url>
+            <distribution>repo</distribution>
+        </license>
+    </licenses>
+    <scm>
+        <connection>scm:git:git://github.com/killbill/killbill-braintree_blue-plugin.git</connection>
+        <url>https://github.com/killbill/killbill-braintree_blue-plugin/</url>
+        <developerConnection>scm:git:git@github.com:killbill/killbill-braintree_blue-plugin.git</developerConnection>
+    </scm>
+</project>

data/release.sh

@@ -0,0 +1,41 @@
+set -e
+
+if [ 'GNU' != "$(tar --help | grep GNU | head -1 | awk '{print $1}')" ]; then
+  echo 'Unable to release: make sure to use GNU tar'
+  exit 1
+fi
+
+if $(ruby -e'require "java"'); then
+  # Good
+  echo 'Detected JRuby'
+else
+  echo 'Unable to release: make sure to use JRuby'
+  exit 1
+fi
+
+VERSION=`grep -E '<version>([0-9]+\.[0-9]+\.[0-9]+)</version>' pom.xml | sed 's/[\t \n]*<version>\(.*\)<\/version>[\t \n]*/\1/'`
+if [ "$VERSION" != "$(cat $PWD/VERSION)" ]; then
+  echo 'Unable to release: make sure the versions in pom.xml and VERSION match'
+  exit 1
+fi
+
+echo 'Cleaning up'
+rake killbill:clean ; rake build
+
+echo 'Pushing the gem to Rubygems'
+rake release
+
+echo 'Building artifact'
+rake killbill:package
+
+ARTIFACT="$PWD/pkg/killbill-braintree_blue-$VERSION.tar.gz"
+echo "Pushing $ARTIFACT to Maven Central"
+mvn gpg:sign-and-deploy-file \
+    -DgroupId=org.kill-bill.billing.plugin.ruby \
+    -DartifactId=braintree_blue-plugin \
+    -Dversion=$VERSION \
+    -Dpackaging=tar.gz \
+    -DrepositoryId=ossrh-releases \
+    -Durl=https://oss.sonatype.org/service/local/staging/deploy/maven2/ \
+    -Dfile=$ARTIFACT \
+    -DpomFile=pom.xml

data/spec/braintree_blue/base_plugin_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe Killbill::BraintreeBlue::PaymentPlugin do
+  before(:each) do
+    Dir.mktmpdir do |dir|
+      file = File.new(File.join(dir, 'braintree_blue.yml'), "w+")
+      file.write(<<-eos)
+:braintree_blue:
+  :test: true
+# As defined by spec_helper.rb
+:database:
+  :adapter: 'sqlite3'
+  :database: 'test.db'
+      eos
+      file.close
+
+      @plugin              = Killbill::BraintreeBlue::PaymentPlugin.new
+      @plugin.logger       = Logger.new(STDOUT)
+      @plugin.logger.level = Logger::INFO
+      @plugin.conf_dir     = File.dirname(file)
+      @plugin.kb_apis      = Killbill::Plugin::KillbillApi.new('braintree_blue', {})
+
+      # 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
+
+  it 'should generate forms correctly' do
+=begin
+    kb_account_id = SecureRandom.uuid
+    kb_tenant_id  = SecureRandom.uuid
+    context       = @plugin.kb_apis.create_context(kb_tenant_id)
+    fields        = @plugin.hash_to_properties({
+                                                   :order_id => '1234',
+                                                   :amount   => 10
+                                               })
+    form          = @plugin.build_form_descriptor kb_account_id, fields, [], context
+
+    form.kb_account_id.should == kb_account_id
+    form.form_method.should == 'POST'
+    form.form_url.should == 'https://braintree_blue.com'
+
+    form_fields = @plugin.properties_to_hash(form.form_fields)
+=end
+  end
+
+  it 'should receive notifications correctly' do
+=begin
+
+    description    = 'description'
+
+    kb_tenant_id = SecureRandom.uuid
+    context      = @plugin.kb_apis.create_context(kb_tenant_id)
+    properties   = @plugin.hash_to_properties({ :description => description })
+
+    notification    = ""
+    gw_notification = @plugin.process_notification notification, properties, context
+=end
+  end
+end

data/spec/braintree_blue/braintree_blue_payment_method_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe Killbill::BraintreeBlue::BraintreeBluePaymentMethod do
+  before :all do
+    Killbill::BraintreeBlue::BraintreeBluePaymentMethod.delete_all
+  end
+
+  it 'should search all fields' do
+    kb_tenant_id = '77-88-99-00'
+
+    do_search('foo', kb_tenant_id).size.should == 0
+
+    pm = Killbill::BraintreeBlue::BraintreeBluePaymentMethod.create :kb_account_id        => '11-22-33-44',
+                                                      :kb_payment_method_id => '55-66-77-88',
+                                                      :kb_tenant_id          => kb_tenant_id,
+                                                      :braintree_customer_id   => '123xka',
+                                                      :token                => '38102343',
+                                                      :cc_first_name        => 'ccFirstName',
+                                                      :cc_last_name         => 'ccLastName',
+                                                      :cc_type              => 'ccType',
+                                                      :cc_exp_month         => 10,
+                                                      :cc_exp_year          => 11,
+                                                      :cc_last_4            => 1234,
+                                                      :address1             => 'address1',
+                                                      :address2             => 'address2',
+                                                      :city                 => 'city',
+                                                      :state                => 'state',
+                                                      :zip                  => 'zip',
+                                                      :country              => 'country'
+
+    do_search('foo', kb_tenant_id).size.should == 0
+    do_search(pm.token, kb_tenant_id).size.should == 1
+    do_search('ccType', kb_tenant_id).size.should == 1
+    # Exact match only for cc_last_4
+    do_search('123', kb_tenant_id).size.should == 0
+    do_search('1234', kb_tenant_id).size.should == 1
+    # Test partial match
+    do_search('address', kb_tenant_id).size.should == 1
+    do_search('Name', kb_tenant_id).size.should == 1
+
+    pm2 = Killbill::BraintreeBlue::BraintreeBluePaymentMethod.create :kb_account_id        => '22-33-44-55',
+                                                       :kb_payment_method_id => '66-77-88-99',
+                                                       :kb_tenant_id          => kb_tenant_id,
+                                                       :braintree_customer_id   => '123xka',
+                                                       :token                => '49384029302',
+                                                       :cc_first_name        => 'ccFirstName',
+                                                       :cc_last_name         => 'ccLastName',
+                                                       :cc_type              => 'ccType',
+                                                       :cc_exp_month         => 10,
+                                                       :cc_exp_year          => 11,
+                                                       :cc_last_4            => 1234,
+                                                       :address1             => 'address1',
+                                                       :address2             => 'address2',
+                                                       :city                 => 'city',
+                                                       :state                => 'state',
+                                                       :zip                  => 'zip',
+                                                       :country              => 'country'
+
+    do_search('foo', kb_tenant_id).size.should == 0
+    do_search(pm.token, kb_tenant_id).size.should == 1
+    do_search(pm2.token, kb_tenant_id).size.should == 1
+    do_search('ccType', kb_tenant_id).size.should == 2
+    # Exact match only for cc_last_4
+    do_search('123', kb_tenant_id).size.should == 0
+    do_search('1234', kb_tenant_id).size.should == 2
+    # Test partial match
+    do_search('cc', kb_tenant_id).size.should == 2
+    do_search('address', kb_tenant_id).size.should == 2
+    do_search('Name', kb_tenant_id).size.should == 2
+  end
+
+  private
+
+  def do_search(search_key, kb_tenant_id)
+    pagination = Killbill::BraintreeBlue::BraintreeBluePaymentMethod.search(search_key, kb_tenant_id)
+    pagination.current_offset.should == 0
+    results = pagination.iterator.to_a
+    pagination.total_nb_records.should == results.size
+    results
+  end
+end