killbill-litle 1.2.1 → 1.3.0

data/Jarfile

@@ -1,3 +1,5 @@
-jar 'com.ning.billing:killbill-api', '0.1.80'
-jar 'com.ning.billing:killbill-util:tests', '0.1.80'
+jar 'com.ning.billing:killbill-api', '0.3.0'
+jar 'com.ning.billing.plugin:killbill-plugin-api-notification', '0.2.4'
+jar 'com.ning.billing.plugin:killbill-plugin-api-payment', '0.2.4'
+jar 'com.ning.billing:killbill-util:tests', '0.2.6-SNAPSHOT'
 jar 'javax.servlet:javax.servlet-api', '3.0.1'

data/NEWS

@@ -0,0 +1,2 @@
+1.3.0
+    Update to killbill 1.1.2

data/VERSION

@@ -1 +1 @@
-1.2.1
+1.3.0

data/killbill-litle.gemspec

@@ -22,7 +22,7 @@ Gem::Specification.new do |s|
 
   s.rdoc_options << '--exclude' << '.'
 
-  s.add_dependency 'killbill', '~> 1.0.19'
+  s.add_dependency 'killbill', '~> 1.1.2'
   s.add_dependency 'activemerchant', '~> 2.0.0'
   s.add_dependency 'activerecord', '~> 3.2.1'
   s.add_dependency 'sinatra', '~> 1.3.4'

data/lib/litle/api.rb

@@ -13,15 +13,15 @@ module Killbill::Litle
       ActiveRecord::Base.connection.close
     end
 
-    def process_payment(kb_account_id, kb_payment_id, kb_payment_method_id, amount_in_cents, currency, call_context, options = {})
+    def process_payment(kb_account_id, kb_payment_id, kb_payment_method_id, amount_in_cents, currency, call_context = nil, options = {})
       # If the payment was already made, just return the status
       # TODO Should we set the Litle Id field to check for dups (https://www.litle.com/mc-secure/DupeChecking_V1.2.pdf)?
-      litle_transaction = LitleTransaction.from_kb_payment_id(kb_payment_id.to_s) rescue nil
+      litle_transaction = LitleTransaction.from_kb_payment_id(kb_payment_id) rescue nil
       return litle_transaction.litle_response.to_payment_response unless litle_transaction.nil?
 
       # Required argument
       # Note! The field is limited to 25 chars, so we convert the UUID (in hex) to base64
-      options[:order_id] ||= Utils.compact_uuid kb_payment_id.to_s
+      options[:order_id] ||= Utils.compact_uuid kb_payment_id
 
       # Set a default report group
       options[:merchant] ||= report_group_for_currency(currency)
@@ -36,17 +36,17 @@ module Killbill::Litle
       response.to_payment_response
     end
 
-    def get_payment_info(kb_account_id, kb_payment_id, tenant_context, options = {})
+    def get_payment_info(kb_account_id, kb_payment_id, tenant_context = nil, options = {})
       # We assume the payment is immutable in Litle and only look at our tables since there
       # doesn't seem to be a Litle API to fetch details for a given transaction.
       # TODO How can we support Authorization/Sale Recycling?
-      litle_transaction = LitleTransaction.from_kb_payment_id(kb_payment_id.to_s)
+      litle_transaction = LitleTransaction.from_kb_payment_id(kb_payment_id)
 
       litle_transaction.litle_response.to_payment_response
     end
 
-    def process_refund(kb_account_id, kb_payment_id, amount_in_cents, currency, call_context, options = {})
-      litle_transaction = LitleTransaction.find_candidate_transaction_for_refund(kb_payment_id.to_s, amount_in_cents)
+    def process_refund(kb_account_id, kb_payment_id, amount_in_cents, currency, call_context = nil, options = {})
+      litle_transaction = LitleTransaction.find_candidate_transaction_for_refund(kb_payment_id, amount_in_cents)
 
       # Set a default report group
       options[:merchant] ||= report_group_for_currency(currency)
@@ -59,15 +59,15 @@ module Killbill::Litle
       response.to_refund_response
     end
 
-    def get_refund_info(kb_account_id, kb_payment_id, tenant_context, options = {})
+    def get_refund_info(kb_account_id, kb_payment_id, tenant_context = nil, options = {})
       # We assume the refund is immutable in Litle and only look at our tables since there
       # doesn't seem to be a Litle API to fetch details for a given transaction.
-      litle_transaction = LitleTransaction.refund_from_kb_payment_id(kb_payment_id.to_s)
+      litle_transaction = LitleTransaction.refund_from_kb_payment_id(kb_payment_id)
 
       litle_transaction.litle_response.to_refund_response
     end
 
-    def add_payment_method(kb_account_id, kb_payment_method_id, payment_method_props, set_default, call_context, options = {})
+    def add_payment_method(kb_account_id, kb_payment_method_id, payment_method_props, set_default, call_context = nil, options = {})
       # Set a default report group
       options[:merchant] ||= report_group_for_account(kb_account_id)
 
@@ -80,8 +80,8 @@ module Killbill::Litle
       response = save_response_and_transaction litle_response, :add_payment_method
 
       if response.success
-        LitlePaymentMethod.create :kb_account_id => kb_account_id.to_s,
-                                  :kb_payment_method_id => kb_payment_method_id.to_s,
+        LitlePaymentMethod.create :kb_account_id => kb_account_id,
+                                  :kb_payment_method_id => kb_payment_method_id,
                                   :litle_token => response.litle_token,
                                   :cc_first_name => find_value_from_payment_method_props(payment_method_props, 'ccFirstName'),
                                   :cc_last_name => find_value_from_payment_method_props(payment_method_props, 'ccLastName'),
@@ -100,26 +100,26 @@ module Killbill::Litle
       end
     end
 
-    def delete_payment_method(kb_account_id, kb_payment_method_id, call_context, options = {})
-      LitlePaymentMethod.mark_as_deleted! kb_payment_method_id.to_s
+    def delete_payment_method(kb_account_id, kb_payment_method_id, call_context = nil, options = {})
+      LitlePaymentMethod.mark_as_deleted! kb_payment_method_id
     end
 
-    def get_payment_method_detail(kb_account_id, kb_payment_method_id, tenant_context, options = {})
-      LitlePaymentMethod.from_kb_payment_method_id(kb_payment_method_id.to_s).to_payment_method_response
+    def get_payment_method_detail(kb_account_id, kb_payment_method_id, tenant_context = nil, options = {})
+      LitlePaymentMethod.from_kb_payment_method_id(kb_payment_method_id).to_payment_method_response
     end
 
-    def set_default_payment_method(kb_account_id, kb_payment_method_id, call_context, options = {})
+    def set_default_payment_method(kb_account_id, kb_payment_method_id, call_context = nil, options = {})
       # No-op
     end
 
-    def get_payment_methods(kb_account_id, refresh_from_gateway, call_context, options = {})
-      LitlePaymentMethod.from_kb_account_id(kb_account_id.to_s).collect { |pm| pm.to_payment_method_info_response }
+    def get_payment_methods(kb_account_id, refresh_from_gateway = false, call_context = nil, options = {})
+      LitlePaymentMethod.from_kb_account_id(kb_account_id).collect { |pm| pm.to_payment_method_info_response }
     end
 
     def reset_payment_methods(kb_account_id, payment_methods)
       return if payment_methods.nil?
 
-      litle_pms = LitlePaymentMethod.from_kb_account_id(kb_account_id.to_s)
+      litle_pms = LitlePaymentMethod.from_kb_account_id(kb_account_id)
 
       payment_methods.delete_if do |payment_method_info_plugin|
         should_be_deleted = false
@@ -127,16 +127,16 @@ module Killbill::Litle
           # Do litle_pm and payment_method_info_plugin represent the same Litle payment method?
           if litle_pm.external_payment_method_id == payment_method_info_plugin.external_payment_method_id
             # Do we already have a kb_payment_method_id?
-            if litle_pm.kb_payment_method_id == payment_method_info_plugin.payment_method_id.to_s
+            if litle_pm.kb_payment_method_id == payment_method_info_plugin.payment_method_id
               should_be_deleted = true
               break
             elsif litle_pm.kb_payment_method_id.nil?
               # We didn't have the kb_payment_method_id - update it
-              litle_pm.kb_payment_method_id = payment_method_info_plugin.payment_method_id.to_s
+              litle_pm.kb_payment_method_id = payment_method_info_plugin.payment_method_id
               should_be_deleted = litle_pm.save
               break
-            # Otherwise the same token points to 2 different kb_payment_method_id. This should never happen,
-            # but we cowardly will insert a second row below
+              # Otherwise the same token points to 2 different kb_payment_method_id. This should never happen,
+              # but we cowardly will insert a second row below
             end
           end
         end
@@ -146,8 +146,8 @@ module Killbill::Litle
 
       # The remaining elements in payment_methods are not in our table (this should never happen?!)
       payment_methods.each do |payment_method_info_plugin|
-        LitlePaymentMethod.create :kb_account_id => payment_method_info_plugin.account_id.to_s,
-                                  :kb_payment_method_id => payment_method_info_plugin.payment_method_id.to_s,
+        LitlePaymentMethod.create :kb_account_id => payment_method_info_plugin.account_id,
+                                  :kb_payment_method_id => payment_method_info_plugin.payment_method_id,
                                   :litle_token => payment_method_info_plugin.external_payment_method_id
       end
     end
@@ -162,35 +162,35 @@ module Killbill::Litle
     def report_group_for_account(kb_account_id)
       currency = account_currency(kb_account_id)
       report_group_for_currency(currency)
-    rescue Killbill::Plugin::JKillbillApi::APINotAvailableError
-      "Default Report Group"
+    rescue => e
+      'Default Report Group'
     end
 
     def account_currency(kb_account_id)
-      account = @kb_apis.get_account_by_id(kb_account_id)
+      account = @kb_apis.account_user_api.get_account_by_id(kb_account_id, @kb_apis.create_context)
       account.currency
     end
 
     def report_group_for_currency(currency)
-      "Report Group for #{currency.respond_to?(:enum) ? currency.enum : currency.to_s}"
+      "Report Group for #{currency.to_s}"
     end
 
     def get_token(kb_payment_method_id)
-      LitlePaymentMethod.from_kb_payment_method_id(kb_payment_method_id.to_s).litle_token
+      LitlePaymentMethod.from_kb_payment_method_id(kb_payment_method_id).litle_token
     end
 
     def save_response_and_transaction(litle_response, api_call, kb_payment_id=nil, amount_in_cents=0)
       @logger.warn "Unsuccessful #{api_call}: #{litle_response.message}" unless litle_response.success?
 
       # Save the response to our logs
-      response = LitleResponse.from_response(api_call, kb_payment_id.to_s, litle_response)
+      response = LitleResponse.from_response(api_call, kb_payment_id, litle_response)
       response.save!
 
       if response.success and !kb_payment_id.blank? and !response.litle_txn_id.blank?
         # Record the transaction
         transaction = response.create_litle_transaction!(:amount_in_cents => amount_in_cents,
                                                          :api_call => api_call,
-                                                         :kb_payment_id => kb_payment_id.to_s,
+                                                         :kb_payment_id => kb_payment_id,
                                                          :litle_txn_id => response.litle_txn_id)
         @logger.debug "Recorded transaction: #{transaction.inspect}"
       end

data/lib/litle/config/configuration.rb

@@ -31,7 +31,7 @@ module Killbill::Litle
   end
 
   def self.gateway_for_currency(currency)
-    currency_sym = currency.respond_to?(:enum) ? currency.enum.upcase.to_sym : currency.to_s.upcase.to_sym
+    currency_sym = currency.to_s.upcase.to_sym
     gateway = @@gateways[currency_sym]
     raise "Gateway for #{currency} not configured!" if gateway.nil?
     gateway

data/lib/litle/models/litle_payment_method.rb

@@ -37,28 +37,35 @@ module Killbill::Litle
 
     def to_payment_method_response
       properties = []
-      properties << Killbill::Plugin::Model::PaymentMethodKVInfo.new(false, 'token', litle_token)
+      properties << create_pm_kv_info('token', litle_token)
 
-      Killbill::Plugin::Model::PaymentMethodPlugin.new(external_payment_method_id,
-                                                       is_default,
-                                                       properties,
-                                                       nil,
-                                                       'CreditCard',
-                                                       cc_name,
-                                                       cc_type,
-                                                       cc_exp_month,
-                                                       cc_exp_year,
-                                                       cc_last_4,
-                                                       address1,
-                                                       address2,
-                                                       city,
-                                                       state,
-                                                       zip,
-                                                       country)
+      pm_plugin = Killbill::Plugin::Model::PaymentMethodPlugin.new
+      pm_plugin.external_payment_method_id = external_payment_method_id
+      pm_plugin.is_default_payment_method = is_default
+      pm_plugin.properties = properties
+      pm_plugin.type = 'CreditCard'
+      pm_plugin.cc_name = cc_name
+      pm_plugin.cc_type = cc_type
+      pm_plugin.cc_expiration_month = cc_exp_month
+      pm_plugin.cc_expiration_year = cc_exp_year
+      pm_plugin.cc_last4 = cc_last_4
+      pm_plugin.address1 = address1
+      pm_plugin.address2 = address2
+      pm_plugin.city = city
+      pm_plugin.state = state
+      pm_plugin.zip = zip
+      pm_plugin.country = country
+
+      pm_plugin
     end
 
     def to_payment_method_info_response
-      Killbill::Plugin::Model::PaymentMethodInfoPlugin.new(kb_account_id, kb_payment_method_id, is_default, external_payment_method_id)
+      pm_info_plugin = Killbill::Plugin::Model::PaymentMethodInfoPlugin.new
+      pm_info_plugin.account_id = kb_account_id
+      pm_info_plugin.payment_method_id = kb_payment_method_id
+      pm_info_plugin.is_default = is_default
+      pm_info_plugin.external_payment_method_id = external_payment_method_id
+      pm_info_plugin
     end
 
     def is_default
@@ -77,5 +84,14 @@ module Killbill::Litle
         nil
       end
     end
+
+    private
+
+    def create_pm_kv_info(key, value)
+      prop = Killbill::Plugin::Model::PaymentMethodKVInfo.new
+      prop.key = key
+      prop.value = value
+      prop
+    end
   end
 end

data/lib/litle/models/litle_response.rb

@@ -47,33 +47,33 @@ module Killbill::Litle
 
     def self.from_response(api_call, kb_payment_id, response)
       LitleResponse.new({
-                          :api_call => api_call,
-                          :kb_payment_id => kb_payment_id,
-                          :message => response.message,
-                          :authorization => response.authorization,
-                          :fraud_review => response.fraud_review?,
-                          :test => response.test?,
-                          :params_litleonelineresponse_message => extract(response, "litleOnlineResponse", "message"),
-                          :params_litleonelineresponse_response => extract(response, "litleOnlineResponse", "response"),
-                          :params_litleonelineresponse_version => extract(response, "litleOnlineResponse", "version"),
-                          :params_litleonelineresponse_xmlns => extract(response, "litleOnlineResponse", "xmlns"),
-                          :params_litleonelineresponse_saleresponse_customer_id => extract(response, "litleOnlineResponse", "saleResponse", "customerId"),
-                          :params_litleonelineresponse_saleresponse_id => extract(response, "litleOnlineResponse", "saleResponse", "id"),
-                          :params_litleonelineresponse_saleresponse_report_group => extract(response, "litleOnlineResponse", "saleResponse", "reportGroup"),
-                          :params_litleonelineresponse_saleresponse_litle_txn_id => extract(response, "litleOnlineResponse", "saleResponse", "litleTxnId"),
-                          :params_litleonelineresponse_saleresponse_order_id => extract(response, "litleOnlineResponse", "saleResponse", "orderId"),
-                          :params_litleonelineresponse_saleresponse_response => extract(response, "litleOnlineResponse", "saleResponse", "response"),
-                          :params_litleonelineresponse_saleresponse_response_time => extract(response, "litleOnlineResponse", "saleResponse", "responseTime"),
-                          :params_litleonelineresponse_saleresponse_message => extract(response, "litleOnlineResponse", "saleResponse", "message"),
-                          :params_litleonelineresponse_saleresponse_auth_code => extract(response, "litleOnlineResponse", "saleResponse", "authCode"),
-                          :avs_result_code => response.avs_result.kind_of?(ActiveMerchant::Billing::AVSResult) ? response.avs_result.code : response.avs_result['code'],
-                          :avs_result_message => response.avs_result.kind_of?(ActiveMerchant::Billing::AVSResult) ? response.avs_result.message : response.avs_result['message'],
-                          :avs_result_street_match => response.avs_result.kind_of?(ActiveMerchant::Billing::AVSResult) ? response.avs_result.street_match : response.avs_result['street_match'],
-                          :avs_result_postal_match => response.avs_result.kind_of?(ActiveMerchant::Billing::AVSResult) ? response.avs_result.postal_match : response.avs_result['postal_match'],
-                          :cvv_result_code => response.cvv_result.kind_of?(ActiveMerchant::Billing::CVVResult) ? response.cvv_result.code : response.cvv_result['code'],
-                          :cvv_result_message => response.cvv_result.kind_of?(ActiveMerchant::Billing::CVVResult) ? response.cvv_result.message : response.cvv_result['message'],
-                          :success => response.success?
-                       })
+                            :api_call => api_call,
+                            :kb_payment_id => kb_payment_id,
+                            :message => response.message,
+                            :authorization => response.authorization,
+                            :fraud_review => response.fraud_review?,
+                            :test => response.test?,
+                            :params_litleonelineresponse_message => extract(response, "litleOnlineResponse", "message"),
+                            :params_litleonelineresponse_response => extract(response, "litleOnlineResponse", "response"),
+                            :params_litleonelineresponse_version => extract(response, "litleOnlineResponse", "version"),
+                            :params_litleonelineresponse_xmlns => extract(response, "litleOnlineResponse", "xmlns"),
+                            :params_litleonelineresponse_saleresponse_customer_id => extract(response, "litleOnlineResponse", "saleResponse", "customerId"),
+                            :params_litleonelineresponse_saleresponse_id => extract(response, "litleOnlineResponse", "saleResponse", "id"),
+                            :params_litleonelineresponse_saleresponse_report_group => extract(response, "litleOnlineResponse", "saleResponse", "reportGroup"),
+                            :params_litleonelineresponse_saleresponse_litle_txn_id => extract(response, "litleOnlineResponse", "saleResponse", "litleTxnId"),
+                            :params_litleonelineresponse_saleresponse_order_id => extract(response, "litleOnlineResponse", "saleResponse", "orderId"),
+                            :params_litleonelineresponse_saleresponse_response => extract(response, "litleOnlineResponse", "saleResponse", "response"),
+                            :params_litleonelineresponse_saleresponse_response_time => extract(response, "litleOnlineResponse", "saleResponse", "responseTime"),
+                            :params_litleonelineresponse_saleresponse_message => extract(response, "litleOnlineResponse", "saleResponse", "message"),
+                            :params_litleonelineresponse_saleresponse_auth_code => extract(response, "litleOnlineResponse", "saleResponse", "authCode"),
+                            :avs_result_code => response.avs_result.kind_of?(ActiveMerchant::Billing::AVSResult) ? response.avs_result.code : response.avs_result['code'],
+                            :avs_result_message => response.avs_result.kind_of?(ActiveMerchant::Billing::AVSResult) ? response.avs_result.message : response.avs_result['message'],
+                            :avs_result_street_match => response.avs_result.kind_of?(ActiveMerchant::Billing::AVSResult) ? response.avs_result.street_match : response.avs_result['street_match'],
+                            :avs_result_postal_match => response.avs_result.kind_of?(ActiveMerchant::Billing::AVSResult) ? response.avs_result.postal_match : response.avs_result['postal_match'],
+                            :cvv_result_code => response.cvv_result.kind_of?(ActiveMerchant::Billing::CVVResult) ? response.cvv_result.code : response.cvv_result['code'],
+                            :cvv_result_message => response.cvv_result.kind_of?(ActiveMerchant::Billing::CVVResult) ? response.cvv_result.message : response.cvv_result['message'],
+                            :success => response.success?
+                        })
     end
 
     def to_payment_response
@@ -104,11 +104,26 @@ module Killbill::Litle
       gateway_error_code = params_litleonelineresponse_saleresponse_response
 
       if type == :payment
-        status = success ? Killbill::Plugin::Model::PaymentPluginStatus.new(:PROCESSED) : Killbill::Plugin::Model::PaymentPluginStatus.new(:ERROR)
-        Killbill::Plugin::Model::PaymentInfoPlugin.new(amount_in_cents, created_date, effective_date, status, gateway_error, gateway_error_code, first_payment_reference_id, second_payment_reference_id)
+        p_info_plugin = Killbill::Plugin::Model::PaymentInfoPlugin.new
+        p_info_plugin.amount = amount_in_cents
+        p_info_plugin.created_date = created_date
+        p_info_plugin.effective_date = effective_date
+        p_info_plugin.status = (success ? :PROCESSED : :ERROR)
+        p_info_plugin.gateway_error = gateway_error
+        p_info_plugin.gateway_error_code = gateway_error_code
+        p_info_plugin.first_payment_reference_id = first_payment_reference_id
+        p_info_plugin.second_payment_reference_id = second_payment_reference_id
+        p_info_plugin
       else
-        status = success ? Killbill::Plugin::Model::RefundPluginStatus.new(:PROCESSED) : Killbill::Plugin::Model::RefundPluginStatus.new(:ERROR)
-        Killbill::Plugin::Model::RefundInfoPlugin.new(amount_in_cents, created_date, effective_date, status, gateway_error, gateway_error_code, first_payment_reference_id)
+        r_info_plugin = Killbill::Plugin::Model::RefundInfoPlugin.new
+        r_info_plugin.amount = amount_in_cents
+        r_info_plugin.created_date = created_date
+        r_info_plugin.effective_date = effective_date
+        r_info_plugin.status = (success ? :PROCESSED : :ERROR)
+        r_info_plugin.gateway_error = gateway_error
+        r_info_plugin.gateway_error_code = gateway_error_code
+        r_info_plugin.reference_id = first_payment_reference_id
+        r_info_plugin
       end
     end
 

data/lib/litle/private_api.rb

@@ -14,11 +14,10 @@ module Killbill::Litle
       end
     end
 
-    def get_currency(kb_account_id_s)
-      kb_account_id = Killbill::Plugin::Model::UUID.new(kb_account_id_s)
+    def get_currency(kb_account_id)
       account = kb_apis.get_account_by_id(kb_account_id)
-      account.currency.enum
-    rescue Killbill::Plugin::JKillbillApi::APINotAvailableError
+      account.currency
+    rescue => e
       'USD'
     end
 

data/pom.xml

@@ -25,7 +25,7 @@
     <groupId>com.ning.killbill.ruby</groupId>
     <artifactId>litle-plugin</artifactId>
     <packaging>pom</packaging>
-    <version>1.2.1</version>
+    <version>1.3.0</version>
     <name>litle-plugin</name>
     <url>http://github.com/killbill/killbill-litle-plugin</url>
     <description>Plugin for accessing Litle as a payment gateway</description>

data/spec/litle/base_plugin_spec.rb

@@ -32,7 +32,7 @@ describe Killbill::Litle::PaymentPlugin do
   it 'should reset payment methods' do
     kb_account_id = '129384'
 
-    @plugin.get_payment_methods(kb_account_id, false, nil).size.should == 0
+    @plugin.get_payment_methods(kb_account_id).size.should == 0
     verify_pms kb_account_id, 0
 
     # Create a pm with a kb_payment_method_id
@@ -44,19 +44,19 @@ describe Killbill::Litle::PaymentPlugin do
     # Add some in KillBill and reset
     payment_methods = []
     # Random order... Shouldn't matter...
-    payment_methods << Killbill::Plugin::Model::PaymentMethodInfoPlugin.new(kb_account_id, 'kb-3', false, 'litle-3')
-    payment_methods << Killbill::Plugin::Model::PaymentMethodInfoPlugin.new(kb_account_id, 'kb-2', false, 'litle-2')
-    payment_methods << Killbill::Plugin::Model::PaymentMethodInfoPlugin.new(kb_account_id, 'kb-4', false, 'litle-4')
+    payment_methods << create_pm_info_plugin(kb_account_id, 'kb-3', false, 'litle-3')
+    payment_methods << create_pm_info_plugin(kb_account_id, 'kb-2', false, 'litle-2')
+    payment_methods << create_pm_info_plugin(kb_account_id, 'kb-4', false, 'litle-4')
     @plugin.reset_payment_methods kb_account_id, payment_methods
     verify_pms kb_account_id, 4
 
     # Add a payment method without a kb_payment_method_id
     Killbill::Litle::LitlePaymentMethod.create :kb_account_id => kb_account_id,
                                                :litle_token => 'litle-5'
-    @plugin.get_payment_methods(kb_account_id, false, nil).size.should == 5
+    @plugin.get_payment_methods(kb_account_id).size.should == 5
 
     # Verify we can match it
-    payment_methods << Killbill::Plugin::Model::PaymentMethodInfoPlugin.new(kb_account_id, 'kb-5', false, 'litle-5')
+    payment_methods << create_pm_info_plugin(kb_account_id, 'kb-5', false, 'litle-5')
     @plugin.reset_payment_methods kb_account_id, payment_methods
     verify_pms kb_account_id, 5
 
@@ -66,7 +66,7 @@ describe Killbill::Litle::PaymentPlugin do
   private
 
   def verify_pms(kb_account_id, size)
-    pms = @plugin.get_payment_methods(kb_account_id, false, nil)
+    pms = @plugin.get_payment_methods(kb_account_id)
     pms.size.should == size
     pms.each do |pm|
       pm.account_id.should == kb_account_id
@@ -74,4 +74,13 @@ describe Killbill::Litle::PaymentPlugin do
       pm.external_payment_method_id.should == 'litle-' + pm.payment_method_id.split('-')[1]
     end
   end
+
+  def create_pm_info_plugin(kb_account_id, kb_payment_method_id, is_default, external_payment_method_id)
+    pm_info_plugin = Killbill::Plugin::Model::PaymentMethodInfoPlugin.new
+    pm_info_plugin.account_id = kb_account_id
+    pm_info_plugin.payment_method_id = kb_payment_method_id
+    pm_info_plugin.is_default = is_default
+    pm_info_plugin.external_payment_method_id = external_payment_method_id
+    pm_info_plugin
+  end
 end

data/spec/litle/integration_spec.rb

@@ -3,33 +3,30 @@ require 'logger'
 
 ActiveMerchant::Billing::Base.mode = :test
 
-class KillbillApiWithFakeGetAccountById < Killbill::Plugin::KillbillApi
+class FakeJavaUserAccountApi
+  attr_accessor :accounts
 
-  def initialize(japi_proxy)
-    super(japi_proxy)
+  def initialize
+    @accounts = []
   end
 
-  # Returns an account where we specify the currency for the report group
-  def get_account_by_id(id)
-    Killbill::Plugin::Model::Account.new(id, nil, nil, nil, nil, nil, 1, nil, 1, 'USD', nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, false, true)
+  def get_account_by_id(id, context)
+    @accounts.find { |account| account.id == id.to_s }
+  end
+
+  def get_account_by_key(external_key, context)
+    @accounts.find { |account| account.external_key == external_key.to_s }
   end
 end
 
 describe Killbill::Litle::PaymentPlugin do
   before(:each) do
-    @call_context = Killbill::Plugin::Model::CallContext.new(SecureRandom.uuid,
-                                                             'token',
-                                                             'rspec tester',
-                                                             'TEST',
-                                                             'user',
-                                                             'testing',
-                                                             'this is from a test',
-                                                             Time.now,
-                                                             Time.now)
-
     @plugin = Killbill::Litle::PaymentPlugin.new
-    kb_apis = KillbillApiWithFakeGetAccountById.new(nil)
-    @plugin.kb_apis = kb_apis
+
+    @account_api = FakeJavaUserAccountApi.new
+    svcs = {:account_user_api => @account_api}
+    @plugin.kb_apis = Killbill::Plugin::KillbillApi.new('litle', svcs)
+
     @plugin.logger = Logger.new(STDOUT)
     @plugin.conf_dir = File.expand_path(File.dirname(__FILE__) + '../../../')
     @plugin.start_plugin
@@ -39,49 +36,49 @@ describe Killbill::Litle::PaymentPlugin do
     @plugin.stop_plugin
   end
 
-  it "should be able to create and retrieve payment methods" do
+  it 'should be able to create and retrieve payment methods' do
     pm = create_payment_method
 
-    pms = @plugin.get_payment_methods(pm.kb_account_id, false, @call_context)
+    pms = @plugin.get_payment_methods(pm.kb_account_id)
     pms.size.should == 1
     pms[0].external_payment_method_id.should == pm.litle_token
 
-    pm_details = @plugin.get_payment_method_detail(pm.kb_account_id, pm.kb_payment_method_id, @call_context)
+    pm_details = @plugin.get_payment_method_detail(pm.kb_account_id, pm.kb_payment_method_id)
     pm_details.external_payment_method_id.should == pm.litle_token
 
-    @plugin.delete_payment_method(pm.kb_account_id, pm.kb_payment_method_id, @call_context)
+    @plugin.delete_payment_method(pm.kb_account_id, pm.kb_payment_method_id)
 
-    @plugin.get_payment_methods(pm.kb_account_id, false, @call_context).size.should == 0
-    lambda { @plugin.get_payment_method_detail(pm.kb_account_id, pm.kb_payment_method_id, @call_context) }.should raise_error RuntimeError
+    @plugin.get_payment_methods(pm.kb_account_id).size.should == 0
+    lambda { @plugin.get_payment_method_detail(pm.kb_account_id, pm.kb_payment_method_id) }.should raise_error RuntimeError
   end
 
-  it "should be able to charge and refund" do
+  it 'should be able to charge and refund' do
     pm = create_payment_method
     amount_in_cents = 10000
     currency = 'USD'
     kb_payment_id = SecureRandom.uuid
 
-    payment_response = @plugin.process_payment pm.kb_account_id, kb_payment_id, pm.kb_payment_method_id, amount_in_cents, currency, @call_context
+    payment_response = @plugin.process_payment pm.kb_account_id, kb_payment_id, pm.kb_payment_method_id, amount_in_cents, currency
     payment_response.amount.should == amount_in_cents
-    payment_response.status.should == Killbill::Plugin::Model::PaymentPluginStatus.new(:PROCESSED)
+    payment_response.status.should == :PROCESSED
 
     # Verify our table directly
     response = Killbill::Litle::LitleResponse.find_by_api_call_and_kb_payment_id :charge, kb_payment_id
     response.test.should be_true
     response.success.should be_true
-    response.message.should == "Approved"
+    response.message.should == 'Approved'
     response.params_litleonelineresponse_saleresponse_order_id.should == Killbill::Litle::Utils.compact_uuid(kb_payment_id)
 
-    payment_response = @plugin.get_payment_info pm.kb_account_id, kb_payment_id, @call_context
+    payment_response = @plugin.get_payment_info pm.kb_account_id, kb_payment_id
     payment_response.amount.should == amount_in_cents
-    payment_response.status.should == Killbill::Plugin::Model::PaymentPluginStatus.new(:PROCESSED)
+    payment_response.status.should == :PROCESSED
 
     # Check we cannot refund an amount greater than the original charge
-    lambda { @plugin.process_refund pm.kb_account_id, kb_payment_id, amount_in_cents + 1, currency, @call_context }.should raise_error RuntimeError
+    lambda { @plugin.process_refund pm.kb_account_id, kb_payment_id, amount_in_cents + 1, currency }.should raise_error RuntimeError
 
-    refund_response = @plugin.process_refund pm.kb_account_id, kb_payment_id, amount_in_cents, currency, @call_context
+    refund_response = @plugin.process_refund pm.kb_account_id, kb_payment_id, amount_in_cents, currency
     refund_response.amount.should == amount_in_cents
-    refund_response.status.should == Killbill::Plugin::Model::RefundPluginStatus.new(:PROCESSED)
+    refund_response.status.should == :PROCESSED
 
     # Verify our table directly
     response = Killbill::Litle::LitleResponse.find_by_api_call_and_kb_payment_id :refund, kb_payment_id
@@ -89,18 +86,18 @@ describe Killbill::Litle::PaymentPlugin do
     response.success.should be_true
 
     # Check we can retrieve the refund
-    refund_response = @plugin.get_refund_info pm.kb_account_id, kb_payment_id, @call_context
+    refund_response = @plugin.get_refund_info pm.kb_account_id, kb_payment_id
     # Apparently, Litle returns positive amounts for refunds
     refund_response.amount.should == amount_in_cents
-    refund_response.status.should == Killbill::Plugin::Model::PaymentPluginStatus.new(:PROCESSED)
+    refund_response.status.should == :PROCESSED
 
     # Make sure we can charge again the same payment method
     second_amount_in_cents = 29471
     second_kb_payment_id = SecureRandom.uuid
 
-    payment_response = @plugin.process_payment pm.kb_account_id, second_kb_payment_id, pm.kb_payment_method_id, second_amount_in_cents, currency, @call_context
+    payment_response = @plugin.process_payment pm.kb_account_id, second_kb_payment_id, pm.kb_payment_method_id, second_amount_in_cents, currency
     payment_response.amount.should == second_amount_in_cents
-    payment_response.status.should == Killbill::Plugin::Model::PaymentPluginStatus.new(:PROCESSED)
+    payment_response.status.should == :PROCESSED
   end
 
   private
@@ -109,6 +106,9 @@ describe Killbill::Litle::PaymentPlugin do
     kb_account_id = SecureRandom.uuid
     kb_payment_method_id = SecureRandom.uuid
 
+    # Create a new account
+    create_kb_account kb_account_id
+
     # Generate a token in Litle
     paypage_registration_id = '123456789012345678901324567890abcdefghi'
     cc_first_name = 'John'
@@ -125,22 +125,23 @@ describe Killbill::Litle::PaymentPlugin do
     country = 'IFP'
 
     properties = []
-    properties << Killbill::Plugin::Model::PaymentMethodKVInfo.new(false, 'paypageRegistrationId', paypage_registration_id)
-    properties << Killbill::Plugin::Model::PaymentMethodKVInfo.new(false, 'ccFirstName', cc_first_name)
-    properties << Killbill::Plugin::Model::PaymentMethodKVInfo.new(false, 'ccLastName', cc_last_name)
-    properties << Killbill::Plugin::Model::PaymentMethodKVInfo.new(false, 'ccType', cc_type)
-    properties << Killbill::Plugin::Model::PaymentMethodKVInfo.new(false, 'ccExpMonth', cc_exp_month)
-    properties << Killbill::Plugin::Model::PaymentMethodKVInfo.new(false, 'ccExpYear', cc_exp_year)
-    properties << Killbill::Plugin::Model::PaymentMethodKVInfo.new(false, 'ccLast4', cc_last_4)
-    properties << Killbill::Plugin::Model::PaymentMethodKVInfo.new(false, 'address1', address1)
-    properties << Killbill::Plugin::Model::PaymentMethodKVInfo.new(false, 'address2', address2)
-    properties << Killbill::Plugin::Model::PaymentMethodKVInfo.new(false, 'city', city)
-    properties << Killbill::Plugin::Model::PaymentMethodKVInfo.new(false, 'state', state)
-    properties << Killbill::Plugin::Model::PaymentMethodKVInfo.new(false, 'zip', zip)
-    properties << Killbill::Plugin::Model::PaymentMethodKVInfo.new(false, 'country', country)
-
-    info = Killbill::Plugin::Model::PaymentMethodPlugin.new nil, nil, properties, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil
-    payment_method = @plugin.add_payment_method(kb_account_id, kb_payment_method_id, info, true, @call_context)
+    properties << create_pm_kv_info('paypageRegistrationId', paypage_registration_id)
+    properties << create_pm_kv_info('ccFirstName', cc_first_name)
+    properties << create_pm_kv_info('ccLastName', cc_last_name)
+    properties << create_pm_kv_info('ccType', cc_type)
+    properties << create_pm_kv_info('ccExpMonth', cc_exp_month)
+    properties << create_pm_kv_info('ccExpYear', cc_exp_year)
+    properties << create_pm_kv_info('ccLast4', cc_last_4)
+    properties << create_pm_kv_info('address1', address1)
+    properties << create_pm_kv_info('address2', address2)
+    properties << create_pm_kv_info('city', city)
+    properties << create_pm_kv_info('state', state)
+    properties << create_pm_kv_info('zip', zip)
+    properties << create_pm_kv_info('country', country)
+
+    info = Killbill::Plugin::Model::PaymentMethodPlugin.new
+    info.properties = properties
+    payment_method = @plugin.add_payment_method(kb_account_id, kb_payment_method_id, info, true)
 
     pm = Killbill::Litle::LitlePaymentMethod.from_kb_payment_method_id kb_payment_method_id
     pm.should == payment_method
@@ -162,4 +163,27 @@ describe Killbill::Litle::PaymentPlugin do
 
     pm
   end
+
+  def create_kb_account(kb_account_id)
+    external_key = Time.now.to_i.to_s + '-test'
+    email = external_key + '@tester.com'
+
+    account = Killbill::Plugin::Model::Account.new
+    account.id = kb_account_id
+    account.external_key = external_key
+    account.email = email
+    account.name = 'Integration spec'
+    account.currency = :USD
+
+    @account_api.accounts << account
+
+    return external_key, kb_account_id
+  end
+
+  def create_pm_kv_info(key, value)
+    prop = Killbill::Plugin::Model::PaymentMethodKVInfo.new
+    prop.key = key
+    prop.value = value
+    prop
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: killbill-litle
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.3.0
   prerelease:
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-06-14 00:00:00.000000000 Z
+date: 2013-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: killbill
@@ -17,13 +17,13 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.19
+        version: 1.1.2
     none: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.19
+        version: 1.1.2
     none: false
   prerelease: false
   type: :runtime
@@ -213,6 +213,7 @@ files:
 - ".travis.yml"
 - Gemfile
 - Jarfile
+- NEWS
 - README.md
 - Rakefile
 - VERSION