rets-hack 0.11

data/test/test_client.rb

@@ -0,0 +1,307 @@
+require_relative "helper"
+
+class TestClient < MiniTest::Test
+
+  def setup
+    @client = Rets::Client.new(:login_url => "http://example.com/login")
+  end
+
+  def test_extract_capabilities
+    assert_equal(
+      {"abc" => "123", "def" => "ghi=jk"},
+      @client.extract_capabilities(Nokogiri.parse(CAPABILITIES))
+    )
+  end
+
+  def test_extract_capabilities_with_whitespace
+    assert_equal(
+      {"action" => "/RETS/Action"},
+      @client.extract_capabilities(Nokogiri.parse(CAPABILITIES_WITH_WHITESPACE))
+    )
+  end
+
+  def test_capability_url_returns_parsed_url
+    client = Rets::Client.new(:login_url => "http://example.com", :capabilities => { "foo" => "/foo" })
+
+    assert_equal "http://example.com/foo", client.capability_url("foo")
+  end
+
+  def test_cached_capabilities_case_insensitive
+    client = Rets::Client.new(:login_url => "http://example.com", :capabilities => { "foo" => "/foo" })
+
+    assert_equal client.capabilities.default_proc, Rets::Client::CASE_INSENSITIVE_PROC
+  end
+
+  def test_capabilities_calls_login_when_nil
+    @client.expects(:login)
+    @client.capabilities
+  end
+
+  def test_capabilities_does_not_call_login_after_login
+    response = mock
+    response.stubs(:body).returns(CAPABILITIES)
+    @client.stubs(:http_get).returns(response)
+    @client.login
+
+    @client.expects(:login).never
+    @client.capabilities
+  end
+
+  def test_tries_increments_with_each_call
+    assert_equal 1, @client.tries
+    assert_equal 2, @client.tries
+  end
+
+  def test_metadata_when_not_initialized_with_metadata
+    new_raw_metadata = stub(:new_raw_metadata)
+
+    client = Rets::Client.new(:login_url => "http://example.com")
+    client.stubs(:retrieve_metadata).returns(new_raw_metadata)
+
+    assert_same new_raw_metadata, client.metadata.marshal_dump
+  end
+
+  def test_initialize_with_old_metadata_cached_contstructs_new_metadata_from_request
+    metadata = stub(:current? => false)
+    new_raw_metadata = stub(:new_raw_metadata)
+
+    client = Rets::Client.new(:login_url => "http://example.com", :metadata => metadata)
+    client.stubs(:capabilities).returns({})
+    client.stubs(:retrieve_metadata).returns(new_raw_metadata)
+
+    assert_same new_raw_metadata, client.metadata.marshal_dump
+  end
+
+  def test_initialize_with_current_metadata_cached_return_cached_metadata
+    metadata = stub(:current? => true)
+    client = Rets::Client.new(:login_url => "http://example.com", :metadata => metadata)
+    client.stubs(:capabilities => {})
+
+    assert_same metadata, client.metadata
+  end
+
+  def test_initialize_takes_logger
+    logger = Object.new
+
+    client = Rets::Client.new(:login_url => "http://example.com", :logger => logger)
+
+    assert_equal logger, client.logger
+  end
+
+  def test_default_logger_returns_api_compatible_silent_logger
+    logger = @client.logger
+    logger.fatal "foo"
+    logger.error "foo"
+    logger.warn  "foo"
+    logger.info  "foo"
+    logger.debug "foo"
+  end
+
+  def test_find_every_raises_on_missing_required_arguments
+    assert_raises ArgumentError do
+      @client.find_every({})
+    end
+    assert_raises ArgumentError do
+      @client.find_every(:search_type => "Foo")
+    end
+    assert_raises ArgumentError do
+      @client.find_every(:class => "Bar")
+    end
+  end
+
+  def test_find_first_calls_find_every_with_limit_one
+    @client.expects(:find_every).with({:limit => 1, :foo => :bar}, nil).returns([1,2,3])
+
+    assert_equal 1, @client.find(:first, :foo => :bar, :limit => 5), "User-specified limit should be ignored"
+  end
+
+  def test_find_all_calls_find_every
+    @client.expects(:find_every).with({:limit => 5, :foo => :bar}, nil).returns([1,2,3])
+
+    assert_equal [1,2,3], @client.find(:all, :limit => 5, :foo => :bar)
+  end
+
+  def test_find_raises_on_unknown_quantity
+    assert_raises ArgumentError do
+      @client.find(:incorrect, :foo => :bar)
+    end
+  end
+
+  def test_response_text_encoding_from_ascii
+    @client.stubs(:capability_url).with("Search").returns("search_url")
+    response = mock
+    response.stubs(:body).returns("An ascii string".encode("binary", "UTF-8"))
+
+    assert_equal @client.clean_response(response).body, "An ascii string"
+  end
+
+  def test_response_text_encoding_from_utf_8
+    @client.stubs(:capability_url).with("Search").returns("search_url")
+    response = mock
+    response.stubs(:body).returns("Some string with non-ascii characters \u0119")
+
+    assert_equal @client.clean_response(response).body, "Some string with non-ascii characters \u0119"
+
+  end
+
+  def test_response_text_encoding_from_utf_16
+    @client.stubs(:capability_url).with("Search").returns("search_url")
+    response = mock
+    response.stubs(:body).returns("Some string with non-utf-8 characters \xC2")
+
+    assert_equal @client.clean_response(response).body, "Some string with non-utf-8 characters \uFFFD"
+  end
+
+  def test_find_retries_when_receiving_no_records_found
+    @client.stubs(:find_every).raises(Rets::NoRecordsFound.new('')).then.returns([1])
+
+    assert_equal [1], @client.find(:all)
+  end
+
+  def test_find_does_not_retry_when_receiving_no_records_found_with_option
+    @client.stubs(:find_every).raises(Rets::NoRecordsFound.new(''))
+
+    assert_equal [], @client.find(:all, no_records_not_an_error: true)
+  end
+
+  def test_find_does_not_retry_and_returns_zero_on_count_request_when_receiving_no_records_found_with_option
+    @client.stubs(:find_every).raises(Rets::NoRecordsFound.new(''))
+
+    assert_equal 0, @client.find(:all, count: 2, no_records_not_an_error: true)
+  end
+
+  def test_find_retries_on_errors
+    @client.stubs(:find_every).raises(Rets::AuthorizationFailure.new(401, 'Not Authorized')).then.raises(Rets::InvalidRequest.new(20134, 'Not Found')).then.returns([])
+    @client.stubs(:login)
+    @client.find(:all, :foo => :bar)
+  end
+
+  def test_find_waits_configured_time_before_next_request
+    @client.options[:recoverable_error_wait_secs] = 3.14
+    @client.expects(:sleep).with(3.14).times(3)
+    @client.stubs(:find_every).raises(Rets::MiscellaneousSearchError.new(0, 'Foo'))
+    @client.find(:all, :foo => :bar) rescue nil
+  end
+
+  def test_find_eventually_reraises_errors
+    @client.stubs(:find_every).raises(Rets::AuthorizationFailure.new(401, 'Not Authorized'))
+    @client.stubs(:login)
+
+    assert_raises Rets::AuthorizationFailure do
+      @client.find(:all, :foo => :bar)
+    end
+  end
+
+  def test_find_logs_in_after_auth_error
+    @client.stubs(:find_every).raises(Rets::AuthorizationFailure.new(401, 'Not Authorized')).then.returns(["foo"])
+
+    @client.expects(:login)
+    @client.find(:all, :foo => :bar)
+  end
+
+  def test_all_objects_calls_objects
+    @client.expects(:objects).with("*", :foo => :bar)
+
+    @client.all_objects(:foo => :bar)
+  end
+
+  def test_objects_handles_string_argument
+    @client.expects(:fetch_object).with("*", :foo => :bar)
+    @client.stubs(:create_parts_from_response)
+
+    @client.objects("*", :foo => :bar)
+  end
+
+  def test_objects_handle_array_argument
+    @client.expects(:fetch_object).with("1:2:3", :foo => :bar)
+    @client.stubs(:create_parts_from_response)
+
+    @client.objects([1,2,3], :foo => :bar)
+  end
+
+  def test_objects_raises_on_other_arguments
+    assert_raises ArgumentError do
+      @client.objects(Object.new, :foo => :bar)
+    end
+  end
+
+  def test_create_parts_from_response_returns_multiple_parts_when_multipart_response
+    response = {}
+    response.stubs(:header => { "content-type" => ['multipart; boundary="simple boundary"']})
+    response.stubs(:body => MULITPART_RESPONSE)
+
+    Rets::Parser::Multipart.expects(:parse).
+      with(MULITPART_RESPONSE, "simple boundary").
+      returns([])
+
+    @client.create_parts_from_response(response)
+  end
+
+  def test_parse_boundary_wo_quotes
+    response = {}
+    response.stubs(:header => { "content-type" => ['multipart; boundary=simple boundary; foo;']})
+    response.stubs(:body => MULITPART_RESPONSE)
+
+    Rets::Parser::Multipart.expects(:parse).
+      with(MULITPART_RESPONSE, "simple boundary").
+      returns([])
+
+    @client.create_parts_from_response(response)
+  end
+
+  def test_create_parts_from_response_returns_a_single_part_when_not_multipart_response
+    response = {}
+    response.stubs(:header => { "content-type" => ['text/plain']})
+    response.stubs(:headers => { "Content-Type" => 'text/plain'})
+    response.stubs(:body => "fakebody")
+
+    parts = @client.create_parts_from_response(response)
+
+    assert_equal 1, parts.size
+
+    part = parts.first
+
+    assert_equal "text/plain", part.headers["content-type"]
+    assert_equal "fakebody", part.body
+  end
+
+  def test_object_calls_fetch_object
+    response = stub(:body => "foo")
+
+    @client.expects(:fetch_object).with("1", :foo => :bar).returns(response)
+
+    assert_equal "foo", @client.object("1", :foo => :bar)
+  end
+
+  def test_decorate_result_handles_bad_metadata
+    result = {'foo' => 'bar'}
+    rets_class = stub
+    rets_class.expects(:find_table).with('foo').returns(nil)
+    response = @client.decorate_result(result, rets_class)
+    assert_equal response, result
+  end
+
+  def test_clean_setup_with_receive_timeout
+   HTTPClient.any_instance.expects(:receive_timeout=).with(1234)
+   @client = Rets::Client.new(
+       login_url: 'http://example.com/login',
+       receive_timeout: 1234
+   )
+  end
+
+  def test_clean_setup_with_proxy_auth
+    @login_url = 'http://example.com/login'
+    @proxy_url = 'http://example.com/proxy'
+    @proxy_username = 'username'
+    @proxy_password = 'password'
+    HTTPClient.any_instance.expects(:set_proxy_auth).with(@proxy_username, @proxy_password)
+
+    @client = Rets::Client.new(
+        login_url: @login_url,
+        http_proxy: @proxy_url,
+        proxy_username: @proxy_username,
+        proxy_password: @proxy_password
+    )
+  end
+
+end

data/test/test_error_checker.rb

@@ -0,0 +1,87 @@
+require_relative "helper"
+
+class TestErrorChecker < MiniTest::Test
+  def test_check_with_status_code_412
+    response = mock
+    response.stubs(:status_code).returns(412)
+    response.stubs(:body).returns('junk')
+    assert_raises Rets::HttpError do
+      Rets::Parser::ErrorChecker.check(response)
+    end
+  end
+
+  def test_401_with_empty_body_is_auth_failure
+    # 401 with no body is an auth failure
+    response = mock
+    response.stubs(:status_code).returns(401)
+    response.stubs(:ok?).returns(false)
+    response.stubs(:body).returns('')
+    assert_raises Rets::AuthorizationFailure do
+      Rets::Parser::ErrorChecker.check(response)
+    end
+  end
+
+  def test_401_with_html_body_is_auth_failure
+    # 401 with html body returns auth failure
+    response = mock
+    response.stubs(:status_code).returns(401)
+    response.stubs(:ok?).returns(false)
+    response.stubs(:body).returns(HTML_AUTH_FAILURE)
+    assert_raises Rets::AuthorizationFailure do
+      Rets::Parser::ErrorChecker.check(response)
+    end
+  end
+
+  def test_401_with_xhtml_body_is_auth_failure
+    # 401 with xhtml body returns auth failure
+    response = mock
+    response.stubs(:status_code).returns(401)
+    response.stubs(:ok?).returns(false)
+    response.stubs(:body).returns(XHTML_AUTH_FAILURE)
+    assert_raises Rets::AuthorizationFailure do
+      Rets::Parser::ErrorChecker.check(response)
+    end
+  end
+
+  def test_no_records_found_failure
+    response = mock
+    response.stubs(:body).returns(RETS_NO_RECORDS_ERROR)
+    assert_raises Rets::NoRecordsFound do
+      Rets::Parser::ErrorChecker.check(response)
+    end
+  end
+
+  def test_no_object_found_failure
+    response = mock
+    response.stubs(:body).returns(RETS_NO_OBJECT_ERROR)
+    assert_raises Rets::NoObjectFound do
+      Rets::Parser::ErrorChecker.check(response)
+    end
+  end
+
+  Rets::Parser::ErrorChecker::INVALID_REQUEST_ERROR_MAPPING.each do |error_code, error_class|
+    define_method("test_#{error_class}_failure") do
+      response = mock
+      response.stubs(:body).returns(error_body_with_code(error_code))
+      assert_raises error_class do
+        Rets::Parser::ErrorChecker.check(response)
+      end
+    end
+  end
+
+  def test_invalid_request_failure
+    response = mock
+    response.stubs(:body).returns(RETS_INVALID_REQUEST_ERROR)
+    assert_raises Rets::InvalidRequest do
+      Rets::Parser::ErrorChecker.check(response)
+    end
+  end
+
+  def error_body_with_code(code)
+    <<-XML
+<?xml version="1.0"?>
+<RETS ReplyCode="#{code}" ReplyText="Error message">
+</RETS>
+    XML
+  end
+end

data/test/test_file_cache.rb

@@ -0,0 +1,42 @@
+require_relative "helper"
+
+require "tempfile"
+
+class TestFileCache < MiniTest::Test
+
+  def with_tempfile(&block)
+    Tempfile.open(File.basename(__FILE__), &block)
+  end
+
+  def with_temp_path
+    with_tempfile do |file|
+      path = file.path
+      begin
+        file.close!
+        yield path
+      ensure
+        File.delete(path)
+      end
+    end
+  end
+
+  def test_save
+    with_temp_path do |path|
+      cache = Rets::Metadata::FileCache.new(path)
+      cache.save { |file| file.print "foo" }
+      file_contents = File.read(path)
+      assert_equal "foo", file_contents
+    end
+  end
+
+  def test_load
+    with_tempfile do |file|
+      file.print "foo"
+      file.close
+      cache = Rets::Metadata::FileCache.new(file.path)
+      file_contents = cache.load(&:read)
+      assert_equal "foo", file_contents
+    end
+  end
+
+end

data/test/test_http_client.rb

@@ -0,0 +1,132 @@
+require_relative "helper"
+
+class TestHttpClient < MiniTest::Test
+  def setup
+    @cm = WebAgent::CookieManager.new
+
+    @http = HTTPClient.new
+
+    @logger = Rets::Client::FakeLogger.new
+    @logger.stubs(:debug?).returns(false)
+
+    @http_client = Rets::HttpClient.new(@http, {}, @logger, "http://rets.rets.com/somestate/login.aspx")
+  end
+
+  def test_http_get_delegates_to_client
+    url = 'foo@example.com'
+    response = stub(:response)
+    response.stubs(:body).returns('response data')
+
+    @http.stubs(:get).with(url, anything, anything).returns(response)
+
+    assert_equal @http_client.http_get(url, {}), response
+  end
+
+  def test_http_post_delegates_to_client
+    url = 'foo@example.com'
+    response = stub(:response)
+    response.stubs(:body).returns('response data')
+
+    @http.stubs(:post).with(url, anything, anything).returns(response)
+
+    assert_equal @http_client.http_post(url, {}), response
+  end
+end
+
+class CookieManagement < MiniTest::Test
+  def setup
+    @logger = Rets::Client::FakeLogger.new
+    @logger.stubs(:debug?).returns(false)
+
+    @cm = WebAgent::CookieManager.new
+    http = HTTPClient.new
+    http.cookie_manager = @cm
+    @client = Rets::HttpClient.new(http, {}, nil, "http://rets.rets.com/somestate/login.aspx")
+  end
+
+  def teardown
+    # Empty cookie jar
+    @cm.cookies = []
+  end
+
+  def test_http_cookie_with_one_cookie_from_one_domain
+    set_cookie = "RETS-Session-ID=879392834723043209; path=/; domain=rets.rets.com; expires=Wednesday, 31-Dec-2037 12:00:00 GMT"
+    @cm.parse(set_cookie, URI.parse("http://www.rets.rets.com"))
+    assert_equal "879392834723043209", @client.http_cookie('RETS-Session-ID')
+  end
+
+  def test_http_cookie_with_multiple_cookies_from_one_domain
+    # NOTE: Cookies are ordered alphabetically by name when retrieving
+    set_cookie_1 = "RETS-Session-ID=879392834723043209; path=/; domain=rets.rets.com; expires=Wednesday, 31-Dec-2037 12:00:00 GMT"
+    @cm.parse(set_cookie_1, URI.parse("http://www.rets.rets.com"))
+
+    set_cookie_2 = "Zoo=Bar; path=/; domain=rets.rets.com; expires=Wednesday, 31-Dec-2037 12:00:00 GMT"
+    @cm.parse(set_cookie_2, URI.parse("http://www.rets.rets.com"))
+
+    set_cookie_3 = "Foo=Bar; path=/; domain=rets.rets.com; expires=Wednesday, 31-Dec-2037 12:00:00 GMT"
+    @cm.parse(set_cookie_3, URI.parse("http://www.rets.rets.com"))
+
+    assert_equal "879392834723043209", @client.http_cookie('RETS-Session-ID')
+  end
+
+  def test_http_cookie_with_no_cookies_from_domain
+    assert_equal nil, @client.http_cookie('RETS-Session-ID')
+  end
+
+  def test_save_cookie_store
+    cookie_file = Tempfile.new('cookie_file').path
+
+    #setup cookie store
+    client_a = Rets::HttpClient.from_options({ cookie_store: cookie_file, login_url: "http://rets.rets.com/somestate/login.aspx" }, @logger)
+
+    #add cookie
+    cookie = "RETS-Session-ID=879392834723043209; path=/; domain=rets.rets.com; expires=Wednesday, 31-Dec-2037 12:00:00 GMT"
+    client_a.http.cookie_manager.parse(cookie, URI.parse("http://www.rets.rets.com"))
+
+    #save cookie
+    client_a.save_cookie_store
+
+    #create new HTTPCLient with same cookie store
+    client_b = Rets::HttpClient.from_options({ cookie_store: cookie_file, login_url: "http://rets.rets.com/somestate/login.aspx" }, @logger)
+
+    #check added cookie exists
+    assert_equal "879392834723043209", client_b.http_cookie('RETS-Session-ID')
+  end
+
+  def test_creates_cookie_store_if_missing_during_initialization
+    cookie_file = Tempfile.new('cookie_file')
+    cookie_file_path = cookie_file.path
+
+    #remove cookie store
+    cookie_file.unlink
+
+    client = Rets::HttpClient.from_options({cookie_store: cookie_file_path}, @logger)
+
+    #add cookie
+    cookie = "RETS-Session-ID=879392834723043209; path=/; domain=rets.rets.com; expires=Wednesday, 31-Dec-2037 12:00:00 GMT"
+    client.http.cookie_manager.parse(cookie, URI.parse("http://www.rets.rets.com"))
+
+    #check added cookie exists
+    assert_equal "879392834723043209", client.http_cookie('RETS-Session-ID')
+  end
+
+  def test_creates_cookie_store_if_missing_during_save
+    cookie_file = Tempfile.new('cookie_file')
+    cookie_file_path = cookie_file.path
+
+    client = Rets::HttpClient.from_options({cookie_store: cookie_file_path}, @logger)
+
+    #remove cookie store
+    cookie_file.unlink
+
+    #add cookie
+    cookie = "RETS-Session-ID=879392834723043209; path=/; domain=rets.rets.com; expires=Wednesday, 31-Dec-2037 12:00:00 GMT"
+    client.http.cookie_manager.parse(cookie, URI.parse("http://www.rets.rets.com"))
+
+    #save cookie
+    client.save_cookie_store
+
+    #check added cookie exists
+    assert_equal "879392834723043209", client.http_cookie('RETS-Session-ID')
+  end
+end

data/test/test_json_serializer.rb

@@ -0,0 +1,26 @@
+require_relative "helper"
+
+require "stringio"
+
+class TestJsonSerializer < MiniTest::Test
+
+  def setup
+    @serializer = Rets::Metadata::JsonSerializer.new
+  end
+
+  def test_round_trip
+    metadata = {"foo" => "bar"}
+    file = StringIO.new
+    @serializer.save(file, metadata)
+    file.rewind
+    loaded = @serializer.load(file)
+    assert_equal metadata, loaded
+  end
+
+  def test_bad_data
+    file = StringIO.new("bad data")
+    loaded = @serializer.load(file)
+    assert_nil loaded
+  end
+  
+end

data/test/test_locking_http_client.rb

@@ -0,0 +1,29 @@
+require_relative "helper"
+
+class TestLockingHttpClient < MiniTest::Test
+  def setup
+    @fake_client = stub('fake_client')
+    @locker = stub('locker')
+    @locking_client = Rets::LockingHttpClient.new(@fake_client, @locker, 'lock_name')
+    @url = "fake rets url"
+    @params = {'fake_param' => 'fake_param_value'}
+  end
+
+  def test_locking_client_calls_the_real_client_if_lock_succeeds
+    @locker.stubs(:lock).with('lock_name', {}).yields(nil)
+    @fake_client.expects(:http_post).with(@url, @params, {})
+    @locking_client.http_post(@url, @params)
+  end
+
+  def test_locking_client_does_nothing_if_lock_fails_to_yield
+    @fake_client.expects(:http_post).never
+    @locker.stubs(:lock).with('lock_name', {})
+    @locking_client.http_post(@url, @params)
+  end
+
+  def test_locking_client_returns_result_from_client
+    @fake_client.stubs(:http_post).returns('result')
+    @locker.stubs(:lock).with('lock_name', {}).yields(nil)
+    assert_equal 'result', @locking_client.http_post(@url, @params)
+  end
+end

data/test/test_marshal_serializer.rb

@@ -0,0 +1,26 @@
+require_relative "helper"
+
+require "stringio"
+
+class TestMarshalSerializer < MiniTest::Test
+
+  def setup
+    @serializer = Rets::Metadata::MarshalSerializer.new
+  end
+
+  def test_round_trip
+    metadata = {"foo" => "bar"}
+    file = StringIO.new
+    @serializer.save(file, metadata)
+    file.rewind
+    loaded = @serializer.load(file)
+    assert_equal metadata, loaded
+  end
+
+  def test_bad_data
+    file = StringIO.new("bad data")
+    loaded = @serializer.load(file)
+    assert_nil loaded
+  end
+  
+end