mirror42-freshbooks.rb 3.0.25

data/test/schema/test_definition.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+module Schema
+  class TestDefinition < Test::Unit::TestCase
+    def setup
+      @definition = FreshBooks::Schema::Definition.new
+    end
+    
+    def test_method_missing
+      # Empty
+      assert_equal 0, @definition.members.size
+      
+      # One type
+      @definition.string :name
+      assert_equal 1, @definition.members.size
+      assert_equal({ :type => :string, :read_only => false }, @definition.members["name"])
+      
+      # Multiple attributes
+      @definition.fixnum :version, :po_number
+      assert_equal 3, @definition.members.size
+      assert_equal({ :type => :fixnum, :read_only => false }, @definition.members["version"])
+      assert_equal({ :type => :fixnum, :read_only => false }, @definition.members["po_number"])
+      
+      # Multiple times
+      @definition.fixnum :lock_number
+      assert_equal 4, @definition.members.size
+      assert_equal({ :type => :fixnum, :read_only => false }, @definition.members["lock_number"])
+    end
+    
+    def test_method_missing_extra_options
+      @definition.fixnum :version, :po_number, :read_only => true
+      assert_equal({ :type => :fixnum, :read_only => true }, @definition.members["version"])
+      assert_equal({ :type => :fixnum, :read_only => true }, @definition.members["po_number"])
+    end
+  end
+end

data/test/schema/test_mixin.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+module Schema
+  class TestMixin < Test::Unit::TestCase
+    def test_define_schema__unique_definition_per_class
+      assert MyItem.schema_definition.members.include?("name")
+      assert !MyItem.schema_definition.members.include?("name2")
+    
+      assert MyItem2.schema_definition.members.include?("name2")
+      assert !MyItem2.schema_definition.members.include?("name")
+    end
+    
+    def test_define_schema__creates_attr_accessors
+      assert MyItem.public_method_defined?("name")
+      assert MyItem.public_method_defined?("name=")
+      
+      assert MyItem2.public_method_defined?("name2")
+      assert MyItem2.public_method_defined?("name2=")
+    end
+    
+    def test_define_schema__creates_read_only_attr_accessors
+      assert MyItem.public_method_defined?("read_only_name")
+      assert MyItem.protected_method_defined?("read_only_name=")
+    end
+  end
+
+  class MyItem < FreshBooks::Base
+    define_schema do |s|
+      s.string :name
+      s.string :read_only_name, :read_only => true
+    end
+  end
+
+  class MyItem2 < FreshBooks::Base
+    define_schema do |s|
+      s.string :name2
+    end
+  end
+end

data/test/test_base.rb

@@ -0,0 +1,151 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestBase < Test::Unit::TestCase
+  def test_establish_connection
+    assert_nil FreshBooks::Base.connection
+    
+    FreshBooks::Base.establish_connection("company.freshbooks.com", "auth_token")
+    connection = FreshBooks::Base.connection
+    assert_not_nil connection
+    assert_equal "company.freshbooks.com", connection.account_url
+    assert_equal "auth_token", connection.auth_token
+    
+    FreshBooks::Base.establish_connection("company2.freshbooks.com", "auth_token2")
+    connection = FreshBooks::Base.connection
+    assert_not_nil connection
+    assert_equal "company2.freshbooks.com", connection.account_url
+    assert_equal "auth_token2", connection.auth_token
+  end
+  
+  def test_new_from_xml_to_xml__round_trip
+    xml = <<-EOS
+      <my_item>
+        <name>name1</name>
+        <amount>4.5</amount>
+        <read_only_number>5</read_only_number>
+        <number>6</number>
+        <visible>1</visible>
+        <date>2008-02-01</date>
+        <created_at>2008-10-22 13:57:00</created_at>
+        <my_address>
+          <street1>street1</street1>
+        </my_address>
+        <my_lines>
+          <my_line>
+            <description>description</description>
+          </my_line>
+        </my_lines>
+      </my_item>
+    EOS
+    doc = REXML::Document.new(xml)
+    
+    item = FreshBooks::MyItem.new_from_xml(doc.root)
+    assert_equal "name1", item.name
+    assert_equal 5, item.read_only_number
+    assert_equal 6, item.number
+    assert_equal 4.5, item.amount
+    assert_equal true, item.visible
+    assert_equal Date.new(2008, 2, 1), item.date
+    assert_equal DateTime.parse("2008-10-22 13:57:00 -04:00"), item.created_at
+    assert_equal "street1", item.my_address.street1
+    assert_equal 1, item.my_lines.size
+    assert_equal "description", item.my_lines.first.description
+    
+    # If someone knows a good way to compare xml docs where ordering doesn't matter
+    # let me know. This can be refactored and improved greatly.
+    xml_out = item.to_xml.to_s.strip
+    assert_equal "<my_item>", xml_out.first(9)
+    assert xml_out.include?("<name>name1</name>")
+    assert xml_out.include?("<amount>4.5</amount>")
+    assert xml_out.include?("<visible>1</visible>")
+    assert !xml_out.include?("<read_only_number>5</read_only_number>") # this is read only
+    assert xml_out.include?("<number>6</number>")
+    assert xml_out.include?("<date>2008-02-01</date>")
+    assert xml_out.include?("<created_at>2008-10-22 13:57:00</created_at>")
+    assert xml_out.include?("<my_address><street1>street1</street1></my_address>")
+    assert xml_out.include?("<my_lines><my_line><description>description</description></my_line></my_lines>")
+  end
+  
+  def test_create_objects_with_initializer_arguments
+    invoice_1 = FreshBooks::Invoice.new
+    invoice_1.client_id = 1
+    invoice_1.lines = [FreshBooks::Line.new, FreshBooks::Line.new]
+    invoice_1.lines[0].name = "Awesomeness"
+    invoice_1.lines[0].unit_cost = 9999
+    invoice_1.lines[0].quantity = 42
+    invoice_1.lines[1].name = "Ninja skills"
+    invoice_1.lines[1].unit_cost = 349
+    invoice_1.lines[1].quantity = 100
+    
+    invoice_2 = FreshBooks::Invoice.new(
+      :client_id => 1,
+      :lines => [
+        FreshBooks::Line.new(
+          :name => "Awesomeness",
+          :unit_cost => 9999,
+          :quantity => 42
+        ),
+        FreshBooks::Line.new(
+          :name => "Ninja skills",
+          :unit_cost => 349,
+          :quantity => 100
+        )
+      ]
+    )
+    
+    assert_equal invoice_1.to_xml, invoice_2.to_xml
+  end
+  
+  def test_can_handle_all_zero_updated_at
+    xml = <<-END_XML
+      <my_client> 
+        <client_id>3</client_id> 
+        <first_name>Test</first_name> 
+        <last_name>User</last_name> 
+        <organization>User Testing</organization> 
+        <updated>0000-00-00 00:00:00</updated> 
+      </my_client>
+    END_XML
+    doc = REXML::Document.new(xml)
+    
+    item = FreshBooks::MyClient.new_from_xml(doc.root)
+    assert_equal nil, item.updated
+  end
+  
+end
+
+module FreshBooks
+  class MyItem < FreshBooks::Base
+    define_schema do |s|
+      s.string :name
+      s.fixnum :read_only_number, :read_only => true
+      s.fixnum :number
+      s.float :amount
+      s.boolean :visible
+      s.date :date
+      s.date_time :created_at
+      s.object :my_address
+      s.array :my_lines
+    end
+  end
+
+  class MyClient < FreshBooks::Base
+    define_schema do |s|
+      s.string :first_name, :last_name, :organization
+      s.fixnum :client_id
+      s.date_time :updated
+    end
+  end
+
+  class MyAddress < FreshBooks::Base
+    define_schema do |s|
+      s.string :street1
+    end
+  end
+  
+  class MyLine < FreshBooks::Base
+    define_schema do |s|
+      s.string :description
+    end
+  end
+end

data/test/test_connection.rb

@@ -0,0 +1,145 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestConnection < Test::Unit::TestCase
+  def setup
+    @connection = FreshBooks::Connection.new("company.freshbooks.com", "auth_token")
+  end
+  
+  def test_connection_accessors
+    assert_equal "company.freshbooks.com", @connection.account_url
+    assert_equal "auth_token", @connection.auth_token
+  end
+  
+  def test_connection_request_headers
+    request_headers = { "key" => "value" }
+    connection = FreshBooks::Connection.new("company.freshbooks.com", "auth_token", request_headers)
+    assert_equal request_headers, connection.request_headers
+  end
+  
+  
+  def test_create_request__array_of_elements
+    request = @connection.send(:create_request, 'mymethod', [['element1', 'value1'], [:element2, :value2]])
+    assert_equal "<?xml version='1.0' encoding='UTF-8'?><request method='mymethod'><element1>value1</element1><element2>value2</element2></request>", request
+  end
+  
+  def test_create_request__base_object_element
+    invoice = FreshBooks::Invoice.new
+    invoice.expects(:to_xml).with().returns("<invoice><number>23</number></invoice>")
+    
+    request = @connection.send(:create_request, 'mymethod', 'invoice' => invoice)
+    assert_equal "<?xml version='1.0' encoding='UTF-8'?><request method='mymethod'><invoice><number>23</number></invoice></request>", request
+  end
+  
+  def test_check_for_api_error__success
+    body = "body xml"
+    response = Net::HTTPSuccess.new("1.1", "200", "message")
+    response.expects(:body).with().returns(body)
+    assert_equal body, @connection.send(:check_for_api_error, response)
+  end
+  
+  def test_check_for_api_error__unknown_system
+    response = Net::HTTPMovedPermanently.new("1.1", "301", "message")
+    response.stubs(:[]).with("location").returns("loginSearch")
+    assert_raise(FreshBooks::UnknownSystemError) do
+      @connection.send(:check_for_api_error, response)
+    end
+  end
+  
+  def test_check_for_api_error__deactivated
+    response = Net::HTTPMovedPermanently.new("1.1", "301", "message")
+    response.stubs(:[]).with("location").returns("deactivated")
+    assert_raise(FreshBooks::AccountDeactivatedError) do
+      @connection.send(:check_for_api_error, response)
+    end
+  end
+  
+  def test_check_for_api_error__unauthorized
+    response = Net::HTTPUnauthorized.new("1.1", "401", "message")
+    assert_raise(FreshBooks::AuthenticationError) do
+      @connection.send(:check_for_api_error, response)
+    end
+  end
+  
+  def test_check_for_api_error__bad_request
+    response = Net::HTTPBadRequest.new("1.1", "401", "message")
+    assert_raise(FreshBooks::ApiAccessNotEnabledError) do
+      @connection.send(:check_for_api_error, response)
+    end
+  end
+  
+  def test_check_for_api_error__internal_error
+    response = Net::HTTPBadGateway.new("1.1", "502", "message")
+    assert_raise(FreshBooks::InternalError) do
+      @connection.send(:check_for_api_error, response)
+    end
+    
+    response = Net::HTTPMovedPermanently.new("1.1", "301", "message")
+    response.stubs(:[]).with("location").returns("somePage")
+    assert_raise(FreshBooks::InternalError) do
+      @connection.send(:check_for_api_error, response)
+    end
+  end
+  
+  def test_close_is_only_called_once_in_ntexted_start_sessions
+    @connection.expects(:obtain_connection)
+    @connection.expects(:close)
+    
+    @connection.start_session { @connection.start_session { } }
+  end
+  
+  def test_reconnect
+    connection = stub()
+    
+    @connection.expects(:close).with()
+    @connection.expects(:obtain_connection).with(true).returns(connection)
+    
+    assert_equal connection, @connection.send(:reconnect)
+  end
+  
+  def test_post_request_successfull_request
+    request = "<request></request>"
+    response = "<response></response>"
+    
+    http_connection = stub()
+    http_connection.expects(:request).with(request).returns(response)
+    @connection.expects(:start_session).with().yields(http_connection)
+    
+    assert_equal response, @connection.send(:post_request, request)
+  end
+  
+  def test_post_request_eof_error_retry
+    request = "<request></request>"
+    response = "<response></response>"
+    eof_error = EOFError.new("End of file error")
+    
+    bad_http_connection = stub()
+    bad_http_connection.expects(:request).with(request).raises(eof_error)
+    
+    new_http_connection = stub()
+    new_http_connection.expects(:request).with(request).returns(response)
+    
+    @connection.expects(:start_session).with().yields(bad_http_connection)
+    @connection.expects(:reconnect).with().returns(new_http_connection)
+    
+    assert_equal response, @connection.send(:post_request, request)
+  end
+  
+  def test_post_request_eof_error_retry_only_retry_once
+    request = "<request></request>"
+    response = "<response></response>"
+    eof_error = EOFError.new("End of file error")
+    
+    bad_http_connection = stub()
+    bad_http_connection.expects(:request).with(request).raises(eof_error)
+    
+    new_http_connection = stub()
+    new_http_connection.expects(:request).with(request).raises(eof_error)
+    
+    @connection.expects(:start_session).with().yields(bad_http_connection)
+    @connection.expects(:reconnect).with().returns(new_http_connection)
+    
+    assert_raises(EOFError, eof_error.message) do 
+      @connection.send(:post_request, request)
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + '/../lib/freshbooks'
+
+require 'stringio'
+require 'test/unit'
+require File.dirname(__FILE__) + '/mock_connection'
+
+begin
+  require 'mocha'
+rescue LoadError
+  require 'rubygems'
+  gem 'mocha'
+  require 'mocha'
+end
+
+class Test::Unit::TestCase
+  
+  @@fixtures = {}
+  def self.fixtures list
+    [list].flatten.each do |fixture|
+      self.class_eval do
+        # add a method name for this fixture type
+        define_method(fixture) do |item|
+          # load and cache the YAML
+          @@fixtures[fixture] ||= YAML::load_file(self.fixture_dir + "/#{fixture.to_s}.yml")
+          @@fixtures[fixture][item.to_s]
+        end
+      end
+    end
+  end
+  
+  
+  def mock_connection(file_name)
+    mock_connection = MockConnection.new(fixture_xml_content(file_name))
+    FreshBooks::Base.stubs(:connection).with().returns(mock_connection)
+    mock_connection
+  end
+  
+  def fixture_xml_content(file_name)
+    # Quick way to remove white space and newlines from xml. Makes it easier to compare in tests
+    open(File.join(fixture_dir, "#{file_name}.xml"), "r").readlines.inject("") do |contents, line|
+      contents + line.strip
+    end
+  end
+  
+  def fixture_dir
+    File.join(File.dirname(__FILE__), "fixtures")
+  end
+end

data/test/test_invoice.rb

@@ -0,0 +1,125 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestInvoice < Test::Unit::TestCase
+  def test_list
+    mock_call_api("invoice.list", { "page" => 1 }, "invoice_list_response")
+    
+    invoices = FreshBooks::Invoice.list
+    assert_equal 3, invoices.size
+    assert_invoice invoices[0], 0
+    assert_invoice invoices[1], 1
+  end
+  
+  def test_get
+    invoice_id = 2
+    mock_call_api("invoice.get", { "invoice_id" => invoice_id }, "invoice_get_response")
+    
+    invoice = FreshBooks::Invoice.get(invoice_id)
+    assert_invoice invoice, 0, true
+  end
+  
+  def test_create
+    invoice = FreshBooks::Invoice.new
+    assert_nil invoice.invoice_id
+    
+    mock_call_api("invoice.create", { "invoice" => invoice }, "invoice_create_response")
+    assert invoice.create
+    assert_equal 1, invoice.invoice_id
+  end
+  
+  def test_update
+    invoice = FreshBooks::Invoice.new
+    invoice.invoice_id = 1
+    
+    mock_call_api("invoice.update", { "invoice" => invoice }, "success_response")
+    assert invoice.update
+  end
+  
+  def test_delete
+    invoice = FreshBooks::Invoice.new
+    invoice.invoice_id = 2
+    mock_call_api("invoice.delete", { "invoice_id" => invoice.invoice_id }, "success_response")
+    
+    assert invoice.delete
+  end
+  
+  def test_send_by_email
+    invoice = FreshBooks::Invoice.new
+    invoice.invoice_id = 2
+    mock_call_api("invoice.sendByEmail", { "invoice_id" => invoice.invoice_id }, "success_response")
+    
+    assert invoice.send_by_email
+  end
+  
+  def test_send_by_snail_mail
+    invoice = FreshBooks::Invoice.new
+    invoice.invoice_id = 2
+    mock_call_api("invoice.sendBySnailMail", { "invoice_id" => invoice.invoice_id }, "success_response")
+    
+    assert invoice.send_by_snail_mail
+  end
+  
+private
+  
+  def mock_call_api(method, options, response_fixture)
+    FreshBooks::Base.connection.
+      expects(:call_api).
+      with(method, options).
+      returns(FreshBooks::Response.new(fixture_xml_content(response_fixture)))
+  end
+  
+  def assert_invoice(invoice, number, expanded_form = false)
+    number = number + 1
+    
+    assert_equal number, invoice.invoice_id
+    assert_equal "number#{number}", invoice.number
+    assert_equal number, invoice.client_id
+    assert_equal number, invoice.recurring_id
+    assert_equal "draft", invoice.status
+    assert_equal (number * 100), invoice.amount
+    assert_equal (number * 100) / 2, invoice.amount_outstanding
+    assert_equal Date.parse("2009-02-0#{number}"), invoice.date
+    
+    assert_equal number, invoice.po_number
+    assert_equal number.to_f, invoice.discount
+    assert_equal "notes#{number}", invoice.notes
+    assert_equal "terms#{number}", invoice.terms
+    assert_equal "first_name#{number}", invoice.first_name
+    assert_equal "last_name#{number}", invoice.last_name
+    assert_equal "p_street1#{number}", invoice.p_street1
+    assert_equal "p_street2#{number}", invoice.p_street2
+    assert_equal "p_city#{number}", invoice.p_city
+    assert_equal "p_state#{number}", invoice.p_state
+    assert_equal "p_country#{number}", invoice.p_country
+    assert_equal "p_code#{number}", invoice.p_code
+    
+    assert_equal "return_uri#{number}", invoice.return_uri
+    assert_equal DateTime.parse("2009-08-#{number} 0#{number}:00:00 -04:00"), invoice.updated
+    
+    
+    
+    assert_equal "client_view#{number}", invoice.links.client_view
+    assert_equal "view#{number}", invoice.links.view
+    assert_equal "edit#{number}", invoice.links.edit
+    
+    lines = invoice.lines
+    assert_equal 1, lines.size
+    lines.each_with_index do |line, index|
+      assert_line(line, index)
+    end
+  end
+  
+  def assert_line(line, number)
+    number = number + 1
+    
+    assert_equal number.to_f, line.amount
+    assert_equal "name#{number}", line.name
+    assert_equal "description#{number}", line.description
+    assert_equal number.to_f, line.unit_cost
+    assert_equal number, line.quantity
+    assert_equal "tax1_name#{number}", line.tax1_name
+    assert_equal "tax2_name#{number}", line.tax2_name
+    assert_equal number.to_f, line.tax1_percent
+    assert_equal number.to_f, line.tax2_percent
+  end
+end