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

data/test/unit/oauth_test.rb

@@ -0,0 +1,179 @@
+require 'unit_test_helper'
+
+class OAuthTest < Test::Unit::TestCase
+  include TestHelper
+
+  def setup
+    @client = Xeroizer::PublicApplication.new(CONSUMER_KEY, CONSUMER_SECRET)
+  end
+
+  context "with oauth error handling" do
+
+    should "handle token expired" do
+      Xeroizer::OAuth.any_instance.stubs(:get).returns(stub(:plain_body => get_file_as_string("token_expired"), :code => "401"))
+
+      assert_raises Xeroizer::OAuth::TokenExpired do
+        @client.Organisation.first
+      end
+    end
+
+    should "handle invalid request tokens" do
+      Xeroizer::OAuth.any_instance.stubs(:get).returns(stub(:plain_body => get_file_as_string("invalid_request_token"), :code => "401"))
+
+      assert_raises Xeroizer::OAuth::TokenInvalid do
+        @client.Organisation.first
+      end
+    end
+
+    should "handle invalid consumer key" do
+      Xeroizer::OAuth.any_instance.stubs(:get).returns(stub(:plain_body => get_file_as_string("invalid_consumer_key"), :code => "401"))
+
+      assert_raises Xeroizer::OAuth::TokenInvalid do
+        @client.Organisation.first
+      end
+    end
+
+    should "handle nonce used" do
+      Xeroizer::OAuth.any_instance.stubs(:get).returns(stub(:plain_body => get_file_as_string("nonce_used"), :code => "401"))
+
+      assert_raises Xeroizer::OAuth::NonceUsed do
+        @client.Organisation.first
+      end
+    end
+
+    should "raise rate limit exceeded" do
+      Xeroizer::OAuth.any_instance.stubs(:get).returns(stub(:plain_body => get_file_as_string("rate_limit_exceeded"), :code => "401"))
+
+      assert_raises Xeroizer::OAuth::RateLimitExceeded do
+        @client.Organisation.first
+      end
+    end
+
+    should "automatically handle rate limit exceeded" do
+      auto_rate_limit_client = Xeroizer::PublicApplication.new(CONSUMER_KEY, CONSUMER_SECRET, :rate_limit_sleep => 1)
+
+      # Return rate limit exceeded on first call, OK on the second
+      Xeroizer::OAuth.any_instance.stubs(:get).returns(
+        stub(:plain_body => get_file_as_string("rate_limit_exceeded"), :code => "401"),
+        stub(:plain_body => get_record_xml(:organisation), :code => '200')
+      )
+
+      auto_rate_limit_client.expects(:sleep_for).with(1).returns(1)
+
+      auto_rate_limit_client.Organisation.first
+    end
+
+    should "only retry rate limited request a configurable number of times" do
+      auto_rate_limit_client = Xeroizer::PublicApplication.new(CONSUMER_KEY, CONSUMER_SECRET, :rate_limit_sleep => 1, :rate_limit_max_attempts => 4)
+      Xeroizer::OAuth.any_instance.stubs(:get).returns(stub(:plain_body => get_file_as_string("rate_limit_exceeded"), :code => "401"))
+
+      auto_rate_limit_client.expects(:sleep_for).with(1).times(4).returns(1)
+
+      assert_raises Xeroizer::OAuth::RateLimitExceeded do
+        auto_rate_limit_client.Organisation.first
+      end
+    end
+
+    should "retry nonce_used failures a configurable number of times" do
+      nonce_used_client = Xeroizer::PublicApplication.new(CONSUMER_KEY, CONSUMER_SECRET, :nonce_used_max_attempts => 4)
+      Xeroizer::OAuth.any_instance.stubs(:get).returns(stub(:plain_body => get_file_as_string("nonce_used"), :code => "401"))
+
+      nonce_used_client.expects(:sleep_for).with(1).times(4).returns(1)
+
+      assert_raises Xeroizer::OAuth::NonceUsed do
+        nonce_used_client.Organisation.first
+      end
+    end
+
+    should "handle unknown errors" do
+      Xeroizer::OAuth.any_instance.stubs(:get).returns(stub(:plain_body => get_file_as_string("bogus_oauth_error"), :code => "401"))
+
+      assert_raises Xeroizer::OAuth::UnknownError do
+        @client.Organisation.first
+      end
+    end
+
+    should "handle ApiExceptions" do
+      Xeroizer::OAuth.any_instance.stubs(:put).returns(stub(:plain_body => get_file_as_string("api_exception.xml"),
+          :code => "400"))
+
+      assert_raises Xeroizer::ApiException do
+        contact = @client.Contact.build(:name => 'Test Contact')
+        contact.save!
+      end
+    end
+
+    should "handle random root elements" do
+      Xeroizer::OAuth.any_instance.stubs(:put).returns(stub(:plain_body => "<RandomRootElement></RandomRootElement>",
+          :code => "200"))
+
+      assert_raises Xeroizer::UnparseableResponse do
+        contact = @client.Contact.build(:name => 'Test Contact')
+        contact.save!
+      end
+    end
+
+  end
+
+  context "with oauth2 error handling" do
+    context "when token is invalid" do
+      should "raise an invalid token error" do
+        Xeroizer::OAuth2.any_instance.stubs(:get).returns(stub(:plain_body => get_file_as_string("invalid_oauth2_request_token.json"), :code => "401"))
+
+        assert_raises Xeroizer::OAuth::TokenInvalid do
+          Xeroizer::OAuth2Application.new("client id", "client secret", access_token: "access token").Organisation.first
+        end
+      end
+    end
+
+    context "when token is expired" do
+      should "raise an expired token error" do
+        Xeroizer::OAuth2.any_instance.stubs(:get).returns(stub(:plain_body => get_file_as_string("expired_oauth2_token.json"), :code => "401"))
+
+        assert_raises Xeroizer::OAuth::TokenExpired do
+          Xeroizer::OAuth2Application.new("client id", "client secret", access_token: "access token").Organisation.first
+        end
+      end
+    end
+
+    context "when the tenant_id header is invalid or not present" do
+      should "handle oauth2 invalid tenant_id" do
+        Xeroizer::OAuth2.any_instance.stubs(:get).returns(stub(:plain_body => get_file_as_string("invalid_tenant_header.json"), :code => "403"))
+
+        assert_raises Xeroizer::OAuth::Forbidden do
+          Xeroizer::OAuth2Application.new("client id", "client secret", access_token: "access token").Account.first
+        end
+      end
+    end
+
+    context "when a bad request was made" do
+      should "handle a json payload" do
+        Xeroizer::OAuth2.any_instance.stubs(:get).returns(stub(:plain_body => get_file_as_string("bad_request.json"), :code => "400"))
+
+        assert_raises Xeroizer::BadResponse do
+          Xeroizer::OAuth2Application.new("client id", "client secret", access_token: "access token").Account.first
+        end
+      end
+    end
+
+    context "when an object is not found" do
+      should "raise an object not found error" do
+        Xeroizer::OAuth2.any_instance.stubs(:get).returns(stub(:plain_body => get_file_as_string("object_not_found.json"), :code => "404"))
+
+        assert_raises Xeroizer::ObjectNotFound do
+          Xeroizer::OAuth2Application.new("client id", "client secret", access_token: "access token").Account.first
+        end
+      end
+    end
+
+    context "when an error that isn't explicitly handled is received" do
+      should "raise an unknown error" do
+        Xeroizer::OAuth2.any_instance.stubs(:get).returns(stub(:plain_body => get_file_as_string("generic_response_error.json"), :code => "409"))
+
+        assert_raises Xeroizer::OAuth::UnknownError do
+          Xeroizer::OAuth2Application.new("client id", "client secret", access_token: "access token").Account.first
+        end
+      end
+    end
+  end
+end

data/test/unit/private_application_test.rb

@@ -0,0 +1,20 @@
+require 'unit_test_helper'
+
+class PrivateApplicationTest < Test::Unit::TestCase
+  include TestHelper
+
+  def setup
+    @client = Xeroizer::PrivateApplication.new(CONSUMER_KEY, CONSUMER_SECRET, PRIVATE_KEY_PATH)
+  end
+
+  context "initialization" do
+
+    should "have a valid client" do
+      assert_kind_of(Xeroizer::OAuth, @client.client)
+      assert_equal(CONSUMER_KEY, @client.client.ctoken)
+      assert_equal(CONSUMER_SECRET, @client.client.csecret)
+    end
+
+  end
+
+end

data/test/unit/record/base_model_test.rb

@@ -0,0 +1,58 @@
+require 'unit_test_helper'
+
+class RecordBaseModelTest < Test::Unit::TestCase
+  include TestHelper
+
+  class AppleModel < Xeroizer::Record::BaseModel
+    set_api_controller_name 'AppleController'
+    set_permissions :read, :write
+  end
+
+  class PearModel < Xeroizer::Record::BaseModel
+    set_api_controller_name 'PearController'
+    set_permissions :read
+  end
+
+  class OrangeModel < Xeroizer::Record::BaseModel
+    set_permissions :read, :write, :update
+  end
+
+  def setup
+    @client = Xeroizer::PublicApplication.new(CONSUMER_KEY, CONSUMER_SECRET)
+    @apple_model = AppleModel.new(@client, 'Apple')
+    @pear_model = PearModel.new(@client, 'Pear')
+    @orange_model = OrangeModel.new(@client, 'Orange')
+  end
+
+  context "RecordModel.api_controller_name" do
+
+    should "api_controller_name should default to pluralized model name" do
+      assert_equal('Oranges', @orange_model.api_controller_name)
+    end
+
+    should "set_api_controller_name should set the base controller name used by Xero" do
+      assert_equal('AppleController', @apple_model.api_controller_name)
+     assert_equal('PearController', @pear_model.api_controller_name)
+    end
+
+  end
+
+  context "model permssions" do
+
+    should "save permissions correctly" do
+      assert_equal(%w(read write), @apple_model.class.permissions.keys.map(&:to_s).sort)
+      assert_equal(%w(read), @pear_model.class.permissions.keys.map(&:to_s).sort)
+      assert_equal(%w(read update write), @orange_model.class.permissions.keys.map(&:to_s).sort)
+    end
+
+  end
+
+  context "InvalidPermissionError" do
+    should "also be catchable by the name 'InvaidPermissionError' for historical reasons" do
+      assert_raise(Xeroizer::Record::BaseModel::InvaidPermissionError) do
+        raise Xeroizer::Record::BaseModel::InvalidPermissionError
+      end
+    end
+  end
+
+end

data/test/unit/record/base_test.rb

@@ -0,0 +1,174 @@
+require 'unit_test_helper'
+
+class RecordBaseTest < Test::Unit::TestCase
+  include TestHelper
+
+  def setup
+    @client = Xeroizer::PublicApplication.new(CONSUMER_KEY, CONSUMER_SECRET)
+    @contact = @client.Contact.build(:name => 'Test Contact Name ABC')
+  end
+
+  context "base record" do
+
+    should "create new model instance from #new_model_class" do
+      model_class = @contact.new_model_class("Invoice")
+      assert_kind_of(Xeroizer::Record::InvoiceModel, model_class)
+      assert_equal(@contact.parent.application, model_class.application)
+      assert_equal('Invoice', model_class.model_name)
+    end
+
+    should "new_record? should be new on create" do
+      assert_equal(true, @contact.new_record?)
+    end
+
+  end
+
+  context "new_record? states" do
+
+    should "new_record? should be false when loading data" do
+      Xeroizer::OAuth.any_instance.stubs(:get).returns(stub(:plain_body => get_record_xml(:contact), :code => '200'))
+      contact = @client.Contact.find('TESTID')
+      assert_kind_of(Xeroizer::Record::Contact, contact)
+      assert_equal(false, contact.new_record?)
+    end
+
+    should "new_record? should be false after successfully creating a record" do
+      Xeroizer::OAuth.any_instance.stubs(:put).returns(stub(:plain_body => get_record_xml(:contact), :code => '200'))
+      assert_equal(true, @contact.new_record?)
+      assert_nil(@contact.contact_id)
+      assert_equal(true, @contact.save, "Error saving contact: #{@contact.errors.inspect}")
+      assert_equal(false, @contact.new_record?)
+      assert(@contact.contact_id =~ GUID_REGEX, "@contact.contact_id is not a GUID, it is '#{@contact.contact_id}'")
+    end
+
+    should "new_record? should be false if we have specified a primary key" do
+      contact = @client.Contact.build(:contact_id => 'ABC')
+      assert_equal(false, contact.new_record?)
+
+      contact = @client.Contact.build(:contact_number => 'CDE')
+      assert_equal(true, contact.new_record?)
+
+      contact = @client.Contact.build(:name => 'TEST NAME')
+      assert_equal(true, contact.new_record?)
+    end
+
+  end
+
+  context "about logging" do
+    # Setup we only wish to do once:
+    class ExampleRecordClass < Xeroizer::Record::Base
+      def valid?; true; end
+      def to_xml(b = nil); "<FakeRequest />" end
+      string :id
+    end
+    class Xeroizer::Record::ExampleRecordClassModel < Xeroizer::Record::BaseModel; end
+
+    # Setup before each test
+    setup do
+      @example_class = ExampleRecordClass
+    end
+
+    must "log the request and response xml when saving a new record" do
+      Xeroizer::Logging::Log.expects(:info).once.with {|arg| arg =~ /\[CREATE SENT\]/}
+      Xeroizer::Logging::Log.expects(:info).once.with {|arg| arg =~ /\[CREATE RECEIVED\]/}
+
+      a_fake_parent = mock "Mock parent",
+        :http_put => "<FakeResponse />",
+        :parse_response => stub("Stub response", :response_items => []),
+        :mark_dirty => nil,
+        :create_method => :http_put,
+        :mark_clean => nil,
+        :application => nil
+
+      an_example_instance = @example_class.new(a_fake_parent)
+
+      an_example_instance.id = nil
+      an_example_instance.save
+    end
+
+    must "log the request and response xml when updating an existing record" do
+      Xeroizer::Logging::Log.expects(:info).once.with {|arg| arg =~ /\[UPDATE SENT\]/}
+      Xeroizer::Logging::Log.expects(:info).once.with {|arg| arg =~ /\[UPDATE RECEIVED\]/}
+
+      a_fake_parent = mock "Mock parent",
+        :http_post => "<FakeResponse />",
+        :parse_response => stub("Stub response", :response_items => []),
+        :mark_dirty => nil,
+        :mark_clean => nil,
+        :application => nil
+
+      an_example_instance = @example_class.new(a_fake_parent)
+
+      an_example_instance.id = "phil's lunch box"
+      an_example_instance.save
+    end
+  end
+
+  context 'build' do
+
+    should "raise an undefined method error with useful message" do
+      assert_raise_message("undefined method `this_method_does_not_exist=' for #<Xeroizer::Record::Contact >") do
+        @client.Contact.build(:this_method_does_not_exist =>  true)
+      end
+    end
+
+  end
+
+  context 'saving' do
+    context 'invalid record' do
+      setup do
+        @contact.stubs(:valid?).returns(false)
+      end
+
+      must 'raise an exception saving with #save!' do
+        assert_raise(Xeroizer::RecordInvalid) do
+          @contact.save!
+        end
+      end
+
+      must 'return false saving with #save' do
+        assert_equal(false, @contact.save)
+      end
+    end
+
+    context 'api error received' do
+      setup do
+        response = get_file_as_string('api_exception.xml')
+        doc = Nokogiri::XML(response)
+        exception = Xeroizer::ApiException.new(doc.root.xpath("Type").text,
+                                               doc.root.xpath("Message").text,
+                                               response,
+                                               doc,
+                                               '<FakeRequest />')
+
+        @contact.stubs(:valid?).returns(true)
+        @contact.stubs(:create).raises(exception)
+        @contact.stubs(:update).raises(exception)
+      end
+
+      must 'raise an exception creating records with #save!' do
+        @contact.stubs(:new_record?).returns(true)
+        assert_raise(Xeroizer::ApiException) do
+          @contact.save!
+        end
+      end
+
+      must 'raise an exception updating records with #save!' do
+        @contact.stubs(:new_record?).returns(false)
+        assert_raise(Xeroizer::ApiException) do
+          @contact.save!
+        end
+      end
+
+      must 'return false creating records with #save' do
+        @contact.stubs(:new_record?).returns(true)
+        assert_equal(false, @contact.save)
+      end
+
+      must 'return false updating records with #save' do
+        @contact.stubs(:new_record?).returns(false)
+        assert_equal(false, @contact.save)
+      end
+    end
+  end
+end

data/test/unit/record/block_validator_test.rb

@@ -0,0 +1,125 @@
+require 'unit_test_helper'
+
+class BlockValidatorTest < Test::Unit::TestCase
+  def setup
+    @fake_record_class = Class.new do
+      attr_accessor :errors
+      def initialize; @errors = []; end
+    end
+  end
+
+  it "returns valid when block returns true" do
+    record = @fake_record_class.new
+
+    the_block_returning_true = Proc.new{ true }
+
+    block_validator = Xeroizer::Record::Validator::BlockValidator.new(
+      :name,
+      :block => the_block_returning_true
+    )
+
+    block_validator.valid?(record)
+
+    assert_empty record.errors, "Expected validation to pass. #{record.errors.inspect}"
+  end
+
+  it "returns invalid when block returns a non-null object" do
+    record = @fake_record_class.new
+
+    the_block_returning_true = Proc.new{ Object }
+
+    block_validator = Xeroizer::Record::Validator::BlockValidator.new(
+      :name,
+      :block => the_block_returning_true
+    )
+
+    block_validator.valid?(record)
+
+    assert_equal 1, record.errors.size, "Expected validation to fail with one error. #{record.errors.inspect}"
+  end
+
+  it "returns invalid when block returns false" do
+    record = @fake_record_class.new
+
+    the_block_returning_false = Proc.new{ false }
+
+    block_validator = Xeroizer::Record::Validator::BlockValidator.new(
+      :name,
+      {
+        :block => the_block_returning_false
+      }
+    )
+
+    block_validator.valid?(record)
+
+    assert_equal 1, record.errors.size, "Expected validation to fail with one error. #{record.errors.inspect}"
+  end
+
+  it "uses the message supplied when validation fails" do
+    record = @fake_record_class.new
+
+    the_block_returning_false = Proc.new{ false }
+
+    expected_error = "Cornrows are usually a headwear mistake"
+
+    block_validator = Xeroizer::Record::Validator::BlockValidator.new(
+      :name,
+      {
+        :block => the_block_returning_false,
+        :message => expected_error
+      }
+    )
+
+    block_validator.valid?(record)
+
+    assert_equal 1, record.errors.size,
+      "Expected validation to fail with one error. #{record.errors.inspect}"
+    assert_equal expected_error, record.errors.first[1],
+      "There is an error, but it doesn't match"
+  end
+
+  it "uses a default message when validation fails and no message has been supplied" do
+    record = @fake_record_class.new
+
+    the_block_returning_false = Proc.new{ false }
+
+    expected_error = "block condition failed"
+
+    block_validator = Xeroizer::Record::Validator::BlockValidator.new(
+      :name,
+      {
+        :block => the_block_returning_false
+      }
+    )
+
+    block_validator.valid?(record)
+
+    assert_equal 1, record.errors.size,
+      "Expected validation to fail with one error. #{record.errors.inspect}"
+    assert_equal expected_error, record.errors.first[1],
+      "There is an error, but it doesn't match"
+  end
+
+  it "uses a default message when validation fails and message has been supplied as empty" do
+    record = @fake_record_class.new
+
+    the_block_returning_false = Proc.new{ false }
+
+    expected_error = "block condition failed"
+
+    block_validator = Xeroizer::Record::Validator::BlockValidator.new(
+      :name,
+      {
+        :block => the_block_returning_false,
+        :message => ""
+      }
+    )
+
+    block_validator.valid?(record)
+
+    assert_equal 1, record.errors.size,
+      "Expected validation to fail with one error. #{record.errors.inspect}"
+    assert_equal expected_error, record.errors.first[1],
+      "There is an error, but it doesn't match"
+  end
+end