killbill-client 0.30.0 → 0.31.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fa7b9310db3e2077873d4782699d17a7b842095d
-  data.tar.gz: 6265f9b80356fd96ed2c8d68b42eb55a33963683
+  metadata.gz: 1557b30b93a8605ae8e3d36179b24a93b439c839
+  data.tar.gz: 267910459ce59518aab8abba5b9f62cb1ed773f0
 SHA512:
-  metadata.gz: 67abf97671a18f027a2df4761201f0181627787af8f12e2e5a45fe4c02f5f58f4c1f7fee9d0508c8f7352348ce3133c6496c8a2a97863b1e986e676c1751da67
-  data.tar.gz: 54680415c950f005332ba9d161ee6a0f8c42091faf495c64cd3eabccbf92b9ed5fe4b692a2f9a3c90e4f2543b5907da649847b90b558217f14c501074006fba5
+  metadata.gz: 86c73b8dadf31bb8d0e96fb40e1157ad8971392dd63c3d15d697f7eeef84a29b0497c8ab897f065f181ed38fa1a041f2851156adecdea6c9c763f05981033720
+  data.tar.gz: c4eaaa21e76392bab84bfd341aa7b5d8761fa1cfabf86a604da08e4cc8fccc311cb8affa0faf9cd5b318f4a5b7428ea545c49b68b731a0c7a0b3a0db7ccaf733

data/killbill_client.gemspec

@@ -41,6 +41,6 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'json', '>= 1.2.0'
 
-  s.add_development_dependency 'rake', '>= 10.0.0'
-  s.add_development_dependency 'rspec', '~> 2.12.0'
+  s.add_development_dependency 'rake', '>= 10.0.0', '< 11.0.0'
+  s.add_development_dependency 'rspec', '~> 3.4'
 end

data/lib/killbill_client/api/net_http_adapter.rb

@@ -35,6 +35,30 @@ module KillBillClient
             :delete => ::Net::HTTP::Delete
         }
 
+        def encode_params(options = {})
+          # Plugin properties are passed in the options but we want to send them as query parameters,
+          # so remove with from global hash and insert them under :params
+          plugin_properties = options.delete :pluginProperty
+          if plugin_properties && plugin_properties.size > 0
+            options[:params][:pluginProperty] = plugin_properties.map { |p| "#{CGI.escape p.key}=#{CGI.escape p.value}" }
+          end
+          return nil unless (options[:params] && !options[:params].empty?)
+
+          pairs = options[:params].map { |key, value|
+            # If the value is an array, we 'demultiplex' into several
+            if value.is_a? Array
+              internal_pairs = value.map do |simple_value|
+                "#{CGI.escape key.to_s}=#{CGI.escape simple_value.to_s}"
+              end
+              internal_pairs
+            else
+              "#{CGI.escape key.to_s}=#{CGI.escape value.to_s}"
+            end
+          }
+          pairs.flatten!
+          "?#{pairs.join '&'}"
+        end
+
         def request(method, relative_uri, options = {})
           head = headers.dup
           head.update options[:head] if options[:head]
@@ -45,29 +69,7 @@ module KillBillClient
           # See https://github.com/killbill/killbill/issues/221#issuecomment-151980263
           base_path = uri.request_uri == '/' ? '' : uri.request_uri
           uri += (base_path + URI.escape(relative_uri))
-
-          # Plugin properties are passed in the options but we want to send them as query parameters,
-          # so remove with from global hash and insert them under :params
-          plugin_properties = options.delete :pluginProperty
-          if plugin_properties && plugin_properties.size > 0
-            options[:params][:pluginProperty] = plugin_properties.map { |p| "#{p.key}=#{p.value}" }
-          end
-
-          if options[:params] && !options[:params].empty?
-            pairs = options[:params].map { |key, value|
-              # If the value is an array, we 'demultiplex' into several
-              if value.is_a? Array
-                internal_pairs = value.map do |simple_value|
-                  "#{CGI.escape key.to_s}=#{CGI.escape simple_value.to_s}"
-                end
-                internal_pairs
-              else
-                "#{CGI.escape key.to_s}=#{CGI.escape value.to_s}"
-              end
-            }
-            pairs.flatten!
-            uri += "?#{pairs.join '&'}"
-          end
+          uri += encode_params(options).to_s
           request = METHODS[method].new uri.request_uri, head
 
           # Configure multi-tenancy headers, if enabled

data/lib/killbill_client/models/combo_transaction.rb

@@ -2,27 +2,27 @@ module KillBillClient
   module Model
     class ComboTransaction < ComboPaymentTransactionAttributes
 
-      def auth(user = nil, reason = nil, comment = nil, options = {})
+      def auth(user = nil, reason = nil, comment = nil, options = {}, refresh_options = nil)
         @transaction.transaction_type = 'AUTHORIZE'
 
-        combo_payment(user, reason, comment, options)
+        combo_payment(user, reason, comment, options, refresh_options)
       end
 
-      def purchase(user = nil, reason = nil, comment = nil, options = {})
+      def purchase(user = nil, reason = nil, comment = nil, options = {}, refresh_options = nil)
         @transaction.transaction_type = 'PURCHASE'
 
-        combo_payment(user, reason, comment, options)
+        combo_payment(user, reason, comment, options, refresh_options)
       end
 
-      def credit(user = nil, reason = nil, comment = nil, options = {})
+      def credit(user = nil, reason = nil, comment = nil, options = {}, refresh_options = nil)
         @transaction.transaction_type = 'CREDIT'
 
-        combo_payment(user, reason, comment, options)
+        combo_payment(user, reason, comment, options, refresh_options)
       end
 
       private
 
-      def combo_payment(user, reason, comment, options)
+      def combo_payment(user, reason, comment, options, refresh_options = nil)
         query_map = {
         }
         if options.include? :controlPluginNames
@@ -37,7 +37,7 @@ module KillBillClient
                                                   :reason => reason,
                                                   :comment => comment,
                                               }.merge(options)
-        created_transaction.refresh(options, Payment)
+        created_transaction.refresh(refresh_options || options, Payment)
       end
     end
   end

data/lib/killbill_client/models/resource.rb

@@ -26,7 +26,9 @@ module KillBillClient
       class << self
 
         def require_multi_tenant_options!(options, msg)
-          if options[:api_key].nil? || options[:api_secret].nil?
+          api_key = options[:api_key] || KillBillClient.api_key
+          api_secret = options[:api_secret] || KillBillClient.api_secret
+          if api_key.nil? || api_secret.nil?
             raise ArgumentError, msg
           end
         end

data/lib/killbill_client/models/transaction.rb

@@ -2,6 +2,7 @@ module KillBillClient
   module Model
     class Transaction < PaymentTransactionAttributes
 
+      has_many :properties, KillBillClient::Model::PluginPropertyAttributes
       has_many :audit_logs, KillBillClient::Model::AuditLog
 
       def auth(account_id, payment_method_id = nil, user = nil, reason = nil, comment = nil, options = {})
@@ -40,6 +41,10 @@ module KillBillClient
         create_initial_transaction("#{Account::KILLBILL_API_ACCOUNTS_PREFIX}/payments", query_map, payment_method_id, user, reason, comment, options)
       end
 
+      def complete(user = nil, reason = nil, comment = nil, options = {})
+        complete_initial_transaction(user, reason, comment, options)
+      end
+
       def complete_auth(user = nil, reason = nil, comment = nil, options = {})
         @transaction_type = 'AUTHORIZE'
         complete_initial_transaction(user, reason, comment, options)

data/lib/killbill_client/version.rb

@@ -1,7 +1,7 @@
 module KillBillClient
   module Version
     MAJOR = 0
-    MINOR = 30
+    MINOR = 31
     PATCH = 0
     PRE = nil
 

data/spec/killbill_client/base_uri_spec.rb

@@ -4,15 +4,15 @@ describe KillBillClient do
 
   it 'should be able to parse a url with http' do
     KillBillClient.url = "http://example.com:8080"
-    KillBillClient::API.base_uri.scheme.should == "http"
-    KillBillClient::API.base_uri.host.should == "example.com"
-    KillBillClient::API.base_uri.port.should == 8080
+    expect(KillBillClient::API.base_uri.scheme).to eq("http")
+    expect(KillBillClient::API.base_uri.host).to eq("example.com")
+    expect(KillBillClient::API.base_uri.port).to eq(8080)
   end
 
   it 'should be able to parse a url without http' do
     KillBillClient.url = "example.com:8080"
-    KillBillClient::API.base_uri.scheme.should == "http"
-    KillBillClient::API.base_uri.host.should == "example.com"
-    KillBillClient::API.base_uri.port.should == 8080
+    expect(KillBillClient::API.base_uri.scheme).to eq("http")
+    expect(KillBillClient::API.base_uri.host).to eq("example.com")
+    expect(KillBillClient::API.base_uri.port).to eq(8080)
   end
 end

data/spec/killbill_client/encoding_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe KillBillClient::API do
+  let(:expected_query_params) {
+    [
+        'controlPluginName=killbill-example-plugin',
+        'pluginProperty=contractId%3Dtest'
+    ]
+  }
+
+  it 'should send double-encoded uri' do
+    contract_property = KillBillClient::Model::PluginPropertyAttributes.new
+    contract_property.key = 'contractId'
+    contract_property.value = 'test'
+    info_property = KillBillClient::Model::PluginPropertyAttributes.new
+    info_property.key = 'details'
+    info_property_hash = {
+        'eventType' => 'voidEvent',
+        'transactionType' => 'void'
+    }
+    info_property.value = info_property_hash.to_json
+    plugin_properties = [contract_property, info_property]
+    options = {
+        :params => {:controlPluginName => 'killbill-example-plugin'},
+        :pluginProperty => plugin_properties
+    }
+    http_adapter = DummyForHTTPAdapter.new
+    query_string = http_adapter.send(:encode_params, options)
+    expect(query_string.chars.first).to eq('?')
+    query_params = query_string[1..-1].split('&').sort
+    expect(query_params.size).to eq(3)
+
+    # check the first two query strings
+    expect(query_params[0..1]).to eq(expected_query_params)
+
+    # decode info_property to check if it is double encoded
+    info_property_query = CGI.parse(query_params[2])
+    expect(info_property_query.size).to eq(1)
+    expect(info_property_query.keys.first).to eq('pluginProperty')
+    expect(info_property_query['pluginProperty'].size).to eq(1)
+    output_info_property = info_property_query['pluginProperty'].first.split('=')
+    expect(output_info_property.size).to eq(2)
+    expect(output_info_property[0]).to eq(info_property.key)
+    # should match if we decode it
+    expect(JSON.parse CGI.unescape(output_info_property[1])).to eq(info_property_hash)
+    # also ensure the undecoded value is different so that it was indeed encocded twice
+    expect(output_info_property[1]).not_to eq(CGI.unescape output_info_property[1])
+  end
+end
+
+class DummyForHTTPAdapter
+  include KillBillClient::API::Net::HTTPAdapter
+end

data/spec/killbill_client/model_relation_spec.rb

@@ -2,32 +2,32 @@ require 'spec_helper'
 
 describe KillBillClient::Model::Resource do
   class_var_name = '@@attribute_names'
-  
+
   it 'should test has_one property' do
     #test account_timeline has one account
     #has_one :account, KillBillClient::Model::Account
     #expected "KillBillClient::Model::AccountTimeline"=>{:account=>{:type=>KillBillClient::Model::Account, :cardinality=>:one}, :payments=>{:type=>KillBillClient::Model::Payment, :cardinality=>:many}, :bundles=>{:type=>KillBillClient::Model::Bundle, :cardinality=>:many}, :invoices=>{:type=>KillBillClient::Model::Invoice, :cardinality=>:many}}
     test_var = KillBillClient::Model::AccountTimeline.class_variable_defined? class_var_name
-    test_var.should_not be_false
+    expect(test_var).not_to be(false)
 
     var = KillBillClient::Model::AccountTimeline.send(:class_variable_get, class_var_name)
-    var.size.should > 0
-    var.should have_key "KillBillClient::Model::AccountTimeline"
-    var["KillBillClient::Model::AccountTimeline"].should have_key :account
+    expect(var.size).to be > 0
+    expect(var).to have_key "KillBillClient::Model::AccountTimeline"
+    expect(var["KillBillClient::Model::AccountTimeline"]).to have_key :account
 
     attr = var["KillBillClient::Model::AccountTimeline"][:account]
 
-    attr.should have_key :type
-    attr.should have_key :cardinality
+    expect(attr).to have_key :type
+    expect(attr).to have_key :cardinality
 
-    attr[:type].should == KillBillClient::Model::Account
-    attr[:cardinality].should == :one #has one
+    expect(attr[:type]).to eq(KillBillClient::Model::Account)
+    expect(attr[:cardinality]).to eq(:one) #has one
 
     #should also be accessible by attr_accessors
 
     methods = KillBillClient::Model::AccountTimeline.instance_methods
-    methods.map(&:to_sym).should include :account     # attr_reader
-    methods.map(&:to_sym).should include :account= #attr_writer
+    expect(methods.map(&:to_sym)).to include :account     # attr_reader
+    expect(methods.map(&:to_sym)).to include :account= #attr_writer
   end
 
   it 'should test has_many property' do
@@ -36,39 +36,39 @@ describe KillBillClient::Model::Resource do
     #expected {"KillBillClient::Model::SubscriptionEvent"=>{:audit_logs=>{:type=>KillBillClient::Model::AuditLog, :cardinality=>:many}}}
 
     test_var = KillBillClient::Model::EventSubscription.class_variable_defined? class_var_name
-    test_var.should_not be_false
+    expect(test_var).to be(true)
 
     var = KillBillClient::Model::EventSubscription.send(:class_variable_get, class_var_name)
-    var.size.should > 0
-    var.should have_key "KillBillClient::Model::Subscription"
-    var["KillBillClient::Model::Subscription"].should have_key :events
+    expect(var.size).to be > 0
+    expect(var).to have_key "KillBillClient::Model::Subscription"
+    expect(var["KillBillClient::Model::Subscription"]).to have_key :events
 
     attr = var["KillBillClient::Model::Subscription"][:events]
 
-    attr.should have_key :type
-    attr.should have_key :cardinality
+    expect(attr).to have_key :type
+    expect(attr).to have_key :cardinality
 
-    attr[:type].should == KillBillClient::Model::EventSubscription
-    attr[:cardinality].should == :many #has many
+    expect(attr[:type]).to eq(KillBillClient::Model::EventSubscription)
+    expect(attr[:cardinality]).to eq(:many) #has many
 
     #should also be accessible by attr_accessors
 
     methods = KillBillClient::Model::EventSubscription.instance_methods
-    methods.map(&:to_sym).should include :audit_logs     # attr_reader
-    methods.map(&:to_sym).should include :audit_logs= #attr_writer
+    expect(methods.map(&:to_sym)).to include :audit_logs     # attr_reader
+    expect(methods.map(&:to_sym)).to include :audit_logs= #attr_writer
   end
 
   it 'should create alias attr accessors' do
     KillBillClient::Model::EventSubscription.create_alias :alias_date, :requested_dt
 
     methods = KillBillClient::Model::EventSubscription.instance_methods
-    methods.map(&:to_sym).should include :alias_date
-    methods.map(&:to_sym).should include :alias_date=
+    expect(methods.map(&:to_sym)).to include :alias_date
+    expect(methods.map(&:to_sym)).to include :alias_date=
 
     evt = KillBillClient::Model::EventSubscription.new
     evt.alias_date = "devaroop"
-    evt.requested_dt.should == "devaroop"
-    evt.alias_date.should == "devaroop"
+    expect(evt.requested_dt).to eq("devaroop")
+    expect(evt.alias_date).to eq("devaroop")
   end
 end
- 
+

data/spec/killbill_client/remote/api_spec.rb

@@ -3,8 +3,8 @@ require 'spec_helper'
 describe KillBillClient::API do
   it 'should get all tag definitions', :integration => true  do
     response = KillBillClient::API.get '/1.0/kb/tagDefinitions'
-    response.code.to_i.should == 200
+    expect(response.code.to_i).to eq(200)
     tag_definitions = KillBillClient::Model::Resource.from_response KillBillClient::Model::TagDefinition, response
-    tag_definitions.size.should > 1
+    expect(tag_definitions.size).to be > 1
   end
 end

data/spec/killbill_client/remote/model_spec.rb

@@ -22,73 +22,73 @@ describe KillBillClient::Model do
     account.country = 'LalaLand'
     account.locale = 'FR_fr'
     account.is_notified_for_invoices = false
-    account.account_id.should be_nil
+    expect(account.account_id).to be_nil
 
     # Create and verify the account
     account = account.create('KillBill Spec test')
-    account.external_key.should == external_key
-    account.account_id.should_not be_nil
+    expect(account.external_key).to eq(external_key)
+    expect(account.account_id).not_to be_nil
     account_id = account.account_id
 
     # Try to retrieve it
     account = KillBillClient::Model::Account.find_by_id account.account_id
-    account.external_key.should == external_key
-    account.payment_method_id.should be_nil
+    expect(account.external_key).to eq(external_key)
+    expect(account.payment_method_id).to be_nil
 
     # Try to retrieve it
     account = KillBillClient::Model::Account.find_by_external_key external_key
-    account.account_id.should == account_id
-    account.payment_method_id.should be_nil
+    expect(account.account_id).to eq(account_id)
+    expect(account.payment_method_id).to be_nil
 
     # Try to retrieve it (bis repetita placent)
     accounts = KillBillClient::Model::Account.find_in_batches(0, search_limit)
     # Can't test equality if the remote server has extra data
-    accounts.pagination_total_nb_records.should >= 1
-    accounts.pagination_max_nb_records.should >= 1
-    accounts.size.should >= 1
+    expect(accounts.pagination_total_nb_records).to be >= 1
+    expect(accounts.pagination_max_nb_records).to be >= 1
+    expect(accounts.size).to be >= 1
     # If the remote server has lots of data, we need to page through the results (good test!)
     found = nil
     accounts.each_in_batches do |account|
       found = account if account.external_key == external_key
       break unless found.nil?
     end
-    found.should_not be_nil
+    expect(found).not_to be_nil
 
     # Try to retrieve it via the search API
     accounts = KillBillClient::Model::Account.find_in_batches_by_search_key(account.name, 0, search_limit)
     # Can't test equality if the remote server has extra data
-    accounts.pagination_total_nb_records.should >= 1
-    accounts.pagination_max_nb_records.should >= 1
-    accounts.size.should >= 1
+    expect(accounts.pagination_total_nb_records).to be >= 1
+    expect(accounts.pagination_max_nb_records).to be >= 1
+    expect(accounts.size).to be >= 1
     # If the remote server has lots of data, we need to page through the results (good test!)
     found = nil
     accounts.each_in_batches do |account|
       found = account if account.external_key == external_key
       break unless found.nil?
     end
-    found.should_not be_nil
+    expect(found).not_to be_nil
 
     # Add/Remove a tag
-    account.tags.size.should == 0
+    expect(account.tags.size).to eq(0)
     account.add_tag('TEST', 'KillBill Spec test')
     tags = account.tags
-    tags.size.should == 1
-    tags.first.tag_definition_name.should == 'TEST'
+    expect(tags.size).to eq(1)
+    expect(tags.first.tag_definition_name).to eq('TEST')
     account.remove_tag('TEST', 'KillBill Spec test')
-    account.tags.size.should == 0
+    expect(account.tags.size).to eq(0)
 
     # Add/Remove a custom field
-    account.custom_fields.size.should == 0
+    expect(account.custom_fields.size).to eq(0)
     custom_field = KillBillClient::Model::CustomField.new
     custom_field.name = Time.now.to_i.to_s
     custom_field.value = Time.now.to_i.to_s
     account.add_custom_field(custom_field, 'KillBill Spec test')
     custom_fields = account.custom_fields
-    custom_fields.size.should == 1
-    custom_fields.first.name.should == custom_field.name
-    custom_fields.first.value.should == custom_field.value
+    expect(custom_fields.size).to eq(1)
+    expect(custom_fields.first.name).to eq(custom_field.name)
+    expect(custom_fields.first.value).to eq(custom_field.value)
     account.remove_custom_field(custom_fields.first.custom_field_id, 'KillBill Spec test')
-    account.custom_fields.size.should == 0
+    expect(account.custom_fields.size).to eq(0)
 
     # Add a payment method
     pm = KillBillClient::Model::PaymentMethod.new
@@ -96,38 +96,38 @@ describe KillBillClient::Model do
     pm.is_default = true
     pm.plugin_name = KillBillClient::Model::PaymentMethod::EXTERNAL_PAYMENT
     pm.plugin_info = {}
-    pm.payment_method_id.should be_nil
+    expect(pm.payment_method_id).to be_nil
 
     pm = pm.create(true, 'KillBill Spec test')
-    pm.payment_method_id.should_not be_nil
+    expect(pm.payment_method_id).not_to be_nil
 
     # Try to retrieve it
     pm = KillBillClient::Model::PaymentMethod.find_by_id pm.payment_method_id, true
-    pm.account_id.should == account.account_id
+    expect(pm.account_id).to eq(account.account_id)
 
     # Try to retrieve it (bis repetita placent)
     pms = KillBillClient::Model::PaymentMethod.find_in_batches(0, search_limit)
     # Can't test equality if the remote server has extra data
-    pms.pagination_total_nb_records.should >= 1
-    pms.pagination_max_nb_records.should >= 1
-    pms.size.should >= 1
+    expect(pms.pagination_total_nb_records).to be >= 1
+    expect(pms.pagination_max_nb_records).to be >= 1
+    expect(pms.size).to be >= 1
     # If the remote server has lots of data, we need to page through the results (good test!)
     found = nil
     pms.each_in_batches do |payment_method|
       found = payment_method if payment_method.payment_method_id == pm.payment_method_id
       break unless found.nil?
     end
-    found.should_not be_nil
+    expect(found).not_to be_nil
 
     account = KillBillClient::Model::Account.find_by_id account.account_id
-    account.payment_method_id.should == pm.payment_method_id
+    expect(account.payment_method_id).to eq(pm.payment_method_id)
 
     pms = KillBillClient::Model::PaymentMethod.find_all_by_account_id account.account_id
-    pms.size.should == 1
-    pms[0].payment_method_id.should == pm.payment_method_id
+    expect(pms.size).to eq(1)
+    expect(pms[0].payment_method_id).to eq(pm.payment_method_id)
 
     # Check there is no payment associated with that account
-    account.payments.size.should == 0
+    expect(account.payments.size).to eq(0)
 
     # Add an external charge
     invoice_item = KillBillClient::Model::InvoiceItem.new
@@ -138,27 +138,27 @@ describe KillBillClient::Model do
     invoice_item = invoice_item.create 'KillBill Spec test'
     invoice = KillBillClient::Model::Invoice.find_by_id_or_number invoice_item.invoice_id
 
-    invoice.balance.should == 123.98
+    expect(invoice.balance).to eq(123.98)
 
     # Check the account balance
     account = KillBillClient::Model::Account.find_by_id account.account_id, true
-    account.account_balance.should == 123.98
+    expect(account.account_balance).to eq(123.98)
 
     pm.destroy(true, 'KillBill Spec test')
 
     account = KillBillClient::Model::Account.find_by_id account.account_id
-    account.payment_method_id.should be_nil
+    expect(account.payment_method_id).to be_nil
 
     # Get its timeline
     timeline = KillBillClient::Model::AccountTimeline.find_by_account_id account.account_id
 
-    timeline.account.external_key.should == external_key
-    timeline.account.account_id.should_not be_nil
+    expect(timeline.account.external_key).to eq(external_key)
+    expect(timeline.account.account_id).not_to be_nil
 
-    timeline.invoices.should be_a_kind_of Array
-    timeline.invoices.should_not be_empty
-    timeline.payments.should be_a_kind_of Array
-    timeline.bundles.should be_a_kind_of Array
+    expect(timeline.invoices).to be_a_kind_of Array
+    expect(timeline.invoices).not_to be_empty
+    expect(timeline.payments).to be_a_kind_of Array
+    expect(timeline.bundles).to be_a_kind_of Array
 
     # Let's find the invoice by two methods
     invoice = timeline.invoices.first
@@ -168,8 +168,8 @@ describe KillBillClient::Model do
     invoice_with_id = KillBillClient::Model::Invoice.find_by_id_or_number invoice_id
     invoice_with_number = KillBillClient::Model::Invoice.find_by_id_or_number invoice_number
 
-    invoice_with_id.invoice_id.should == invoice_with_number.invoice_id
-    invoice_with_id.invoice_number.should == invoice_with_number.invoice_number
+    expect(invoice_with_id.invoice_id).to eq(invoice_with_number.invoice_id)
+    expect(invoice_with_id.invoice_number).to eq(invoice_with_number.invoice_number)
 
     # Create an external payment for each unpaid invoice
     invoice_payment = KillBillClient::Model::InvoicePayment.new
@@ -179,43 +179,43 @@ describe KillBillClient::Model do
     # Try to retrieve it
     payments = KillBillClient::Model::Payment.find_in_batches(0, search_limit)
     # Can't test equality if the remote server has extra data
-    payments.pagination_total_nb_records.should >= 1
-    payments.pagination_max_nb_records.should >= 1
-    payments.size.should >= 1
+    expect(payments.pagination_total_nb_records).to be >= 1
+    expect(payments.pagination_max_nb_records).to be >= 1
+    expect(payments.size).to be >= 1
     # If the remote server has lots of data, we need to page through the results (good test!)
     found = nil
     payments.each_in_batches do |p|
       found = p if p.account_id == account.account_id
       break unless found.nil?
     end
-    found.should_not be_nil
+    expect(found).not_to be_nil
 
     # Try to retrieve it (bis repetita placent)
     invoice_payment = KillBillClient::Model::InvoicePayment.find_by_id found.payment_id
-    invoice_payment.account_id.should == account.account_id
+    expect(invoice_payment.account_id).to eq(account.account_id)
 
     # Try to retrieve it
     invoice = KillBillClient::Model::Invoice.new
     invoice.invoice_id = invoice_payment.target_invoice_id
     payments = invoice.payments
-    payments.size.should == 1
-    payments.first.account_id.should == account.account_id
+    expect(payments.size).to eq(1)
+    expect(payments.first.account_id).to eq(account.account_id)
 
     # Check the account balance
     account = KillBillClient::Model::Account.find_by_id account.account_id, true
-    account.account_balance.should == 0
+    expect(account.account_balance).to eq(0)
 
     # Verify the timeline
     timeline = KillBillClient::Model::AccountTimeline.find_by_account_id account.account_id
-    timeline.payments.should_not be_empty
+    expect(timeline.payments).not_to be_empty
     invoice_payment = timeline.payments.first
-    timeline.payments.first.transactions.size.should == 1
-    timeline.payments.first.transactions.first.transaction_type.should == 'PURCHASE'
-    invoice_payment.auth_amount.should == 0
-    invoice_payment.captured_amount.should == 0
-    invoice_payment.purchased_amount.should == invoice_payment.purchased_amount
-    invoice_payment.refunded_amount.should == 0
-    invoice_payment.credited_amount.should == 0
+    expect(timeline.payments.first.transactions.size).to eq(1)
+    expect(timeline.payments.first.transactions.first.transaction_type).to eq('PURCHASE')
+    expect(invoice_payment.auth_amount).to eq(0)
+    expect(invoice_payment.captured_amount).to eq(0)
+    expect(invoice_payment.purchased_amount).to eq(invoice_payment.purchased_amount)
+    expect(invoice_payment.refunded_amount).to eq(0)
+    expect(invoice_payment.credited_amount).to eq(0)
 
     # Refund the payment (with item adjustment)
     invoice_item = KillBillClient::Model::Invoice.find_by_id_or_number(invoice_number, true).items.first
@@ -226,13 +226,13 @@ describe KillBillClient::Model do
 
     # Verify the refund
     timeline = KillBillClient::Model::AccountTimeline.find_by_account_id account.account_id
-    timeline.payments.should_not be_empty
-    timeline.payments.size.should == 1
-    timeline.payments.first.transactions.size.should == 2
-    timeline.payments.first.transactions.first.transaction_type.should == 'PURCHASE'
+    expect(timeline.payments).not_to be_empty
+    expect(timeline.payments.size).to eq(1)
+    expect(timeline.payments.first.transactions.size).to eq(2)
+    expect(timeline.payments.first.transactions.first.transaction_type).to eq('PURCHASE')
     refund = timeline.payments.first.transactions.last
-    refund.transaction_type.should == 'REFUND'
-    refund.amount.should == invoice_item.amount
+    expect(refund.transaction_type).to eq('REFUND')
+    expect(refund.amount).to eq(invoice_item.amount)
 
     # Create a credit for invoice
     new_credit = KillBillClient::Model::Credit.new
@@ -244,15 +244,15 @@ describe KillBillClient::Model do
 
     # Verify the invoice item of the credit
     invoice = KillBillClient::Model::Invoice.find_by_id_or_number invoice_id
-    invoice.items.should_not be_empty
+    expect(invoice.items).not_to be_empty
     item = invoice.items.last
-    item.invoice_id.should == invoice_id
-    item.amount.should == 10.1
-    item.account_id.should == account.account_id
+    expect(item.invoice_id).to eq(invoice_id)
+    expect(item.amount).to eq(10.1)
+    expect(item.account_id).to eq(account.account_id)
 
     # Verify the credit
     account = KillBillClient::Model::Account.find_by_id account.account_id, true
-    account.account_balance.should == -10.1
+    expect(account.account_balance).to eq(-10.1)
 
     # Create a subscription
     sub = KillBillClient::Model::Subscription.new
@@ -265,39 +265,39 @@ describe KillBillClient::Model do
     sub = sub.create 'KillBill Spec test'
 
     # Verify we can retrieve it
-    account.bundles.size.should == 1
-    account.bundles[0].subscriptions.size.should == 1
-    account.bundles[0].subscriptions[0].subscription_id.should == sub.subscription_id
+    expect(account.bundles.size).to eq(1)
+    expect(account.bundles[0].subscriptions.size).to eq(1)
+    expect(account.bundles[0].subscriptions[0].subscription_id).to eq(sub.subscription_id)
     bundle = account.bundles[0]
 
     # Verify we can retrieve it by id
-    KillBillClient::Model::Bundle.find_by_id(bundle.bundle_id).should == bundle
+    expect(KillBillClient::Model::Bundle.find_by_id(bundle.bundle_id)).to eq(bundle)
 
     # Verify we can retrieve it by external key
-    KillBillClient::Model::Bundle.find_by_external_key(bundle.external_key).should == bundle
+    expect(KillBillClient::Model::Bundle.find_by_external_key(bundle.external_key)).to eq(bundle)
 
     # Verify we can retrieve it by account id and external key
     bundles = KillBillClient::Model::Bundle.find_all_by_account_id_and_external_key(account.account_id, bundle.external_key)
-    bundles.size.should == 1
-    bundles[0].should == bundle
+    expect(bundles.size).to eq(1)
+    expect(bundles[0]).to eq(bundle)
   end
 
   it 'should manipulate tag definitions' do
-    KillBillClient::Model::TagDefinition.all.size.should > 0
-    KillBillClient::Model::TagDefinition.find_by_name('TEST').is_control_tag.should be_true
+    expect(KillBillClient::Model::TagDefinition.all.size).to be > 0
+    expect(KillBillClient::Model::TagDefinition.find_by_name('TEST').is_control_tag).to be_truthy
 
     tag_definition_name = Time.now.to_i.to_s
-    KillBillClient::Model::TagDefinition.find_by_name(tag_definition_name).should be_nil
+    expect(KillBillClient::Model::TagDefinition.find_by_name(tag_definition_name)).to be_nil
 
     tag_definition = KillBillClient::Model::TagDefinition.new
     tag_definition.name = tag_definition_name
     tag_definition.description = 'Tag for unit test'
-    tag_definition.create('KillBill Spec test').id.should_not be_nil
+    expect(tag_definition.create('KillBill Spec test').id).not_to be_nil
 
     found_tag_definition = KillBillClient::Model::TagDefinition.find_by_name(tag_definition_name)
-    found_tag_definition.name.should == tag_definition_name
-    found_tag_definition.description.should == tag_definition.description
-    found_tag_definition.is_control_tag.should be_false
+    expect(found_tag_definition.name).to eq(tag_definition_name)
+    expect(found_tag_definition.description).to eq(tag_definition.description)
+    expect(found_tag_definition.is_control_tag).to be_falsey
   end
 
   it 'should manipulate tenants', :integration => true  do
@@ -310,22 +310,22 @@ describe KillBillClient::Model do
 
     # Create and verify the tenant
     tenant = tenant.create('KillBill Spec test')
-    tenant.api_key.should == api_key
-    tenant.tenant_id.should_not be_nil
+    expect(tenant.api_key).to eq(api_key)
+    expect(tenant.tenant_id).not_to be_nil
 
     # Try to retrieve it by id
     tenant = KillBillClient::Model::Tenant.find_by_id tenant.tenant_id
-    tenant.api_key.should == api_key
+    expect(tenant.api_key).to eq(api_key)
 
     # Try to retrieve it by api key
     tenant = KillBillClient::Model::Tenant.find_by_api_key tenant.api_key
-    tenant.api_key.should == api_key
+    expect(tenant.api_key).to eq(api_key)
   end
 
   it 'should manipulate the catalog', :integration => true do
     plans = KillBillClient::Model::Catalog::available_base_plans
-    plans.size.should > 0
-    plans[0].plan.should_not be_nil
+    expect(plans.size).to be > 0
+    expect(plans[0].plan).not_to be_nil
   end
 
   #it 'should retrieve users permissions' do

data/spec/killbill_client/resource_spec.rb

@@ -10,9 +10,66 @@ describe KillBillClient::Model::Resource do
 
     payment2 = KillBillClient::Model::InvoicePayment.new(payment1.to_hash)
 
-    payment2.should == payment1
-    payment2.account_id.should == '1234'
-    payment2.target_invoice_id.should == '5678'
-    payment2.purchased_amount.should == 12.42
+    expect(payment2).to eq(payment1)
+    expect(payment2.account_id).to eq('1234')
+    expect(payment2.target_invoice_id).to eq('5678')
+    expect(payment2.purchased_amount).to eq(12.42)
+  end
+
+  describe '#require_multi_tenant_options!' do
+    let(:message) { 'nothing' }
+
+    def require_multi_tenant_options!
+      described_class.require_multi_tenant_options!(options, message)
+    end
+
+    context 'when api_key and api_secret passed as options' do
+      let(:options) do
+        {
+          :api_key => 'bob',
+          :api_secret =>'lazar'
+        }
+      end
+
+      it do
+        expect { require_multi_tenant_options! }.not_to raise_error
+      end
+    end
+
+    context 'when no api_key passed as options' do
+      let(:options) do
+        {
+          :api_secret => 'lazar'
+        }
+      end
+
+      it do
+        expect { require_multi_tenant_options! }.to raise_error(ArgumentError, message)
+      end
+    end
+
+    context 'when no api_secret passed as options' do
+      let(:options) do
+        {
+          :api_key => 'bob'
+        }
+      end
+
+      it do
+        expect { require_multi_tenant_options! }.to raise_error(ArgumentError, message)
+      end
+    end
+
+    context 'when api_key and api_secret passed as KillBillClient configuration option' do
+      let(:options) { { } }
+      before do
+        allow(KillBillClient).to receive_messages(:api_key => 'bob')
+        allow(KillBillClient).to receive_messages(:api_secret => 'lazar')
+      end
+
+      it do
+        expect { require_multi_tenant_options! }.not_to raise_error
+      end
+    end
   end
 end

data/spec/killbill_client/resources_spec.rb

@@ -4,11 +4,11 @@ describe KillBillClient::Model::Resources do
   it 'should respect the next page url when calling the .each_in_batches method' do
     stuff = KillBillClient::Model::Resources.new
     1.upto(10).each { |i| stuff << i }
-    stuff.size.should == 10
+    expect(stuff.size).to eq(10)
 
     idx = 1
     stuff.each_in_batches do |i|
-      i.should == idx
+      expect(i).to eq(idx)
       idx += 1
     end
   end

data/spec/spec_helper.rb

@@ -13,7 +13,7 @@ KillBillClient.password = 'password'
 
 
 RSpec.configure do |config|
-  config.color_enabled = true
+  config.color = true
   config.tty = true
   config.formatter = 'documentation'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: killbill-client
 version: !ruby/object:Gem::Version
-  version: 0.30.0
+  version: 0.31.0
 platform: ruby
 authors:
 - Killbill core team
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-02-17 00:00:00.000000000 Z
+date: 2016-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -31,11 +31,17 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: 10.0.0
+    - - <
+      - !ruby/object:Gem::Version
+        version: 11.0.0
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
         version: 10.0.0
+    - - <
+      - !ruby/object:Gem::Version
+        version: 11.0.0
   prerelease: false
   type: :development
 - !ruby/object:Gem::Dependency
@@ -44,12 +50,12 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.12.0
+        version: '3.4'
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.12.0
+        version: '3.4'
   prerelease: false
   type: :development
 description: An API client library for Kill Bill.
@@ -175,6 +181,7 @@ files:
 - lib/rails/generators/killbill_client/config_generator.rb
 - lib/rails/killbill_client.rb
 - spec/killbill_client/base_uri_spec.rb
+- spec/killbill_client/encoding_spec.rb
 - spec/killbill_client/model_relation_spec.rb
 - spec/killbill_client/remote/api_spec.rb
 - spec/killbill_client/remote/model_spec.rb
@@ -203,7 +210,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 2.1.9
+rubygems_version: 2.4.6
 signing_key:
 specification_version: 4
 summary: Kill Bill client library.