xeroizer-3-pre-beta 3.0.0.pre.beta

data/test/unit/models/address_test.rb

@@ -0,0 +1,92 @@
+require 'unit_test_helper'
+
+class AddressTest < Test::Unit::TestCase
+  include TestHelper
+
+  def setup
+    @client = Xeroizer::PublicApplication.new(CONSUMER_KEY, CONSUMER_SECRET)
+    @contact = @client.Contact.build
+  end
+
+  def build_valid_address
+    @contact.add_address({
+      :type => "DEFAULT",
+      :address_line1 => "Baker street",
+      :address_line2 => "221",
+      :address_line3 => "Appartment: B",
+      :address_line4 => "abcdefgh",
+      :city => "London",
+      :region => "Marylebone",
+      :postal_code => "NW1 6XE",
+      :country => "UK",
+      :attention_to => "Mr Sherlock Holmes"
+    })
+  end
+
+  def generate_random_string(size)
+    charset = %w{A C D E F G H J K M N P Q R T V W X Y Z}
+    (0...size).map{ charset.to_a[rand(charset.size)] }.join
+  end
+
+   context "validators" do
+
+    should "allow valid address with valid attributes" do
+      address = build_valid_address
+      assert_equal(true, address.valid?)
+    end
+
+    should "not allow address_line1 to be longer than 500 characters" do
+      address = build_valid_address
+      address.line1 = generate_random_string(501)
+      assert_equal(false, address.valid?)
+    end
+
+    should "not allow address_line2 to be longer than 500 characters" do
+      address = build_valid_address
+      address.line2 = generate_random_string(501)
+      assert_equal(false, address.valid?)
+    end
+    should "not allow address_line3 to be longer than 500 characters" do
+      address = build_valid_address
+      address.line3 = generate_random_string(501)
+      assert_equal(false, address.valid?)
+    end
+
+    should "not allow address_line4 to be longer than 500 characters" do
+      address = build_valid_address
+      address.line4 = generate_random_string(501)
+      assert_equal(false, address.valid?)
+    end
+
+
+    should "not allow city to be longer than 255 characters" do
+      address = build_valid_address
+      address.city = generate_random_string(256)
+      assert_equal(false, address.valid?)
+    end
+
+    should "not allow region to be longer than 255 characters" do
+      address = build_valid_address
+      address.region = generate_random_string(256)
+      assert_equal(false, address.valid?)
+    end
+
+    should "not allow postal_code to be longer than 50 characters" do
+      address = build_valid_address
+      address.postal_code = generate_random_string(51)
+      assert_equal(false, address.valid?)
+    end
+
+    should "not allow country to be longer than 50 characters" do
+      address = build_valid_address
+      address.country = generate_random_string(51)
+      assert_equal(false, address.valid?)
+    end
+
+    should "not allow attention_to to be longer than 255 characters" do
+      address = build_valid_address
+      address.attention_to = generate_random_string(256)
+      assert_equal(false, address.valid?)
+    end
+  end
+end

data/test/unit/models/bank_transaction_model_parsing_test.rb

@@ -0,0 +1,133 @@
+require 'unit_test_helper'
+
+class BankTransactionModelParsingTest < Test::Unit::TestCase
+  def setup
+    # See lib/xeroizer/record/base_model.rb
+    @instance = Xeroizer::Record::BankTransactionModel.new(nil, "BankTransaction")
+  end
+
+  must "parse all the root elements except sub_total, total_tax and total" do
+    some_xml = "
+     <Response>
+        <BankTransactions>
+          <BankTransaction>
+            <Date>2010-07-30T00:00:00</Date>
+            <LineAmountTypes>Inclusive</LineAmountTypes>
+            <SubTotal>15.00</SubTotal>
+            <TotalTax>0.00</TotalTax>
+            <Total>15.00</Total>
+            <UpdatedDateUTC>2008-02-20T12:19:56.657</UpdatedDateUTC>
+            <FullyPaidOnDate>2010-07-30T00:00:00</FullyPaidOnDate>
+            <BankTransactionID>d20b6c54-7f5d-4ce6-ab83-55f609719126</BankTransactionID>
+            <Type>SPEND</Type>
+            <IsReconciled>true</IsReconciled>
+          </BankTransaction>
+        </BankTransactions>
+    </Response>"
+
+    result = @instance.parse_response(some_xml)
+
+    the_bank_transaction = result.response_items.first
+
+    assert_equal Date.parse("2010-07-30T00:00:00"), the_bank_transaction.date
+    assert_equal "Inclusive", the_bank_transaction.line_amount_types
+
+    assert_equal(Time.parse("2008-02-20T12:19:56.657Z"), the_bank_transaction.updated_date_utc)
+
+    assert_equal Date.parse("2010-07-30T00:00:00"), the_bank_transaction.fully_paid_on_date
+    assert_equal "d20b6c54-7f5d-4ce6-ab83-55f609719126", the_bank_transaction.bank_transaction_id
+    assert_equal "SPEND", the_bank_transaction.type
+    assert the_bank_transaction.reconciled?, "Expected reconciled to be true"
+  end
+
+  must "parse the contact" do
+    some_xml_with_a_contact = "
+     <Response>
+        <BankTransactions>
+          <BankTransaction>
+            <Contact>
+              <ContactID>c09661a2-a954-4e34-98df-f8b6d1dc9b19</ContactID>
+              <ContactStatus>ACTIVE</ContactStatus>
+              <Name>BNZ</Name>
+              <Addresses>
+                <Address>
+                  <AddressType>POBOX</AddressType>
+                </Address>
+                <Address>
+                  <AddressType>STREET</AddressType>
+                </Address>
+              </Addresses>
+              <Phones>
+                <Phone>
+                  <PhoneType>MOBILE</PhoneType>
+                </Phone>
+              </Phones>
+              <UpdatedDateUTC>2010-09-17T19:26:39.157</UpdatedDateUTC>
+            </Contact>
+          </BankTransaction>
+        </BankTransactions>
+    </Response>"
+
+    result = @instance.parse_response(some_xml_with_a_contact)
+    the_bank_transaction = result.response_items.first
+    the_contact = the_bank_transaction.contact
+
+    assert_equal(
+      "c09661a2-a954-4e34-98df-f8b6d1dc9b19",
+      the_contact.contact_id,
+      "Mismatched contact id for contact: #{the_contact.inspect}"
+    )
+  end
+
+  must "parse the correct number of line items" do
+    some_xml_with_a_line_item = "
+     <Response>
+        <BankTransactions>
+          <BankTransaction>
+            <LineItems>
+              <LineItem>
+                <Description>Monthly account fee</Description>
+                <UnitAmount>15</UnitAmount>
+                <TaxType>NONE</TaxType>
+                <TaxAmount>0.00</TaxAmount>
+                <LineAmount>15.00</LineAmount>
+                <AccountCode>404</AccountCode>
+                <Quantity>1.0000</Quantity>
+              </LineItem>
+            </LineItems>
+          </BankTransaction>
+        </BankTransactions>
+    </Response>"
+
+    result = @instance.parse_response(some_xml_with_a_line_item)
+    the_bank_transaction = result.response_items.first
+
+    assert_equal(1, the_bank_transaction.line_items.size,
+      "Mismatched number of line items: #{the_bank_transaction.inspect}"
+    )
+  end
+
+  must "parse the bank account" do
+    some_xml_with_a_bank_account = "
+     <Response>
+        <BankTransactions>
+          <BankTransaction>
+            <BankAccount>
+              <AccountID>297c2dc5-cc47-4afd-8ec8-74990b8761e9</AccountID>
+              <Code>BANK</Code>
+            </BankAccount>
+          </BankTransaction>
+        </BankTransactions>
+    </Response>"
+
+    result = @instance.parse_response(some_xml_with_a_bank_account)
+    the_bank_transaction = result.response_items.first
+
+    assert_not_nil(the_bank_transaction.bank_account,
+      "Missing bank_account: #{the_bank_transaction.inspect}"
+    )
+
+    assert_equal "297c2dc5-cc47-4afd-8ec8-74990b8761e9", the_bank_transaction.bank_account.account_id,
+      "Unexpected bank account id: #{the_bank_transaction.inspect}"
+  end
+end

data/test/unit/models/bank_transaction_test.rb

@@ -0,0 +1,44 @@
+require 'unit_test_helper'
+
+class BankTransactionTest < Test::Unit::TestCase
+  include Xeroizer::Record
+
+  def setup
+
+    the_line_items = [
+      LineItem.build({:quantity => 1, :unit_amount => 1.00, :tax_amount => 0.50}, nil),
+      LineItem.build({:quantity => 1, :unit_amount => 1.00, :tax_amount => 0.50}, nil)
+    ]
+
+    @the_bank_transaction = BankTransaction.new(nil)
+    @the_bank_transaction.line_items = the_line_items
+  end
+
+  context "given a bank_transaction with line_amount_types set to \"Exclusive\"" do
+    setup do
+      @the_bank_transaction.line_amount_types = "Exclusive"
+    end
+
+    must "calculate the total as the sum of its line item line_amount and tax_amount" do
+      assert_equal "3.0", @the_bank_transaction.total.to_s
+    end
+
+    must "calculate the sub_total as the sum of the line_amounts" do
+      assert_equal "2.0", @the_bank_transaction.sub_total.to_s
+    end
+  end
+
+  context "given a bank_transaction with line_amount_types set to \"Inclusive\"" do
+    setup do
+      @the_bank_transaction.line_amount_types = "Inclusive"
+    end
+
+    must "calculate the total as the sum of its line item line_amount and tax_amount" do
+      assert_equal "2.0", @the_bank_transaction.total.to_s
+    end
+
+    must "calculate the sub_total as the sum of the line_amounts minus the total tax" do
+      assert_equal "1.0", @the_bank_transaction.sub_total.to_s
+    end
+  end
+end

data/test/unit/models/bank_transaction_validation_test.rb

@@ -0,0 +1,115 @@
+require 'unit_test_helper'
+
+class BankTransactionValidationTest < Test::Unit::TestCase
+  include Xeroizer::Record
+
+  must "supply either SPEND or RECEIVE as the type" do
+    instance = BankTransaction.build({:type => "xxx"}, nil)
+
+    assert false == instance.valid?, "Expected invalid because of invalid type"
+
+    expected_error = "Invalid type. Expected one of https://developer.xero.com/documentation/api/types#BankTransactionTypes"
+
+    assert_equal expected_error, instance.errors_for(:type).first, "Expected an error about type"
+
+    instance = BankTransaction.build({:type => "SPEND"}, nil)
+
+    instance.valid?
+
+    assert_empty instance.errors_for(:type), "Expected no error about type"
+
+    instance = BankTransaction.build({:type => "RECEIVE"}, nil)
+
+    instance.valid?
+
+    assert_empty instance.errors_for(:type), "Expected no error about type"
+  end
+
+  can "omit the status attribute" do
+    instance = BankTransaction.build({}, nil)
+    instance.valid?
+    assert_empty instance.errors_for(:status), "Expected no error about status"
+  end
+
+  must "supply either AUTHORISED or DELETED as the status" do
+    instance = BankTransaction.build({:status => "xxx"}, nil)
+
+    assert false == instance.valid?, "Expected invalid because of invalid status"
+
+    expected_error = "not one of AUTHORISED, DELETED"
+
+    assert_equal expected_error, instance.errors_for(:status).first, "Expected an error about status"
+
+    instance = BankTransaction.build({:status => "AUTHORISED"}, nil)
+
+    instance.valid?
+
+    assert_empty instance.errors_for(:status), "Expected no error about status"
+
+    instance = BankTransaction.build({:status => "DELETED"}, nil)
+
+    instance.valid?
+
+    assert_empty instance.errors_for(:status), "Expected no error about status"
+  end
+
+  must "supply a non-blank contact" do
+    instance = BankTransaction.build({}, nil)
+
+    assert false == instance.valid?, "Expected invalid because of missing contact"
+
+    assert_equal "can't be blank", instance.errors_for(:contact).first,
+      "Expected an error about blank contact"
+  end
+
+  must "supply at least one line item" do
+    zero_line_items = []
+
+    instance = BankTransaction.build({:line_items => zero_line_items}, nil)
+
+    assert false == instance.valid?, "Expected invalid because of empty line items"
+
+    assert_equal "Invalid line items. Must supply at least one.", instance.errors_for(:line_items).first,
+      "Expected an error about blank line items"
+
+    one_line_item = [LineItem.build({}, nil)]
+
+    instance.errors.clear
+    instance.line_items = one_line_item
+
+    assert_empty instance.errors_for(:line_items), "expected no errors for one line item, #{instance.errors_for(:line_items)}"
+
+    more_than_one_line_item = [LineItem.build({}, nil), LineItem.build({}, nil)]
+
+    instance.errors.clear
+    instance.line_items = more_than_one_line_item
+
+    assert_empty instance.errors_for(:line_items), "expected no errors for more than one line item, #{instance.errors_for(:line_items)}"
+  end
+
+  must "supply a non-blank bank account" do
+    instance = BankTransaction.build({}, nil)
+
+    assert false == instance.valid?, "Expected invalid because of missing bank account"
+
+    assert_equal "can't be blank", instance.errors_for(:bank_account).first,
+      "Expected an error about blank contact"
+  end
+
+  must "supply valid line_amount_types value" do
+    instance = BankTransaction.build({
+      :line_amount_types => "XXX_ANYTHING_INVALID_XXX"
+    }, nil)
+
+    assert false == instance.valid?, "Expected invalid because of missing bank account"
+
+    assert_equal "not one of Exclusive, Inclusive, NoTax", instance.errors_for(:line_amount_types).first,
+      "Expected an error about blank contact"
+  end
+
+  must "line_amount_type defaults to \"Exclusive\"" do
+    instance = BankTransaction.build({}, nil)
+
+    assert_equal "Exclusive", instance.line_amount_types
+  end
+end

data/test/unit/models/contact_test.rb

@@ -0,0 +1,132 @@
+require 'unit_test_helper'
+
+class ContactTest < Test::Unit::TestCase
+  include TestHelper
+
+  def setup
+    @client = Xeroizer::PublicApplication.new(CONSUMER_KEY, CONSUMER_SECRET)
+  end
+
+  context "contact validators" do
+    should "have a name" do
+      contact = @client.Contact.build
+
+      assert_equal(false, contact.valid?)
+      blank_error = contact.errors_for(:name).first
+      assert_not_nil(blank_error)
+      assert_equal("can't be blank", blank_error)
+
+      contact.name = "SOMETHING"
+      assert_equal(true, contact.valid?)
+      assert_equal(0, contact.errors.size)
+    end
+
+    should "be able to have no name if it has a contact_id" do
+      contact = @client.Contact.build
+
+      assert_equal(false, contact.valid?)
+      contact.contact_id = "1-2-3"
+      assert_equal(true, contact.valid?)
+      assert_equal(0, contact.errors.size)
+    end
+
+    should "be able to have no name if it has a contact_number" do
+      contact = @client.Contact.build
+
+      assert_equal(false, contact.valid?)
+      contact.contact_number = "abc123"
+      assert_equal(true, contact.valid?)
+      assert_equal(0, contact.errors.size)
+    end
+
+    should "not allow invalid addresses" do
+      contact = @client.Contact.build(name: "SOMETHING")
+      address = contact.add_address(:type => "INVALID_TYPE")
+
+      assert_equal(false, contact.valid?)
+      invalid_error = contact.errors_for(:addresses).first
+      assert_not_nil(invalid_error)
+      assert_equal("must all be valid", invalid_error)
+
+      address.type = "DEFAULT"
+      assert_equal(true, contact.valid?)
+      assert_equal(0, contact.errors.size)
+    end
+  end
+
+  context "response parsing" do
+    it "parses default attributes" do
+      @instance = Xeroizer::Record::ContactModel.new(nil, "Contact")
+
+      some_xml = get_record_xml("contact")
+
+      result = @instance.parse_response(some_xml)
+      contact = result.response_items.first
+
+      keys = [:contact_id,
+              :contact_status,
+              :name,
+              :first_name,
+              :last_name,
+              :email_address,
+              :skype_user_name,
+              :bank_account_details,
+              :tax_number,
+              :accounts_receivable_tax_type,
+              :accounts_payable_tax_type,
+              :addresses,
+              :phones,
+              :updated_date_utc,
+              :is_supplier,
+              :is_customer,
+              :default_currency]
+
+      assert_equal(contact.attributes.keys, keys)
+    end
+
+    it "parses extra attributes when present" do
+      @instance = Xeroizer::Record::ContactModel.new(nil, "Contact")
+      some_xml = get_record_xml("contact_with_details")
+
+      result = @instance.parse_response(some_xml)
+      contact = result.response_items.first
+
+      keys = [:contact_id,
+              :contact_status,
+              :name,
+              :first_name,
+              :last_name,
+              :email_address,
+              :skype_user_name,
+              :bank_account_details,
+              :tax_number,
+              :accounts_receivable_tax_type,
+              :accounts_payable_tax_type,
+              :addresses,
+              :phones,
+              :updated_date_utc,
+              :is_supplier,
+              :is_customer,
+              :default_currency,
+              :balances,
+              :batch_payments,
+              :payment_terms]
+
+      assert_equal(contact.attributes.keys, keys)
+
+      assert_equal(contact.balances.accounts_receivable.outstanding, 849.50)
+      assert_equal(contact.balances.accounts_receivable.overdue, 910.00)
+      assert_equal(contact.balances.accounts_payable.outstanding, 0.00)
+      assert_equal(contact.balances.accounts_payable.overdue, 0.00)
+
+      assert_equal(contact.batch_payments.bank_account_number, "123456")
+      assert_equal(contact.batch_payments.bank_account_name, "bank account")
+      assert_equal(contact.batch_payments.details, "details")
+
+      assert_equal(contact.payment_terms.bills.day, "4")
+      assert_equal(contact.payment_terms.bills.type, "OFFOLLOWINGMONTH")
+      assert_equal(contact.payment_terms.sales.day, "2")
+      assert_equal(contact.payment_terms.sales.type, "OFFOLLOWINGMONTH")
+    end
+  end
+end