killbill 3.2.4 → 4.0.0

data/spec/killbill/helpers/private_payment_plugin_spec.rb

@@ -1,7 +1,4 @@
 require 'spec_helper'
-require 'spec/killbill/helpers/payment_method_spec'
-require 'spec/killbill/helpers/response_spec'
-require 'spec/killbill/helpers/transaction_spec'
 
 describe Killbill::Plugin::ActiveMerchant::PrivatePaymentPlugin do
 
@@ -54,28 +51,18 @@ Pay!
   private
 
   def setup_public_plugin
-    Dir.mktmpdir do |dir|
-      file = File.new(File.join(dir, 'test.yml'), 'w+')
-      file.write(<<-eos)
-:test:
-  :test: true
-# As defined by spec_helper.rb
-:database:
-  :adapter: 'sqlite3'
-  :database: 'test.db'
-      eos
-      file.close
-
+    with_plugin_yaml_config('test.yml', :test => { :test => true }) do |file|
       plugin          = ::Killbill::Plugin::ActiveMerchant::PaymentPlugin.new(Proc.new { |config| nil },
                                                                               :test,
                                                                               ::Killbill::Test::TestPaymentMethod,
                                                                               ::Killbill::Test::TestTransaction,
                                                                               ::Killbill::Test::TestResponse)
       payment_api     = ::Killbill::Plugin::ActiveMerchant::RSpec::FakeJavaPaymentApi.new
-      tenant_api = ::Killbill::Plugin::ActiveMerchant::RSpec::FakeJavaTenantUserApi.new({})
+      tenant_api      = ::Killbill::Plugin::ActiveMerchant::RSpec::FakeJavaTenantUserApi.new
 
       plugin.kb_apis  = ::Killbill::Plugin::KillbillApi.new('test', {:payment_api => payment_api, :tenant_user_api => tenant_api})
       plugin.logger   = Logger.new(STDOUT)
+      plugin.logger.level = ActiveRecord::Base.logger.level
       plugin.conf_dir = File.dirname(file)
       plugin.root     = File.dirname(file)
       # Start the plugin here - since the config file will be deleted

data/spec/killbill/helpers/response_spec.rb

@@ -1,17 +1,4 @@
 require 'spec_helper'
-require 'spec/killbill/helpers/transaction_spec'
-
-module Killbill #:nodoc:
-  module Test #:nodoc:
-    class TestResponse < ::Killbill::Plugin::ActiveMerchant::ActiveRecord::Response
-
-      self.table_name = 'test_responses'
-
-      has_one :test_transaction
-
-    end
-  end
-end
 
 describe Killbill::Plugin::ActiveMerchant::ActiveRecord::Response do
 
@@ -60,7 +47,7 @@ describe Killbill::Plugin::ActiveMerchant::ActiveRecord::Response do
     # No associated transaction
     ptip.amount.should be_nil
     ptip.currency.should be_nil
-    ptip.status.should == :PROCESSED
+    ptip.status.should == :UNDEFINED
     ptip.gateway_error.should == 'Message'
     ptip.gateway_error_code.should be_nil
     ptip.first_payment_reference_id.should be_nil
@@ -72,10 +59,13 @@ describe Killbill::Plugin::ActiveMerchant::ActiveRecord::Response do
     api_call                     = 'for debugging only'
     kb_account_id                = SecureRandom.uuid
     kb_payment_id                = SecureRandom.uuid
+    kb_payment_id2               = SecureRandom.uuid
+    kb_payment_id3               = SecureRandom.uuid
     kb_payment_transaction_id    = SecureRandom.uuid
     transaction_type             = :PURCHASE
     payment_processor_account_id = 'petit_poucet'
     kb_tenant_id                 = SecureRandom.uuid
+    kb_tenant_id2                = SecureRandom.uuid
     success_response             = ::ActiveMerchant::Billing::Response.new(true, 'Message', {}, {
         :authorization => SecureRandom.uuid,
         :avs_result    => ::ActiveMerchant::Billing::AVSResult.new(:code => 'P')
@@ -85,6 +75,7 @@ describe Killbill::Plugin::ActiveMerchant::ActiveRecord::Response do
         :avs_result    => ::ActiveMerchant::Billing::AVSResult.new(:code => 'P')
     })
 
+    # Successful response
     response, transaction = ::Killbill::Test::TestResponse.create_response_and_transaction('test', ::Killbill::Test::TestTransaction, api_call, kb_account_id, kb_payment_id, kb_payment_transaction_id, transaction_type, payment_processor_account_id, kb_tenant_id, success_response, 120, 'USD', {}, ::Killbill::Test::TestResponse)
     found_response        = ::Killbill::Test::TestResponse.find(response.id)
     found_response.should == response
@@ -93,17 +84,36 @@ describe Killbill::Plugin::ActiveMerchant::ActiveRecord::Response do
     found_transaction.should == transaction
     found_transaction.test_response.should == response
 
+    successful_responses = ::Killbill::Test::TestResponse.from_kb_payment_id(::Killbill::Test::TestTransaction, kb_payment_id, kb_tenant_id)
+    successful_responses.size.should == 1
+    successful_responses[0].should == response
+
+    # Unsuccessful response
     response, transaction = ::Killbill::Test::TestResponse.create_response_and_transaction('test', ::Killbill::Test::TestTransaction, api_call, kb_account_id, kb_payment_id, kb_payment_transaction_id, transaction_type, payment_processor_account_id, kb_tenant_id, failure_response, 120, 'USD', {}, ::Killbill::Test::TestResponse)
     transaction.should be_nil
     found_response = ::Killbill::Test::TestResponse.find(response.id)
     found_response.should == response
     found_response.test_transaction.should be_nil
 
+    ::Killbill::Test::TestResponse.from_kb_payment_id(::Killbill::Test::TestTransaction, kb_payment_id, kb_tenant_id).size == 2
+
+    # Another successful response for the same payment (different transaction)
+    ::Killbill::Test::TestResponse.create_response_and_transaction('test', ::Killbill::Test::TestTransaction, api_call, kb_account_id, kb_payment_id, SecureRandom.uuid, transaction_type, payment_processor_account_id, kb_tenant_id, success_response, 120, 'USD', {}, ::Killbill::Test::TestResponse)
+    ::Killbill::Test::TestResponse.from_kb_payment_id(::Killbill::Test::TestTransaction, kb_payment_id, kb_tenant_id).size == 3
+
+    # Add other successful responses
+    ::Killbill::Test::TestResponse.create_response_and_transaction('test', ::Killbill::Test::TestTransaction, api_call, kb_account_id, kb_payment_id2, SecureRandom.uuid, transaction_type, payment_processor_account_id, kb_tenant_id, success_response, 120, 'USD', {}, ::Killbill::Test::TestResponse)
+    ::Killbill::Test::TestResponse.create_response_and_transaction('test', ::Killbill::Test::TestTransaction, api_call, kb_account_id, kb_payment_id3, SecureRandom.uuid, transaction_type, payment_processor_account_id, kb_tenant_id2, success_response, 120, 'USD', {}, ::Killbill::Test::TestResponse)
+    ::Killbill::Test::TestResponse.from_kb_payment_id(::Killbill::Test::TestTransaction, kb_payment_id, kb_tenant_id).size == 3
+    ::Killbill::Test::TestResponse.from_kb_payment_id(::Killbill::Test::TestTransaction, kb_payment_id2, kb_tenant_id).size == 1
+    ::Killbill::Test::TestResponse.from_kb_payment_id(::Killbill::Test::TestTransaction, kb_payment_id3, kb_tenant_id2).size == 1
+
     # Lookup responses for kb_payment_id
     responses = ::Killbill::Test::TestResponse.responses_from_kb_payment_id(transaction_type, kb_payment_id, kb_tenant_id)
-    responses.size.should == 2
+    responses.size.should == 3
     responses[0].success.should be_true
     responses[1].success.should be_false
+    responses[2].success.should be_true
 
     # Lookup responses for kb_payment_transaction_id
     responses = ::Killbill::Test::TestResponse.responses_from_kb_payment_transaction_id(transaction_type, kb_payment_transaction_id, kb_tenant_id)
@@ -118,25 +128,30 @@ describe Killbill::Plugin::ActiveMerchant::ActiveRecord::Response do
     ::Killbill::Test::TestResponse.responses_from_kb_payment_transaction_id(:foo, kb_payment_transaction_id, kb_tenant_id).size.should == 0
     ::Killbill::Test::TestResponse.responses_from_kb_payment_transaction_id(transaction_type, SecureRandom.uuid, kb_tenant_id).size.should == 0
     ::Killbill::Test::TestResponse.responses_from_kb_payment_transaction_id(transaction_type, kb_payment_transaction_id, SecureRandom.uuid).size.should == 0
+    ::Killbill::Test::TestResponse.from_kb_payment_id(::Killbill::Test::TestTransaction, SecureRandom.uuid, kb_tenant_id).size.should == 0
+    ::Killbill::Test::TestResponse.from_kb_payment_id(::Killbill::Test::TestTransaction, kb_payment_id, SecureRandom.uuid).size.should == 0
+    ::Killbill::Test::TestResponse.from_kb_payment_id(::Killbill::Test::TestTransaction, kb_payment_id, kb_tenant_id2).size == 0
+    ::Killbill::Test::TestResponse.from_kb_payment_id(::Killbill::Test::TestTransaction, kb_payment_id2, kb_tenant_id2).size == 0
+    ::Killbill::Test::TestResponse.from_kb_payment_id(::Killbill::Test::TestTransaction, kb_payment_id3, kb_tenant_id).size == 0
   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\".\"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\""
+    expected_query = "SELECT COUNT(DISTINCT #{q('test_responses')}.#{q('id')}) FROM #{q('test_responses')}  WHERE ((((#{q('test_responses')}.#{q('kb_payment_id')} = '1234' OR #{q('test_responses')}.#{q('kb_payment_transaction_id')} = '1234') OR #{q('test_responses')}.#{q('message')} = '1234') OR #{q('test_responses')}.#{q('authorization')} = '1234') OR #{q('test_responses')}.#{q('fraud_review')} = '1234') AND #{q('test_responses')}.#{q('success')} = #{qtrue} AND #{q('test_responses')}.#{q('kb_tenant_id')} = '11-22-33'  ORDER BY #{q('test_responses')}.#{q('id')}"
     # Note that Kill Bill will pass a String, even for numeric types
     ::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\".\"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"
+    expected_query = "SELECT  DISTINCT #{q('test_responses')}.* FROM #{q('test_responses')}  WHERE ((((#{q('test_responses')}.#{q('kb_payment_id')} = '1234' OR #{q('test_responses')}.#{q('kb_payment_transaction_id')} = '1234') OR #{q('test_responses')}.#{q('message')} = '1234') OR #{q('test_responses')}.#{q('authorization')} = '1234') OR #{q('test_responses')}.#{q('fraud_review')} = '1234') AND #{q('test_responses')}.#{q('success')} = #{qtrue} AND #{q('test_responses')}.#{q('kb_tenant_id')} = '11-22-33'  ORDER BY #{q('test_responses')}.#{q('id')} LIMIT 10 OFFSET 0"
     # Note that Kill Bill will pass a String, even for numeric types
     ::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\".\"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\""
+    expected_query = "SELECT COUNT(DISTINCT #{q('test_responses')}.#{q('id')}) FROM #{q('test_responses')}  WHERE ((((#{q('test_responses')}.#{q('kb_payment_id')} = 'XXX' OR #{q('test_responses')}.#{q('kb_payment_transaction_id')} = 'XXX') OR #{q('test_responses')}.#{q('message')} = 'XXX') OR #{q('test_responses')}.#{q('authorization')} = 'XXX') OR #{q('test_responses')}.#{q('fraud_review')} = 'XXX') AND #{q('test_responses')}.#{q('success')} = #{qtrue} AND #{q('test_responses')}.#{q('kb_tenant_id')} = '11-22-33'  ORDER BY #{q('test_responses')}.#{q('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\".\"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"
+    expected_query = "SELECT  DISTINCT #{q('test_responses')}.* FROM #{q('test_responses')}  WHERE ((((#{q('test_responses')}.#{q('kb_payment_id')} = 'XXX' OR #{q('test_responses')}.#{q('kb_payment_transaction_id')} = 'XXX') OR #{q('test_responses')}.#{q('message')} = 'XXX') OR #{q('test_responses')}.#{q('authorization')} = 'XXX') OR #{q('test_responses')}.#{q('fraud_review')} = 'XXX') AND #{q('test_responses')}.#{q('success')} = #{qtrue} AND #{q('test_responses')}.#{q('kb_tenant_id')} = '11-22-33'  ORDER BY #{q('test_responses')}.#{q('id')} LIMIT 10 OFFSET 0"
     ::Killbill::Test::TestResponse.search_query('XXX', '11-22-33', 0, 10).to_sql.should == expected_query
   end
 
@@ -147,14 +162,18 @@ describe Killbill::Plugin::ActiveMerchant::ActiveRecord::Response do
                                                      :kb_account_id => '55-66-77-88',
                                                      :kb_payment_id => '11-22-33-44',
                                                      :kb_tenant_id  => '11-22-33',
-                                                     :success       => true
+                                                     :success       => true,
+                                                     :created_at    => Time.now.utc,
+                                                     :updated_at    => Time.now.utc
 
     # Not successful
     ignored2 = ::Killbill::Test::TestResponse.create :api_call      => 'charge',
                                                      :kb_account_id => '55-66-77-88',
                                                      :kb_payment_id => pm.kb_payment_id,
                                                      :kb_tenant_id  => '11-22-33',
-                                                     :success       => false
+                                                     :success       => false,
+                                                     :created_at    => Time.now.utc,
+                                                     :updated_at    => Time.now.utc
 
     do_search(pm.kb_payment_id).size.should == 1
 
@@ -162,11 +181,54 @@ describe Killbill::Plugin::ActiveMerchant::ActiveRecord::Response do
                                                 :kb_account_id => '55-66-77-88',
                                                 :kb_payment_id => pm.kb_payment_id,
                                                 :kb_tenant_id  => '11-22-33',
-                                                :success       => true
+                                                :success       => true,
+                                                :created_at    => Time.now.utc,
+                                                :updated_at    => Time.now.utc
 
     do_search(pm.kb_payment_id).size.should == 2
   end
 
+  context 'performance' do
+    require 'benchmark'
+
+    it 'creates the transaction association fast' 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
+      payment_processor_account_id = SecureRandom.uuid
+      kb_tenant_id = SecureRandom.uuid
+      success_response = ::ActiveMerchant::Billing::Response.new(true, 'Message')
+
+      # Warm-up the stack
+      response, transaction = ::Killbill::Test::TestResponse.create_response_and_transaction('test', ::Killbill::Test::TestTransaction, api_call, kb_account_id, kb_payment_id, kb_payment_transaction_id, transaction_type, payment_processor_account_id, kb_tenant_id, success_response, 120, 'USD', {}, ::Killbill::Test::TestResponse)
+
+      runs = (ENV['NB_RUNS'] || 2).to_i
+
+      time = Benchmark::Tms.new
+      Benchmark.bm do |x|
+        runs.times do |n|
+          time += x.report("run ##{n}:") do
+            response, transaction = ::Killbill::Test::TestResponse.create_response_and_transaction('test', ::Killbill::Test::TestTransaction, api_call, kb_account_id, kb_payment_id, kb_payment_transaction_id, transaction_type, payment_processor_account_id, kb_tenant_id, success_response, 120, 'USD', {}, ::Killbill::Test::TestResponse)
+
+            response.id.should_not be_nil
+            response.created_at.should_not be_nil
+            response.updated_at.should_not be_nil
+
+            transaction.id.should_not be_nil
+            transaction.created_at.should_not be_nil
+            transaction.updated_at.should_not be_nil
+            transaction.test_response_id.should == response.id
+          end
+        end
+      end
+
+      puts " total:#{time.to_s}"
+      puts "   avg:#{(time/runs).to_s}"
+    end
+  end
+
   private
 
   def do_search(search_key)
@@ -176,4 +238,12 @@ describe Killbill::Plugin::ActiveMerchant::ActiveRecord::Response do
     pagination.total_nb_records.should == results.size
     results
   end
+
+  def q(arg)
+    ::ActiveRecord::Base.connection.quote_column_name(arg)
+  end
+
+  def qtrue
+    ::ActiveRecord::Base.connection.quoted_true
+  end
 end

data/spec/killbill/helpers/streamy_result_set_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'spec/killbill/helpers/payment_method_spec'
 
 describe Killbill::Plugin::ActiveMerchant::ActiveRecord do
 
@@ -12,7 +11,9 @@ describe Killbill::Plugin::ActiveMerchant::ActiveRecord do
       ::Killbill::Test::TestPaymentMethod.create(:kb_account_id        => SecureRandom.uuid,
                                                  :kb_payment_method_id => SecureRandom.uuid,
                                                  :kb_tenant_id         => SecureRandom.uuid,
-                                                 :token                => SecureRandom.uuid)
+                                                 :token                => SecureRandom.uuid,
+                                                 :created_at           => Time.now.utc,
+                                                 :updated_at           => Time.now.utc)
     end
     ::Killbill::Test::TestPaymentMethod.count.should == 35
 

data/spec/killbill/helpers/test_payment_method.rb

@@ -0,0 +1,9 @@
+module Killbill #:nodoc:
+  module Test #:nodoc:
+    class TestPaymentMethod < ::Killbill::Plugin::ActiveMerchant::ActiveRecord::PaymentMethod
+
+      self.table_name = 'test_payment_methods'
+
+    end
+  end
+end

data/spec/killbill/helpers/test_response.rb

@@ -0,0 +1,11 @@
+module Killbill #:nodoc:
+  module Test #:nodoc:
+    class TestResponse < ::Killbill::Plugin::ActiveMerchant::ActiveRecord::Response
+
+      self.table_name = 'test_responses'
+
+      has_one :test_transaction
+
+    end
+  end
+end

data/spec/killbill/helpers/test_schema.rb

@@ -23,8 +23,8 @@ ActiveRecord::Schema.define(:version => 20140410153635) do
     t.string   "zip"
     t.string   "country"
     t.boolean  "is_deleted",             :null => false, :default => false
-    t.datetime "created_at",             :null => false
-    t.datetime "updated_at",             :null => false
+    t.datetime "created_at",             :null => false, :limit => 3
+    t.datetime "updated_at",             :null => false, :limit => 3
     t.string   "kb_account_id",          :null => false
     t.string   "kb_tenant_id",           :null => false
   end
@@ -42,8 +42,8 @@ ActiveRecord::Schema.define(:version => 20140410153635) do
     t.string   "txn_id"
     t.integer  "amount_in_cents"
     t.string   "currency"
-    t.datetime "created_at",                :null => false
-    t.datetime "updated_at",                :null => false
+    t.datetime "created_at",                :null => false, :limit => 3
+    t.datetime "updated_at",                :null => false, :limit => 3
     t.string   "kb_account_id",             :null => false
     t.string   "kb_tenant_id",              :null => false
   end
@@ -67,8 +67,8 @@ ActiveRecord::Schema.define(:version => 20140410153635) do
     t.string   "cvv_result_code"
     t.string   "cvv_result_message"
     t.boolean  "success"
-    t.datetime "created_at",        :null => false
-    t.datetime "updated_at",        :null => false
+    t.datetime "created_at",        :null => false, :limit => 3
+    t.datetime "updated_at",        :null => false, :limit => 3
     t.string   "kb_account_id",     :null => false
     t.string   "kb_tenant_id",      :null => false
   end

data/spec/killbill/helpers/test_transaction.rb

@@ -0,0 +1,11 @@
+module Killbill #:nodoc:
+  module Test #:nodoc:
+    class TestTransaction < ::Killbill::Plugin::ActiveMerchant::ActiveRecord::Transaction
+
+      self.table_name = 'test_transactions'
+
+      belongs_to :test_response
+
+    end
+  end
+end

data/spec/killbill/helpers/transaction_spec.rb

@@ -1,17 +1,5 @@
 require 'spec_helper'
 
-module Killbill #:nodoc:
-  module Test #:nodoc:
-    class TestTransaction < ::Killbill::Plugin::ActiveMerchant::ActiveRecord::Transaction
-
-      self.table_name = 'test_transactions'
-
-      belongs_to :test_response
-
-    end
-  end
-end
-
 describe Killbill::Plugin::ActiveMerchant::ActiveRecord::Transaction do
 
   before :all do
@@ -131,6 +119,8 @@ describe Killbill::Plugin::ActiveMerchant::ActiveRecord::Transaction do
                                              :currency                  => currency,
                                              :kb_account_id             => kb_account_id,
                                              :kb_tenant_id              => kb_tenant_id,
-                                             :test_response_id          => 0)
+                                             :test_response_id          => 0,
+                                             :created_at                => Time.now.utc,
+                                             :updated_at                => Time.now.utc)
   end
 end

data/spec/killbill/helpers/utils_spec.rb

@@ -1,96 +1,154 @@
 require 'spec_helper'
 
 describe Killbill::Plugin::ActiveMerchant::Utils do
-  it 'should convert back and forth UUIDs' do
-    uuid     = SecureRandom.uuid
-    packed   = Killbill::Plugin::ActiveMerchant::Utils.compact_uuid(uuid)
-    unpacked = Killbill::Plugin::ActiveMerchant::Utils.unpack_uuid(packed)
-    unpacked.should == uuid
-  end
 
-  it 'should respect leading 0s' do
-    uuid = '0ae18a4c-be57-44c3-84ba-a82962a2de03'
-    0.upto(35) do |i|
-      # Skip hyphens
-      next if [8, 13, 18, 23].include?(i)
-      uuid[i]  = '0'
-      packed   = Killbill::Plugin::ActiveMerchant::Utils.compact_uuid(uuid)
+  context 'UUID' do
+    it 'should convert back and forth UUIDs' do
+      uuid = SecureRandom.uuid
+      packed = Killbill::Plugin::ActiveMerchant::Utils.compact_uuid(uuid)
       unpacked = Killbill::Plugin::ActiveMerchant::Utils.unpack_uuid(packed)
       unpacked.should == uuid
     end
+
+    it 'should respect leading 0s' do
+      uuid = '0ae18a4c-be57-44c3-84ba-a82962a2de03'
+      0.upto(35) do |i|
+        # Skip hyphens
+        next if [8, 13, 18, 23].include?(i)
+        uuid[i] = '0'
+        packed = Killbill::Plugin::ActiveMerchant::Utils.compact_uuid(uuid)
+        unpacked = Killbill::Plugin::ActiveMerchant::Utils.unpack_uuid(packed)
+        unpacked.should == uuid
+      end
+    end
+  end
+
+  context 'normalization' do
+    it 'normalizes true values' do
+      ::Killbill::Plugin::ActiveMerchant::Utils.normalize(true).should be_true
+      ::Killbill::Plugin::ActiveMerchant::Utils.normalize('true').should be_true
+      ::Killbill::Plugin::ActiveMerchant::Utils.normalize('  true ').should be_true
+      ::Killbill::Plugin::ActiveMerchant::Utils.normalize(:true).should be_true
+      ::Killbill::Plugin::ActiveMerchant::Utils.normalize('yes').should be_true
+      ::Killbill::Plugin::ActiveMerchant::Utils.normalize('yes  ').should be_true
+      ::Killbill::Plugin::ActiveMerchant::Utils.normalize(:yes).should be_true
+    end
+
+    it 'normalizes false values' do
+      ::Killbill::Plugin::ActiveMerchant::Utils.normalize(false).should be_false
+      ::Killbill::Plugin::ActiveMerchant::Utils.normalize('  false ').should be_false
+      ::Killbill::Plugin::ActiveMerchant::Utils.normalize(:false).should be_false
+      ::Killbill::Plugin::ActiveMerchant::Utils.normalize('no').should be_false
+      ::Killbill::Plugin::ActiveMerchant::Utils.normalize('no  ').should be_false
+      ::Killbill::Plugin::ActiveMerchant::Utils.normalize(:no).should be_false
+    end
+
+    it 'understands snake case and camel case' do
+      ::Killbill::Plugin::ActiveMerchant::Utils.normalized({:skip_gw => 'true'}, :skip_gw).should be_true
+      ::Killbill::Plugin::ActiveMerchant::Utils.normalized({:skip_gw => 'false'}, :skip_gw).should be_false
+      ::Killbill::Plugin::ActiveMerchant::Utils.normalized({:skipGw => 'true'}, :skip_gw).should be_true
+      ::Killbill::Plugin::ActiveMerchant::Utils.normalized({:skipGw => 'false'}, :skip_gw).should be_false
+    end
+
+    it 'normalizes non-boolean attributes' do
+      ::Killbill::Plugin::ActiveMerchant::Utils.normalized({}, :cc_first_name).should be_nil
+      ::Killbill::Plugin::ActiveMerchant::Utils.normalized({:cc_first_name => ''}, :cc_first_name).should be_nil
+      ::Killbill::Plugin::ActiveMerchant::Utils.normalized({:cc_first_name => 'Paul'}, :cc_first_name).should == 'Paul'
+      ::Killbill::Plugin::ActiveMerchant::Utils.normalized({:ccFirstName => 'Paul'}, :cc_first_name).should == 'Paul'
+    end
+  end
+
+  context 'KBWiredumpDevice' do
+    it 'should implement a wiredump device for the Kill Bill logger' do
+      logger = Logger.new(STDOUT)
+      logger.level = Logger::INFO
+
+      io = ::Killbill::Plugin::ActiveMerchant::Utils::KBWiredumpDevice.new(logger)
+      io.sync = true
+      io.sync.should be_true
+      io << 'This is an I/O test'
+
+      jlogger = ::Killbill::Plugin::KillbillLogger.new(logger)
+      jio = ::Killbill::Plugin::ActiveMerchant::Utils::KBWiredumpDevice.new(jlogger)
+      jio.sync = true
+      jio.sync.should be_true
+      jio << 'This is an I/O test (via Java)'
+    end
   end
 
-  it 'should implement a wiredump device for the Kill Bill logger' do
-    logger       = Logger.new(STDOUT)
-    logger.level = Logger::INFO
+  context 'LazyEvaluator' do
+    it 'defers evaluation until called' do
+      argument = {:int => 12}
+
+      double_argument = ::Killbill::Plugin::ActiveMerchant::Utils::LazyEvaluator.new { argument[:int] *= 2 }
+      argument[:int].should == 12
 
-    io      = ::Killbill::Plugin::ActiveMerchant::Utils::KBWiredumpDevice.new(logger)
-    io.sync = true
-    io.sync.should be_true
-    io << 'This is an I/O test'
+      double_argument.to_i.should == 24
+      argument[:int].should == 24
 
-    jlogger  = ::Killbill::Plugin::KillbillLogger.new(logger)
-    jio      = ::Killbill::Plugin::ActiveMerchant::Utils::KBWiredumpDevice.new(jlogger)
-    jio.sync = true
-    jio.sync.should be_true
-    jio << 'This is an I/O test (via Java)'
+      # The block should be invoked exactly once
+      double_argument.to_i.should == 24
+      argument[:int].should == 24
+    end
   end
 
-  it 'should implement a thread-safe LRU cache' do
-    require 'benchmark'
-
-    runs            = 2
-    cache_size      = 50
-    nb_threads      = (ENV['NB_THREADS'] || 200).to_i
-    keys_per_thread = 1000
-
-    cache = nil
-    Benchmark.bm do |x|
-      runs.times do |n|
-        x.report("run ##{n}:") do
-          cache = ::Killbill::Plugin::ActiveMerchant::Utils::BoundedLRUCache.new(Proc.new { |value| -1 }, cache_size)
-
-          threads = (0..nb_threads).map do |i|
-            Thread.new do
-              (0..keys_per_thread).each do |j|
-                key        = 1001 * i + j
-                value      = rand(2000)
-                cache[key] = value
-                cache[key].should satisfy { |cache_value| cache_value == -1 or cache_value == value }
+  context 'BoundedLRUCache' do
+    it 'should implement a thread-safe LRU cache' do
+      require 'benchmark'
+
+      runs = 2
+      cache_size = 50
+      nb_threads = (ENV['NB_THREADS'] || 200).to_i
+      keys_per_thread = 1000
+
+      cache = nil
+      Benchmark.bm do |x|
+        runs.times do |n|
+          x.report("run ##{n}:") do
+            cache = ::Killbill::Plugin::ActiveMerchant::Utils::BoundedLRUCache.new(Proc.new { |value| -1 }, cache_size)
+
+            threads = (0..nb_threads).map do |i|
+              Thread.new do
+                (0..keys_per_thread).each do |j|
+                  key = 1001 * i + j
+                  value = rand(2000)
+                  cache[key] = value
+                  cache[key].should satisfy { |cache_value| cache_value == -1 or cache_value == value }
+                end
               end
             end
-          end
 
-          threads.each { |thread| thread.join }
+            threads.each { |thread| thread.join }
+          end
         end
       end
-    end
 
-    last_keys   = cache.keys
-    last_values = cache.values
-    0.upto(cache_size - 1) do |i|
-      # No overlap with test keys or values above
-      cache[-1 * i - 1] = -2
+      last_keys = cache.keys
+      last_values = cache.values
+      0.upto(cache_size - 1) do |i|
+        # No overlap with test keys or values above
+        cache[-1 * i - 1] = -2
 
-      new_keys   = cache.keys
-      new_values = cache.values
+        new_keys = cache.keys
+        new_values = cache.values
 
-      # Verify the changes we made
-      0.upto(i) do |j|
-        idx            = cache_size - j - 1
-        expected_key   = -1 * (i - j) - 1
-        expected_value = -2
+        # Verify the changes we made
+        0.upto(i) do |j|
+          idx = cache_size - j - 1
+          expected_key = -1 * (i - j) - 1
+          expected_value = -2
 
-        new_keys[idx].should eq(expected_key), "i=#{i}, j=#{j}, idx=#{idx}, expected_key=#{expected_key}, new_keys=#{new_keys.inspect}, last_keys=#{last_keys}"
-        new_values[idx].should eq(expected_value), "i=#{i}, j=#{j}, idx=#{idx}, expected_value=#{expected_value}, new_values=#{new_values.inspect}, last_values=#{last_values.inspect}"
-      end
+          new_keys[idx].should eq(expected_key), "i=#{i}, j=#{j}, idx=#{idx}, expected_key=#{expected_key}, new_keys=#{new_keys.inspect}, last_keys=#{last_keys}"
+          new_values[idx].should eq(expected_value), "i=#{i}, j=#{j}, idx=#{idx}, expected_value=#{expected_value}, new_values=#{new_values.inspect}, last_values=#{last_values.inspect}"
+        end
 
-      # Check we didn't override older entries
-      new_keys.slice(0, cache_size - i - 1).should eq(last_keys.slice(i + 1, cache_size)), "i=#{i}, new_keys=#{new_keys.inspect}, last_keys=#{last_keys.inspect}"
-      new_values.slice(0, cache_size - i - 1).should eq(last_values.slice(i + 1, cache_size)), "i=#{i}, new_values=#{new_values.inspect}, last_values=#{last_values.inspect}"
+        # Check we didn't override older entries
+        new_keys.slice(0, cache_size - i - 1).should eq(last_keys.slice(i + 1, cache_size)), "i=#{i}, new_keys=#{new_keys.inspect}, last_keys=#{last_keys.inspect}"
+        new_values.slice(0, cache_size - i - 1).should eq(last_values.slice(i + 1, cache_size)), "i=#{i}, new_values=#{new_values.inspect}, last_values=#{last_values.inspect}"
 
-      # Check there is no change in cache size
-      cache.size.should == cache_size
+        # Check there is no change in cache size
+        cache.size.should == cache_size
+      end
     end
   end
 end