xeroizer 2.18.1 → 3.0.1

data/lib/xeroizer.rb

@@ -5,6 +5,7 @@ require 'active_support/inflector'
 require "active_support/core_ext/array"
 require "active_support/core_ext/big_decimal/conversions"
 require 'oauth'
+require 'oauth2'
 require 'oauth/signature/rsa/sha1'
 require 'nokogiri'
 require 'builder'
@@ -17,14 +18,17 @@ $: << File.expand_path(File.dirname(__FILE__))
 require 'class_level_inheritable_attributes'
 require 'xeroizer/exceptions'
 require 'xeroizer/oauth'
+require 'xeroizer/oauth2'
 require 'xeroizer/http_encoding_helper'
 require 'xeroizer/http'
+require 'xeroizer/connection'
 
 require 'xeroizer/record/base_model'
 require 'xeroizer/record/payroll_base_model'
 require 'xeroizer/record/base'
 require 'xeroizer/record/payroll_base'
 require 'xeroizer/configuration'
+require 'xeroizer/http_response'
 
 # Include models
 require 'xeroizer/models/account'
@@ -33,6 +37,7 @@ require 'xeroizer/models/allocation'
 require 'xeroizer/models/branding_theme'
 require 'xeroizer/models/bank_transaction'
 require 'xeroizer/models/bank_account'
+require 'xeroizer/models/batch_payment'
 require 'xeroizer/models/from_bank_account'
 require 'xeroizer/models/to_bank_account'
 require 'xeroizer/models/bank_transfer'
@@ -42,6 +47,7 @@ require 'xeroizer/models/credit_note'
 require 'xeroizer/models/currency'
 require 'xeroizer/models/employee'
 require 'xeroizer/models/expense_claim'
+require 'xeroizer/models/history_record'
 require 'xeroizer/models/invoice'
 require 'xeroizer/models/invoice_reminder'
 require 'xeroizer/models/online_invoice'
@@ -56,10 +62,12 @@ require 'xeroizer/models/manual_journal_line'
 require 'xeroizer/models/option'
 require 'xeroizer/models/organisation'
 require 'xeroizer/models/payment'
+require 'xeroizer/models/payment_service'
 require 'xeroizer/models/prepayment'
 require 'xeroizer/models/overpayment'
 require 'xeroizer/models/phone'
 require 'xeroizer/models/purchase_order'
+require 'xeroizer/models/quote'
 require 'xeroizer/models/receipt'
 require 'xeroizer/models/repeating_invoice'
 require 'xeroizer/models/schedule'
@@ -72,16 +80,37 @@ require 'xeroizer/models/journal_line_tracking_category'
 require 'xeroizer/models/contact_sales_tracking_category'
 require 'xeroizer/models/contact_purchases_tracking_category'
 
-require 'xeroizer/models/payroll/home_address'
 require 'xeroizer/models/payroll/bank_account'
+require 'xeroizer/models/payroll/benefit_line'
+require 'xeroizer/models/payroll/benefit_type'
+require 'xeroizer/models/payroll/deduction_line'
+require 'xeroizer/models/payroll/deduction_type'
+require 'xeroizer/models/payroll/earnings_line'
+require 'xeroizer/models/payroll/earnings_type'
 require 'xeroizer/models/payroll/employee'
+require 'xeroizer/models/payroll/address'
+require 'xeroizer/models/payroll/leave_line'
+require 'xeroizer/models/payroll/pay_items'
+require 'xeroizer/models/payroll/pay_run'
+require 'xeroizer/models/payroll/pay_template'
+require 'xeroizer/models/payroll/payment_method'
+require 'xeroizer/models/payroll/pay_schedule'
+require 'xeroizer/models/payroll/paystub'
+require 'xeroizer/models/payroll/reimbursement_line'
+require 'xeroizer/models/payroll/reimbursement_type'
+require 'xeroizer/models/payroll/salary_and_wage'
+require 'xeroizer/models/payroll/super_line'
+require 'xeroizer/models/payroll/tax_declaration'
+require 'xeroizer/models/payroll/time_off_line'
+require 'xeroizer/models/payroll/time_off_type'
+require 'xeroizer/models/payroll/work_location'
+require 'xeroizer/models/payroll/leave_application'
+require 'xeroizer/models/payroll/leave_period'
 
 require 'xeroizer/report/factory'
 
 require 'xeroizer/response'
 
 require 'xeroizer/generic_application'
-require 'xeroizer/public_application'
-require 'xeroizer/private_application'
-require 'xeroizer/partner_application'
+require 'xeroizer/oauth2_application'
 require 'xeroizer/payroll_application'

data/test/acceptance/about_creating_bank_transactions_test.rb

@@ -4,40 +4,67 @@ require "acceptance_test"
 class AboutCreatingBankTransactions < Test::Unit::TestCase
   include AcceptanceTest
 
-  let :client do
-    Xeroizer::PrivateApplication.new(@consumer_key, @consumer_secret, @key_file)
+  def assert_exists(bank_transaction, client)
+    assert_not_nil bank_transaction.id,
+                   "Cannot check for exitence unless the bank transaction has non-null identifier"
+    assert_not_nil client.BankTransaction.find bank_transaction.id
+  end
+
+  def any_line_items(account)
+    [{
+         :description => "Clingfilm bike shorts",
+         :quantity => 1,
+         :unit_amount => "17.00",
+         :account_code => account.code,
+         :tax_type => account.tax_type
+     }]
+  end
+
+  def get_inclusive_tax(amount, tax_rate)
+    inclusive_tax = amount * (1 - (100/(100 + tax_rate)))
+    BigDecimal(inclusive_tax.to_s).round(2)
+  end
+
+  def get_exclusive_tax(amount, tax_rate)
+    exclusive_tax = amount * (tax_rate/100)
+    BigDecimal(exclusive_tax.to_s).round(2)
+  end
+
+  def get_tax_rate(tax_type, client)
+    @all_tax_types ||= client.TaxRate.all
+    @all_tax_types.select{|tax_rate| tax_rate.tax_type == tax_type}.first
   end
 
-  def setup
-    super
-    all_accounts = client.Account.all
+  setup do
+    @client = AcceptanceTestHelpers.oauth2_client
+    all_accounts = @client.Account.all
     @account = all_accounts.select{|acct| acct.status == "ACTIVE" && acct.type == "REVENUE"}.first
-    @bank_account = all_accounts.select{|acct| acct.status == "ACTIVE" && acct.type == "BANK"}.first    
+    @bank_account = all_accounts.select{|acct| acct.status == "ACTIVE" && acct.type == "BANK"}.first
   end
 
   can "create a new SPEND bank transaction" do
-    new_transaction = client.BankTransaction.build(
-      :type => "SPEND",
-      :contact => { :name => "Jazz Kang" },
-      :line_items => any_line_items(@account),
-      :bank_account => { :account_id => @bank_account.account_id }
+    new_transaction = @client.BankTransaction.build(
+        :type => "SPEND",
+        :contact => { :name => "Jazz Kang" },
+        :line_items => any_line_items(@account),
+        :bank_account => { :account_id => @bank_account.account_id }
     )
 
     assert new_transaction.save, "Save failed with the following errors: #{new_transaction.errors.inspect}"
-    assert_exists new_transaction
+    assert_exists(new_transaction, @client)
   end
 
   can "update a SPEND bank transaction, for example by setting its status" do
-    new_transaction = client.BankTransaction.build(
-      :type => "SPEND",
-      :contact => { :name => "Jazz Kang" },
-      :line_items => any_line_items(@account),
-      :bank_account => { :account_id => @bank_account.account_id }
+    new_transaction = @client.BankTransaction.build(
+        :type => "SPEND",
+        :contact => { :name => "Jazz Kang" },
+        :line_items => any_line_items(@account),
+        :bank_account => { :account_id => @bank_account.account_id }
     )
 
     assert new_transaction.save, "Save failed with the following errors: #{new_transaction.errors.inspect}"
 
-    assert_exists new_transaction
+    assert_exists new_transaction, @client
 
     the_new_type = "RECEIVE"
 
@@ -49,110 +76,81 @@ class AboutCreatingBankTransactions < Test::Unit::TestCase
 
     assert_equal expected_id, new_transaction.id, "Expected the id to be the same because it has been updated"
 
-    refreshed_bank_transaction = client.BankTransaction.find expected_id
+    refreshed_bank_transaction = @client.BankTransaction.find expected_id
 
     assert_equal the_new_type, refreshed_bank_transaction.type,
-      "Expected the bank transaction to've had its type updated"
+                 "Expected the bank transaction to've had its type updated"
   end
 
   can "update a bank transaction by adding line items provided you calculate the tax_amount correctly" do
-    new_transaction = client.BankTransaction.build(
-      :type => "SPEND",
-      :contact => { :name => "Jazz Kang" },
-      :line_items => any_line_items(@account),
-      :bank_account => { :account_id => @bank_account.account_id },
-      :line_amount_types => "Exclusive"
+    new_transaction = @client.BankTransaction.build(
+        :type => "SPEND",
+        :contact => { :name => "Jazz Kang" },
+        :line_items => any_line_items(@account),
+        :bank_account => { :account_id => @bank_account.account_id },
+        :line_amount_types => "Exclusive"
     )
 
     assert new_transaction.save, "Save failed with the following errors: #{new_transaction.errors.inspect}"
-    assert_exists new_transaction
+    assert_exists new_transaction, @client
 
     expected_id = new_transaction.id
 
-    tax_rate = get_tax_rate(@account.tax_type).effective_rate
+    tax_rate = get_tax_rate(@account.tax_type, @client).effective_rate
 
     unit_price = BigDecimal("1337.00")
 
     the_new_line_items = [
-      {
-        :description => "Burrito skin",
-        :quantity => 1,
-        :unit_amount => unit_price,
-        :account_code => @account.code,
-        :tax_type => @account.tax_type,
-        :tax_amount => get_exclusive_tax(unit_price, tax_rate)
-      }
+        {
+            :description => "Burrito skin",
+            :quantity => 1,
+            :unit_amount => unit_price,
+            :account_code => @account.code,
+            :tax_type => @account.tax_type,
+            :tax_amount => get_exclusive_tax(unit_price, tax_rate)
+        }
     ]
 
     new_transaction.line_items = the_new_line_items
 
     assert new_transaction.save, "Update failed with the following errors: #{new_transaction.errors.inspect}"
 
-    refreshed_bank_transaction = client.BankTransaction.find expected_id
+    refreshed_bank_transaction = @client.BankTransaction.find expected_id
 
     assert_equal expected_id, new_transaction.id,
-      "Expected the id to be the same because it has been updated"
+                 "Expected the id to be the same because it has been updated"
 
     assert_equal 1, refreshed_bank_transaction.line_items.size,
-      "Expected the bank transaction to've had its line items updated to just one"
+                 "Expected the bank transaction to've had its line items updated to just one"
 
     the_first_line_item = refreshed_bank_transaction.line_items.first
 
     assert_equal "Burrito skin", the_first_line_item.description,
-      "Expected the bank transaction to've had its line items updated, " +
-      "but the first one's description does not match: #{the_first_line_item.inspect}"
-  end
-
-  def get_inclusive_tax(amount, tax_rate)
-    inclusive_tax = amount * (1 - (100/(100 + tax_rate)))
-    BigDecimal(inclusive_tax.to_s).round(2)
-  end
-
-  def get_exclusive_tax(amount, tax_rate)
-    exclusive_tax = amount * (tax_rate/100)
-    BigDecimal(exclusive_tax.to_s).round(2)
-  end
-
-  def get_tax_rate tax_type
-    @all_tax_types ||= client.TaxRate.all
-    @all_tax_types.select{|tax_rate| tax_rate.tax_type == tax_type}.first
+                 "Expected the bank transaction to've had its line items updated, " +
+                     "but the first one's description does not match: #{the_first_line_item.inspect}"
   end
 
   can "create a new RECEIVE bank transaction" do
-    new_transaction = client.BankTransaction.build(
-      :type => "RECEIVE",
-      :contact => { :name => "Jazz Kang" },
-      :line_items => any_line_items(@account),
-      :bank_account => { :account_id => @bank_account.account_id }
+    new_transaction = @client.BankTransaction.build(
+        :type => "RECEIVE",
+        :contact => { :name => "Jazz Kang" },
+        :line_items => any_line_items(@account),
+        :bank_account => { :account_id => @bank_account.account_id }
     )
 
     assert new_transaction.save, "Save failed with the following errors: #{new_transaction.errors.inspect}"
-    assert_exists new_transaction
+    assert_exists new_transaction, @client
   end
 
   it "treats line item unit_amounts as tax EXCLUSIVE"
   must "not set the tax_amount manually on line items"
 
-  def assert_exists(bank_transaction)
-    assert_not_nil bank_transaction.id,
-      "Cannot check for exitence unless the bank transaction has non-null identifier"
-    assert_not_nil client.BankTransaction.find bank_transaction.id
-  end
 
-  def any_line_items(account)
-    [{
-      :description => "Clingfilm bike shorts",
-      :quantity => 1,
-      :unit_amount => "17.00",
-      :account_code => account.code,
-      :tax_type => account.tax_type
-    }]
-  end
 
   it "fails with ApiException when you try and create a new bank account with missing account type with save! method" do
-    new_account = client.Account.build(
-      :name => "Example bank account",
-      :code => "ACC-001"
+    new_account = @client.Account.build(
+        :name => "Example bank account",
+        :code => "ACC-001"
     )
 
     assert_raise Xeroizer::ApiException do
@@ -161,9 +159,9 @@ class AboutCreatingBankTransactions < Test::Unit::TestCase
   end
 
   it "returns false when you try and create a new bank account with a missing account type with save method" do
-    new_account = client.Account.build(
-      :name => "Example bank account",
-      :code => "ACC-001"
+    new_account = @client.Account.build(
+        :name => "Example bank account",
+        :code => "ACC-001"
     )
 
     assert new_account.save == false, "Account save method expected to return false"

data/test/acceptance/about_creating_prepayment_test.rb

@@ -4,43 +4,38 @@ require "acceptance_test"
 class AboutCreatingPrepayment < Test::Unit::TestCase
   include AcceptanceTest
 
-  let :client do
-    Xeroizer::PrivateApplication.new(@consumer_key, @consumer_secret, @key_file)
+  def any_line_items(account)
+    [{
+         :description => "Clingfilm bike shorts",
+         :quantity => 1,
+         :unit_amount => "200.00",
+         :account_code => account.code,
+         :tax_type => account.tax_type
+     }]
+  end
+
+  def assert_exists(prepayment, client)
+    assert_not_nil prepayment.id,
+                   "Cannot check for exitence unless the prepayment (bank transaction) has non-null identifier"
+    assert_not_nil client.BankTransaction.find prepayment.id
   end
 
-  def setup
-    super
-    all_accounts = client.Account.all
+  setup do
+    @client = AcceptanceTestHelpers.oauth2_client
+    all_accounts = @client.Account.all
     @account = all_accounts.select{|acct| acct.status == "ACTIVE" && acct.type == "REVENUE"}.first
-    @bank_account = all_accounts.select{|acct| acct.status == "ACTIVE" && acct.type == "BANK"}.first    
+    @bank_account = all_accounts.select{|acct| acct.status == "ACTIVE" && acct.type == "BANK"}.first
   end
 
   can "create a new PrePayment bank transaction" do
-    new_transaction = client.BankTransaction.build(
-      :type => "RECEIVE-PREPAYMENT",
-      :contact => { :name => "Jazz Kang" },
-      :line_items => any_line_items(@account),
-      :bank_account => { :account_id => @bank_account.account_id }
+    new_transaction = @client.BankTransaction.build(
+        :type => "RECEIVE-PREPAYMENT",
+        :contact => { :name => "Jazz Kang" },
+        :line_items => any_line_items(@account),
+        :bank_account => { :account_id => @bank_account.account_id }
     )
 
     assert new_transaction.save, "Save failed with the following errors: #{new_transaction.errors.inspect}"
-    assert_exists new_transaction
+    assert_exists new_transaction, @client
   end
-
-  def any_line_items(account)
-    [{
-      :description => "Clingfilm bike shorts",
-      :quantity => 1,
-      :unit_amount => "200.00",
-      :account_code => account.code,
-      :tax_type => account.tax_type
-    }]
-  end
-
-  def assert_exists(prepayment)
-    assert_not_nil prepayment.id,
-      "Cannot check for exitence unless the prepayment (bank transaction) has non-null identifier"
-    assert_not_nil client.BankTransaction.find prepayment.id
-  end
-
-end
+end

data/test/acceptance/about_fetching_bank_transactions_test.rb

@@ -5,40 +5,40 @@ require "bank_transaction_reference_data"
 class AboutFetchingBankTransactions < Test::Unit::TestCase
   include AcceptanceTest
 
-  def client
-    @client ||= Xeroizer::PrivateApplication.new(@consumer_key, @consumer_secret, @key_file)
+  setup do
+    @client = AcceptanceTestHelpers.oauth2_client
   end
 
   context "when requesting a single bank transaction with a reference" do
     setup do
-      @a_new_bank_transaction = BankTransactionReferenceData.new(client).bank_transaction
+      @a_new_bank_transaction = BankTransactionReferenceData.new(@client).bank_transaction
     end
 
     it "has the extended set of attributes" do
       keys = [:line_amount_types, :contact, :date, :status, :line_items,
               :updated_date_utc, :currency_code, :bank_transaction_id,
               :bank_account, :type, :reference, :is_reconciled, :currency_rate]
-      assert_equal(@a_new_bank_transaction.attributes.keys, keys)
+      assert_equal(keys, @a_new_bank_transaction.attributes.keys)
     end
 
     it "returns full line item details" do
-      single_bank_transaction = client.BankTransaction.find @a_new_bank_transaction.id
+      single_bank_transaction = @client.BankTransaction.find @a_new_bank_transaction.id
 
       assert_not_empty single_bank_transaction.line_items,
-        "expected the bank transaction's line items to have been included"
+                       "expected the bank transaction's line items to have been included"
     end
   end
 
   context "when requesting all bank transactions (i.e., without filter)" do
     setup do
-      @the_first_bank_transaction = client.BankTransaction.all.first
+      @the_first_bank_transaction = @client.BankTransaction.all.detect { |trans| trans.attributes.keys.include?(:reference) }
     end
 
     it "has the limited set of attributes" do
-      keys = [:line_amount_types, :contact, :date, :status, :updated_date_utc, 
-              :currency_code, :bank_transaction_id, :bank_account, :type, :reference, 
-              :is_reconciled]
-      assert_equal(@the_first_bank_transaction.attributes.keys, keys)
+      keys = [:line_amount_types, :contact, :date, :status, :updated_date_utc,
+              :currency_code, :bank_transaction_id, :bank_account, :type, :reference,
+              :is_reconciled, :has_attachments]
+      assert_equal(keys, @the_first_bank_transaction.attributes.keys)
     end
 
     it "returns contact" do
@@ -49,5 +49,5 @@ class AboutFetchingBankTransactions < Test::Unit::TestCase
       assert_not_nil @the_first_bank_transaction.bank_account
     end
   end
-end
 
+end

data/test/acceptance/about_online_invoice_test.rb

@@ -4,17 +4,13 @@ require "acceptance_test"
 class AboutGetOnlineInvoiceUrl < Test::Unit::TestCase
   include AcceptanceTest
 
-  let :client do
-    Xeroizer::PrivateApplication.new(@consumer_key, @consumer_secret, @key_file)
+  setup do
+    @client = AcceptanceTestHelpers.oauth2_client
+    @invoice = @client.Invoice.all(:where => 'Type=="ACCREC"').first
+    @invoice_acc_pay = @client.Invoice.all(:where => 'Type=="ACCPAY"').first
   end
 
-  def setup
-    super
-    @invoice = client.Invoice.all(:where => 'Type=="ACCREC"').first
-    @invoice_acc_pay = client.Invoice.all(:where => 'Type=="ACCPAY"').first
-  end
-
-  can "Request OnlineInvoice of an AccRec invoice" do 
+  can "Request OnlineInvoice of an AccRec invoice" do
     @online_invoice = @invoice.online_invoice
 
     assert @online_invoice.online_invoice_url, "online_invoice_url not found"
@@ -26,4 +22,4 @@ class AboutGetOnlineInvoiceUrl < Test::Unit::TestCase
       @online_invoice_acc_pay = @invoice_acc_pay.online_invoice
     end
   end
-end
+end

data/test/acceptance/acceptance_test.rb

@@ -1,7 +1,35 @@
+module AcceptanceTestHelpers
+  def self.oauth2_client
+    config = self.load_oauth2_config_from_env
+    Xeroizer::OAuth2Application.new(
+      config.client_id,
+      config.client_secret,
+      access_token: config.access_token,
+      tenant_id: config.tenant_id
+    )
+  end
+
+  def self.load_oauth2_config_from_env
+    raise "No XERO_CLIENT_ID environment variable specified." unless ENV["XERO_CLIENT_ID"]
+    raise "No XERO_CLIENT_SECRET environment variable specified." unless ENV["XERO_CLIENT_SECRET"]
+    raise "No XERO_ACCESS_TOKEN environment variable specified." unless ENV["XERO_ACCESS_TOKEN"]
+    raise "No XERO_TENANT_ID environment variable specified." unless ENV["XERO_TENANT_ID"]
+
+    OpenStruct.new(client_id: ENV["XERO_CLIENT_ID"],
+      client_secret: ENV["XERO_CLIENT_SECRET"],
+      access_token: ENV["XERO_ACCESS_TOKEN"],
+      tenant_id: ENV["XERO_TENANT_ID"])
+  end
+end
+
 module AcceptanceTest
   class << self
     def included(klass)
       klass.class_eval do
+        def self.it_works_using_oauth2(&block)
+          instance_exec(AcceptanceTestHelpers.oauth2_client, 'oauth2', &block)
+        end
+
         def self.log_to_console
           Xeroizer::Logging.const_set :Log, Xeroizer::Logging::StdOutLog
         end
@@ -24,30 +52,4 @@ module AcceptanceTest
       end
     end
   end
-
-  def setup
-    config = load_config_from_file || load_config_from_env
-
-    @key_file = config.key_file
-    @consumer_key = config.consumer_key
-    @consumer_secret = config.consumer_secret
-  end
-
-  private
-
-  def load_config_from_file
-    the_file_name = File.join(File.dirname(__FILE__), '..', '..', '.oauth')
-
-    return nil unless File.exist? the_file_name
-
-    Xeroizer::OAuthConfig.load IO.read the_file_name
-  end
-
-  def load_config_from_env
-    assert_not_nil ENV["CONSUMER_KEY"], "No CONSUMER_KEY environment variable specified."
-    assert_not_nil ENV["CONSUMER_SECRET"], "No CONSUMER_SECRET environment variable specified."
-    assert_not_nil ENV["PRIVATE_KEY_PATH"], "No PRIVATE_KEY_PATH environment variable specified."
-    assert File.exist?(ENV["PRIVATE_KEY_PATH"]), "The file <#{ENV["PRIVATE_KEY_PATH"]}> does not exist."
-    Xeroizer::OAuthCredentials.new ENV["CONSUMER_KEY"], ENV["CONSUMER_SECRET"], ENV["PRIVATE_KEY_PATH"]
-  end
 end

data/test/acceptance/bank_transfer_test.rb

@@ -4,23 +4,18 @@ require "acceptance_test"
 class BankTransfer < Test::Unit::TestCase
   include AcceptanceTest
 
-  let :client do
-    Xeroizer::PrivateApplication.new(@consumer_key, @consumer_secret, @key_file)
-  end
-
-  def setup
-    super
-    all_accounts = client.Account.all
-    @from_bank_account = all_accounts.select { |acct| acct.status == "ACTIVE" && acct.type == "BANK" }.first
-    @to_bank_account = all_accounts.select { |acct| acct.status == "ACTIVE" && acct.type == "BANK" }.last
-  end
+  it_works_using_oauth2 do |client, client_type|
+    can "create a bank for #{client_type}" do
+      all_accounts = client.Account.all
+      @from_bank_account = all_accounts.select { |acct| acct.status == "ACTIVE" && acct.type == "BANK" }.first
+      @to_bank_account = all_accounts.select { |acct| acct.status == "ACTIVE" && acct.type == "BANK" }.last
 
-  can "create a bank transfer" do
-    new_transfer = client.BankTransfer.build(
-      :amount => 300,
-      :from_bank_account => { :account_id => @from_bank_account.account_id },
-      :to_bank_account => { :account_id => @to_bank_account.account_id }
-    )
-    assert new_transfer.save, "Save failed with the following errors: #{new_transfer.errors.inspect}"
+      new_transfer = client.BankTransfer.build(
+          :amount => 300,
+          :from_bank_account => { :account_id => @from_bank_account.account_id },
+          :to_bank_account => { :account_id => @to_bank_account.account_id }
+      )
+      assert new_transfer.save, "Save failed with the following errors: #{new_transfer.errors.inspect}"
+    end
   end
 end

data/test/acceptance/bulk_operations_test.rb

@@ -1,5 +1,8 @@
 require "test_helper"
 require "acceptance_test"
+require "shoulda/matchers"
+
+include Shoulda::Matchers
 
 class BulkOperationsTest < Test::Unit::TestCase
   include AcceptanceTest
@@ -8,18 +11,17 @@ class BulkOperationsTest < Test::Unit::TestCase
     "test-person-#{rand 1000000000}"
   end
 
-  def setup
-    super
-    @client = Xeroizer::PrivateApplication.new(@consumer_key, @consumer_secret, @key_file)
+  setup do
+    @client = AcceptanceTestHelpers.oauth2_client
   end
 
-  can "create multiple invoices at once" do
+  should "create multiple invoices at once" do
     c1, c2 = nil, nil
     assert_true(
-      @client.Contact.batch_save do
-        c1 = @client.Contact.build(name: random_name)
-        c2 = @client.Contact.build(name: random_name)
-      end
+        @client.Contact.batch_save do
+          c1 = @client.Contact.build(name: random_name)
+          c2 = @client.Contact.build(name: random_name)
+        end
     )
     [c1, c2].each {|c| assert_false c.new_record? }
   end
@@ -27,11 +29,11 @@ class BulkOperationsTest < Test::Unit::TestCase
   can "create and update new records in bulk" do
     c1, c2 = nil, nil
     assert_true(
-      @client.Contact.batch_save do
-        c1 = @client.Contact.create(name: random_name)
-        c1.email_address = "foo@bar.com"
-        c2 = @client.Contact.build(name: random_name)
-      end
+        @client.Contact.batch_save do
+          c1 = @client.Contact.create(name: random_name)
+          c1.email_address = "foo@bar.com"
+          c2 = @client.Contact.build(name: random_name)
+        end
     )
     [c1, c2].each {|c| assert_false c.new_record? }
     c1.download_complete_record!
@@ -40,9 +42,9 @@ class BulkOperationsTest < Test::Unit::TestCase
 
   can "return false from #batch_save if validation fails" do
     assert_false(
-      @client.Contact.batch_save do
-        @client.Contact.build(email_address: "guy-with-no-name@example.com")
-      end
+        @client.Contact.batch_save do
+          @client.Contact.build(email_address: "guy-with-no-name@example.com")
+        end
     )
   end
 end