rets4r 0.8.5 → 1.1.18

data/lib/rets4r/client/parser.rb

@@ -1,141 +0,0 @@
-# This is the generic parser 
-#
-#	Supports responses, data, metadata, reply codes, and reply text.
-#
-#	Supports the following tags:
-#		RETS, METADATA-.*, MAXROWS, COLUMNS, DATA, COUNT, DELIMITER
-#
-#	Metadata is built as:
-#		(Metadata 1-> data row
-#		           -> data row),
-#		(Metadata 2 -> data row),
-#		etc.
-#
-#	Data is built as:
-#		Data 1, Data 2, Data N
-#
-#
-#	TODO
-#		Add comments/documentation
-#		Handle more tags (if any are unaccounted for)
-#   Handle standard (non-compact) output
-#		Case Insensitivity?
-# 	There is still some holdovers from the previous organization of parsers, and they should be cleaned
-# 	  up at some point.
-
-require 'cgi'
-
-module RETS4R
-	class Client
-		module Parser			
-			attr_accessor :output, :logger
-			
-			def initialize
-				@transaction = Transaction.new
-				@current	   = []
-				@output      = 2
-			end
-			
-			def get_transaction
-				@transaction
-			end
-					
-			#### Stream Listener Events
-			def tag_start(name, attrs)		
-				@current.push(name)
-	
-				case name
-					when 'RETS'
-						@transaction.reply_code = attrs['ReplyCode']
-						@transaction.reply_text = attrs['ReplyText']
-					when /METADATA.*/
-						@metadata = Metadata.new(name)
-						@metadata.attributes = attrs
-					when 'MAXROWS'
-						@transaction.maxrows = true
-					when 'COUNT'
-						@transaction.count     = attrs['Records'].to_i
-					when 'DELIMITER'
-						@transaction.delimiter = attrs['value'].to_i
-				end
-			end
-			
-			def text(text)
-				case @current[-1]
-					when 'COLUMNS'
-						@transaction.header = parse_compact_line(text, @transaction.ascii_delimiter)
-						
-					when 'DATA'
-						if @transaction.header.length > 0
-							data_type << parse_data(text, @transaction.header)
-						else
-							data_type << parse_compact_line(text, @transaction.ascii_delimiter)
-						end
-					
-					when 'RETS-RESPONSE'
-						@transaction.response = parse_key_value_body(text)
-				end
-			end
-			
-			def tag_end(name)
-				@current.pop
-				
-				@transaction.data << @metadata if name =~ /METADATA.*/
-			end
-			
-			#### Helper Methods
-			def clean_xml(xml)				
-				# This is a hack, and it assumes that we're using compact mode, but it's the easiest way to
-				# strip out those bad "<" and ">" characters that were not properly escaped...
-				xml.gsub!(/<DATA>(.*)<\/DATA>/i) do |match|
-					"<DATA>#{CGI::escapeHTML(CGI::unescapeHTML($1))}</DATA>"
-				end
-			end
-			
-			def data_type
-				if @current[-2].index('METADATA') === 0
-					return @metadata
-				else
-					return @transaction.data
-				end
-			end
-			
-			def parse_compact_line(data, delim = "\t")
-				begin
-					# We need to remove the beginning and ending delimiters prior to splitting
-					string_data = data.to_s
-					return string_data[1, string_data.length - 2].split(delim, -1)
-				rescue
-					raise "Error while parsing compact line: #{$!} with data: #{data}"
-				end
-			end
-			
-			def parse_data(data, header)			
-				results = Data.new(@current[-2])
-				
-				parsed_data = parse_compact_line(data, @transaction.ascii_delimiter)
-				
-				header.length.times do |pos|
-					# The removal of delimiters in #parse_compact_line prevents blank fields in newer
-					# version of Ruby, but on older versions (specifically 1.8.5 from 2006) a blank
-					# field would still manage to sneak in, so we now explicitly prevent them from going
-					# to the results.
-					results[header[pos]] = parsed_data[pos] unless header[pos].nil? || header[pos].strip == ""
-				end
-				
-				results
-			end
-			
-			def parse_key_value_body(data)
-				parsed = {}
-				
-				data.each do |line|
-					(key, value) = line.strip.split('=')
-					parsed[key] = value
-				end
-				
-				return parsed
-			end
-		end
-	end
-end

data/lib/rets4r/client/parser/rexml.rb

@@ -1,75 +0,0 @@
-require 'rets4r/client/parser'
-require 'rexml/parsers/baseparser'
-require 'rexml/parsers/streamparser'
-require 'rexml/streamlistener'
-require 'rets4r/client/transaction'
-require 'rets4r/client/data'
-require 'rets4r/client/metadata'
-
-module RETS4R
-	class Client
-		module Parser
-			class REXML
-				include Parser
-
-				SUPPORTED_PARSERS << self
-				
-				attr_accessor :logger
-				
-				def initialize
-					@transaction = Transaction.new
-					@current	   = []
-				end
-				
-				def parse(xml, output = false, do_retry = true)
-					output = self.output unless output # Allow per-parse output changes
-					
-					return xml if output == OUTPUT_RAW
-					
-					# This is an legacy option that is not currently supported by XMLParser, but it is left in
-					# here for reference or "undocumented usage."
-					if output == OUTPUT_DOM
-						return ::REXML::Document.new(xml)
-					end			
-					
-					# If we're here, then we need to output a RETS::Data object
-					listener = StreamListener.new
-					
-					begin
-						stream = ::REXML::Parsers::StreamParser.new(xml, listener)
-						stream.parse
-					rescue ::REXML::ParseException, Exception
-						# We should get fancier here and actually check the type of error, but, err, oh well.
-						if do_retry
-							logger.info("Unable to parse XML on first try due to '#{$!}'. Now retrying.") if logger
-							
-							return parse(clean_xml(xml), output, false)
-						else
-							ex = ParserException.new($!)
-							ex.file = xml
-							
-							logger.error("REXML parser was unable to parse XML: #{$!}") if logger
-							logger.error("Unparsable XML was:\n#{xml}") if logger
-							
-							raise ex
-						end
-					end
-					
-					return listener.get_transaction
-				end
-				
-				class StreamListener
-					include ::REXML::StreamListener
-					include Parser				
-
-					def initialize(logger = nil)
-						self.logger  = logger
-						@transaction = Transaction.new
-						@current	   = []
-						@output      = 2
-					end
-				end
-			end
-		end
-	end
-end	

data/lib/rets4r/client/parser/xmlparser.rb

@@ -1,95 +0,0 @@
-# Because XMLParser may not be present on this system, we attempt to require it and if it
-# succeeds, we create the XMLParser and add it to the supported parsers. The user of the client 
-# can still switch to REXML if desired.
-begin
-	require 'xml/parser'
-	require 'rets4r/client/parser'
-	require 'rets4r/client/transaction'
-	require 'rets4r/client/data'
-	require 'rets4r/client/metadata'
-	
-	module RETS4R
-		class Client
-			module Parser
-				class XMLParser < XML::Parser
-					include Parser
-					
-					SUPPORTED_PARSERS << self
-						
-					attr_accessor :logger
-					
-					def initialize
-						@transaction = Transaction.new
-						@current	   = []
-						@text        = ''
-					end
-					
-					def parse(xml, output = false, do_retry = true)			
-						begin
-							super(xml)
-						rescue XMLParserError
-								line = self.line
-							
-								# We should get fancier here and actually check the type of error, but, err, oh well.
-								if do_retry			  		
-									# We probably received this error because somebody forgot to escape XML entities...
-									# so we attempt to escape them ourselves...													
-									do_retry = false
-									
-									begin
-										cleaned_xml = self.clean_xml(xml)
-										
-										# Because a cparser can only be used once per instantiation...
-										retry_xml = self.class.new
-										retry_xml.parse(cleaned_xml, output, do_retry)
-										
-										@transaction = retry_xml.get_transaction
-										
-									rescue
-										ex = ParserException.new($!)
-										ex.file = xml
-		
-										raise ex
-									end
-							else
-								# We should never get here! But if we do...
-								raise "You really shouldn't be seeing this error message! This means that there was an unexpected error: #{$!} (#{$!.class})"
-							end
-						end
-									
-						@transaction
-					end
-					
-					def get_transaction
-						@transaction
-					end
-					
-					private
-					
-					#### Stream Listener Events
-					def startElement(name, attrs)		
-						tag_start(name, attrs)
-					end
-					
-					def character(text)
-						@text += text
-					end
-					
-					def processText()
-						text(@text)
-						
-						@text = ''
-					end
-					
-					def endElement(name)
-						processText()
-						
-						tag_end(name)
-					end
-				end
-			end
-		end
-	end 
-rescue LoadError
-	# CParser is not available because we could not load the XMLParser library	
-end

data/test/client/parser/tc_rexml.rb

@@ -1,17 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__), "../..", "lib")
-
-require 'test/unit'
-require 'rets4r/client/parser/rexml'
-require 'test/client/test_parser'
-
-module RETS4R
-	class Client		
-		class TestRParser < Test::Unit::TestCase
-			include TestParser
-			
-			def setup
-				@parser = Parser::REXML.new
-			end
-		end
-	end
-end

data/test/client/parser/tc_xmlparser.rb

@@ -1,21 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__), "../..", "lib")
-
-require 'test/unit'
-require 'rets4r/client/parser/xmlparser'
-require 'test/client/test_parser'
-
-module RETS4R
-	class Client
-		if Module.constants.include?('XMLParser') && SUPPORTED_PARSERS.include?(Parser::XMLParser)
-			class TestCParser < Test::Unit::TestCase
-				include TestParser
-				
-				def setup
-					@parser = Parser::XMLParser.new
-				end
-			end
-		else
-			puts "Skipping RETS4R XMLParser testing because XMLParser is not available."
-		end
-	end
-end

data/test/client/tc_auth.rb

@@ -1,68 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__), "../..", "lib")
-
-require 'rets4r/auth'
-require 'test/unit'
-
-module RETS4R
-	class TestAuth < Test::Unit::TestCase
-		def setup
-			@useragent  = 'TestAgent/0.00'
-			@username   = 'username'
-			@password   = 'password'
-			@realm      = 'REALM'
-			@nonce      =  '2006-03-03T17:37:10'
-		end
-		
-		def test_authenticate
-			response = {
-				'www-authenticate' => 'Digest qop="auth",realm="'+ @realm +'",nonce="'+ @nonce +'",opaque="",stale="false",domain="\my\test\domain"'
-				}
-				
-			Auth.authenticate(response, @username, @password, '/my/rets/url', 'GET', Auth.request_id, @useragent)
-		end
-		
-		# test without spacing
-		def test_parse_auth_header_without_spacing
-			header = 'Digest qop="auth",realm="'+ @realm +'",nonce="'+ @nonce +'",opaque="",stale="false",domain="\my\test\domain"'
-			check_header(header)
-		end
-		
-		# test with spacing between each item
-		def test_parse_auth_header_with_spacing
-			header = 'Digest qop="auth", realm="'+ @realm +'", nonce="'+ @nonce +'", opaque="", stale="false", domain="\my\test\domain"'
-			check_header(header)
-		end
-		
-		# used to check the that the header was processed properly.
-		def check_header(header)
-			results = Auth.parse_header(header)
-			
-			assert_equal('auth', results['qop'])
-			assert_equal('REALM', results['realm'])
-			assert_equal('2006-03-03T17:37:10', results['nonce'])
-			assert_equal('', results['opaque'])
-			assert_equal('false', results['stale'])
-			assert_equal('\my\test\domain', results['domain'])
-		end
-		
-		def test_calculate_digest
-			# with qop
-			assert_equal('c5f9ef280f0ca78ed7a488158fc2f4cc', Auth.calculate_digest(@username, \
-				@password, @realm, 'test', 'GET', '/my/rets/url', true, 'test'))
-			
-			# without qop
-			assert_equal('bceafa34467a3519c2f6295d4800f4ea', Auth.calculate_digest(@username, \
-				@password, @realm, 'test', 'GET', '/my/rets/url', false))
-		end
-		
-		def test_request_id
-			assert_not_nil(true, Auth.request_id)
-		end
-		
-		def test_cnonce
-			# We call cnonce with a static request ID so that we have a consistent result with which 
-			# to test against
-			assert_equal('d5cdfa1acffde590d263689fb40cf53c', Auth.cnonce(@useragent, @password, 'requestId', @nonce))
-		end
-	end
-end

data/test/client/tc_client.rb

@@ -1,320 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__), "../..", "lib")
-
-require 'rets4r/client'
-require 'test/unit'
-require 'stringio'
-require 'logger'
-require 'rubygems' rescue nil
-require 'mocha'
-
-module RETS4R
-	class Client
-		public :process_content_type
-	end
-	
-	class TestClientGetMetadata < Test::Unit::TestCase
-		RETS_PORT     = '9080'
-		RETS_URL      = "http://localhost:#{RETS_PORT}"
-		RETS_LOGIN    = 'login'
-		RETS_PASSWORD = 'password'
-		
-		class CustomError < StandardError; end
-		
-		def setup
-			@logfile = StringIO.open
-			@rets    = RETS4R::Client.new(RETS_URL)
-			@rets.logger = Logger.new(@logfile)
-			@rets.logger.level = Logger::DEBUG
-			
-			@rets.stubs(:request).returns(@response = mock("response"))
-			@response.stubs(:body).returns(:body)
-			@rets.stubs(:parse).returns(@results = mock("results"))
-		end
-
-		def teardown
-			@logfile.close
-		end
-		
-		def test_get_metadata_yields_the_results_if_given_a_block
-			@rets.expects(:parse).returns(@results = mock("results"))
-			
-			in_block = false
-			@rets.get_metadata do |results|
-				in_block = true
-				assert_equal @results, results
-			end
-			
-			assert in_block, "Block was never yielded to"
-		end
-		
-		def test_get_metadata_returns_the_metadata_when_no_block_given
-			rval = @rets.get_metadata
-			
-			assert_equal @results, rval
-		end
-		
-		def test_get_metadata_returns_the_blocks_value_when_given_a_block
-			rval = @rets.get_metadata do |results|
-				:block_value
-			end
-			
-			assert_equal :block_value, rval
-		end
-	end
-	
-	class TestClientGetObject < Test::Unit::TestCase
-		RETS_PORT     = '9080'
-		RETS_URL      = "http://localhost:#{RETS_PORT}"
-		RETS_LOGIN    = 'login'
-		RETS_PASSWORD = 'password'
-		
-		class CustomError < StandardError; end
-		
-		def setup
-			@logfile = StringIO.open
-			@rets    = RETS4R::Client.new(RETS_URL)
-			@rets.logger = Logger.new(@logfile)
-			@rets.logger.level = Logger::DEBUG
-
-			@rets.stubs(:request).returns(@response = mock("response"))
-		end
-
-		def test_returns_multipart_parallel_objects_in_a_single_array
-			@response.expects(:[]).with('content-type').at_least_once.returns("multipart/parallel; boundary=1231")
-			@response.expects(:body).returns("\r\n--1231\r\nContent-ID: 392103\r\nObject-ID: 1\r\nContent-Type: image/jpeg\r\n\r\n" + "\000"*120 + "\r\n--1231\r\nContent-ID: 392103\r\nObject-ID: 2\r\nContent-Type: image/gif\r\n\r\n" + "\000"*140 + "\r\n--1231--")
-			results = @rets.get_object("Property", "Photo", "392103:*")
-			assert_equal 2, results.size, "Client parsed two objects out of the request"
-			assert_kind_of RETS4R::Client::DataObject, results[0], "First result isn't a DataObject"
-			assert_kind_of RETS4R::Client::DataObject, results[1], "Second result isn't a DataObject"
-			assert_equal "image/jpeg", results[0].type["Content-Type"], "First object isn't an image/jpeg"
-			assert_equal 120, results[0].data.size, "First object isn't 120 bytes in length"
-			assert_equal "image/gif", results[1].type["Content-Type"], "Second object isn't an image/gif"
-			assert_equal 140, results[1].data.size, "Second object isn't 140 bytes in length"
-		end
-
-		def test_returns_single_entity_object_in_a_single_element_array
-			@response.expects(:[]).with('content-type').at_least_once.returns("image/jpeg")
-			@response.expects(:[]).with('Transfer-Encoding').at_least_once.returns("")
-			@response.expects(:[]).with('Content-Length').at_least_once.returns(241)
-			@response.expects(:[]).with('Object-ID').at_least_once.returns("25478")
-			@response.expects(:[]).with('Content-ID').at_least_once.returns("5589")
-			@response.expects(:body).returns("\000"*241)
-
-			results = @rets.get_object("Property", "Photo", "392103:*")
-			assert_equal 1, results.size, "Client parsed one object out of the request"
-			assert_kind_of RETS4R::Client::DataObject, results[0], "First result isn't a DataObject"
-			assert_equal "image/jpeg", results[0].type["Content-Type"], "Content-Type not copied"
-			assert_equal "5589", results[0].type["Content-ID"], "Content-ID not copied"
-			assert_equal "25478", results[0].type["Object-ID"], "Object-ID not copied"
-			assert_equal 241, results[0].data.size, "First object isn't 241 bytes in length"
-		end
-
-		def test_returns_single_entity_object_as_chunked_encoding_in_a_single_element_array
-			@response.expects(:[]).with('content-type').at_least_once.returns("image/jpeg")
-			@response.expects(:[]).with('Transfer-Encoding').at_least_once.returns("chunked")
-			@response.expects(:[]).with('Object-ID').at_least_once.returns("25478")
-			@response.expects(:[]).with('Content-ID').at_least_once.returns("5589")
-			@response.expects(:body).returns("\000"*241)
-
-			results = @rets.get_object("Property", "Photo", "392103:*")
-			assert_equal 1, results.size, "Client parsed one object out of the request"
-			assert_kind_of RETS4R::Client::DataObject, results[0], "First result isn't a DataObject"
-			assert_equal "image/jpeg", results[0].type["Content-Type"], "Content-Type not copied"
-			assert_equal "5589", results[0].type["Content-ID"], "Content-ID not copied"
-			assert_equal "25478", results[0].type["Object-ID"], "Object-ID not copied"
-			assert_equal 241, results[0].data.size, "First object isn't 241 bytes in length"
-		end
-
-		def test_yields_data_objects_to_block_and_returns_blocks_value
-			@response.expects(:[]).with('content-type').at_least_once.returns("image/jpeg")
-			@response.expects(:[]).with('Transfer-Encoding').at_least_once.returns("")
-			@response.expects(:[]).with('Content-Length').at_least_once.returns(241)
-			@response.expects(:[]).with('Object-ID').at_least_once.returns("25478")
-			@response.expects(:[]).with('Content-ID').at_least_once.returns("5589")
-			@response.expects(:body).returns("\000"*241)
-
-			yielded_count = 0
-			
-			value = @rets.get_object("Property", "VRImage", "912:0") do |result|
-				assert_kind_of RETS4R::Client::DataObject, result	
-				yielded_count += 1
-				:return_value
-			end
-
-			assert_equal yielded_count, value
-		end
-	end
-	
-	class TestClientLogin < Test::Unit::TestCase
-		RETS_PORT     = '9080'
-		RETS_URL      = "http://localhost:#{RETS_PORT}"
-		RETS_LOGIN    = 'login'
-		RETS_PASSWORD = 'password'
-		
-		class CustomError < StandardError; end
-		
-		def setup
-			@logfile = StringIO.open
-			@rets    = RETS4R::Client.new(RETS_URL)
-			@rets.logger = Logger.new(@logfile)
-			@rets.logger.level = Logger::DEBUG
-
-			@rets.stubs(:request).returns(@response = mock("response"))
-			@response.stubs(:body).returns(:body)
-			@rets.stubs(:parse).returns(@results = mock("results"))
-			@results.stubs(:success?).returns(true)
-			@results.stubs(:response).returns(Hash.new)
-			@results.stubs(:secondary_response=)
-		end
-
-		def teardown
-			@logfile.close
-		end
-
-		def test_successful_login_yields_the_results_to_the_block
-			@rets.expects(:request).with {|arg| arg.kind_of?(URI)}.returns(@response)
-			@rets.expects(:parse).with(:body, RETS4R::Client::OUTPUT_RUBY).returns(@results)
-			@results.expects(:success?).returns(true)
-			@rets.expects(:logout)
-
-			in_block = false
-			@rets.login("user", "pass") do |results|
-				assert_equal @results, results
-				in_block = true
-			end
-			
-			assert in_block, "Block was never yielded to"
-		end
-
-		def test_logout_called_after_block_execution_if_block_raises
-			assert_raises(CustomError) do
-				@rets.expects(:logout)
-				@rets.login("user", "pass") do |results|
-					raise CustomError
-				end
-			end
-		end
-		
-		def test_login_returns_the_blocks_value
-			rval = @rets.login("user", "pass") do |results|
-				:value
-			end
-			
-			assert_equal :value, rval
-		end
-		
-		def test_login_without_a_block_returns_the_results
-			results = @rets.login("user", "pass")
-			assert_equal @results, results
-		end
-	end
-	
-	class TestClient < Test::Unit::TestCase
-		RETS_PORT     = '9080'
-		RETS_URL      = "http://localhost:#{RETS_PORT}"
-		RETS_LOGIN    = 'login'
-		RETS_PASSWORD = 'password'
-		
-		def setup
-			@logfile = StringIO.open
-			@rets    = RETS4R::Client.new(RETS_URL)
-			@rets.logger = Logger.new(@logfile)
-			@rets.logger.level = Logger::DEBUG
-		end
-
-		def teardown
-			@logfile.close
-		end
-		
-		def test_setup
-			assert_nothing_raised() { @rets.set_user_agent('ACK/2.1') }
-			assert_equal('ACK/2.1', @rets.user_agent)
-
-			assert_nothing_raised() { @rets.user_agent = 'SPRETS/0.1' }
-			assert_nothing_raised() { @rets.set_request_method('GET') }
-			
-			assert_raise(RETS4R::Client::Unsupported) { @rets.set_rets_version('1.4.0') }
-			assert_nothing_raised() { @rets.set_rets_version('1.5') }
-			assert_equal("1.5", @rets.rets_version)
-			assert_equal("RETS/1.5", @rets.get_header("RETS-Version"))
-			assert_nothing_raised() { @rets.rets_version = '1.7' }
-			assert_equal("RETS/1.7", @rets.get_header("RETS-Version"))
-			
-			assert_equal('SPRETS/0.1', @rets.get_user_agent)
-			assert_equal('GET', @rets.get_request_method)
-			assert_equal('1.7', @rets.get_rets_version)
-			
-			assert_nothing_raised() { @rets.request_method = 'POST' }
-			
-			assert_equal('POST', @rets.request_method)
-			
-			assert_nothing_raised() { @rets.set_parser_class(Client::Parser::REXML) }
-			assert_raise(Client::Unsupported) { @rets.parser_class = MockParser }
-			assert_nothing_raised() { @rets.set_parser_class(MockParser, true) }
-			assert_equal(MockParser, @rets.parser_class)
-			
-			assert_nothing_raised() { @rets.set_output(RETS4R::Client::OUTPUT_RAW) }
-			assert_equal(RETS4R::Client::OUTPUT_RAW, @rets.output)
-			assert_nothing_raised() { @rets.output = RETS4R::Client::OUTPUT_RUBY }
-			assert_equal(RETS4R::Client::OUTPUT_RUBY, @rets.get_output)
-			
-			# Check that our changes were logged when in debug mode
-			assert @logfile.length > 0
-		end
-		
-		# Just to make sure that we're okay when we don't have a logger, we set it to nil and
-		# make a change that would trigger a debug mode log.
-		def test_without_logger
-			@rets.logger = nil
-			
-			assert_nothing_raised() { @rets.set_request_method('GET') }
-		end
-		
-		def test_content_type_parsing
-			ct = 'multipart/parallel; boundary=cc2631bb.0165.3b32.8a7d.a8453f662101; charset=utf-8'
-			
-			results = @rets.process_content_type(ct)
-
-			assert_equal('cc2631bb.0165.3b32.8a7d.a8453f662101', results['boundary'])
-			assert_equal('multipart/parallel', results['content-type'])
-			assert_equal('utf-8', results['charset'])
-		end
-	
-		def test_performs_get_request
-			assert_nothing_raised() {@rets.request_method = 'GET'}	
-			assert_equal('GET', @rets.request_method)
-			
-			http     = mock('http')
-			response = mock('response')
-			response.stubs(:to_hash).returns({})
-			response.stubs(:code).returns('500')
-			response.stubs(:message).returns('Move along, nothing to see here.')
-			
-			http.expects(:get).with('', {'RETS-Session-ID' => '0', 'User-Agent' => @rets.user_agent, 'RETS-Version' => "RETS/#{@rets.rets_version}", 'Accept' => '*/*'}).at_least_once.returns(response)
-			http.expects(:post).never
-			Net::HTTP.any_instance.expects(:start).at_least_once.yields(http)
-			
-			assert_raises(RETS4R::Client::HTTPError) {@rets.login('user', 'pass')}
-		end
-		
-		def test_performs_post_request
-			assert_nothing_raised() {@rets.request_method = 'POST'}	
-			assert_equal('POST', @rets.request_method)
-			
-			http     = mock('http')
-			response = mock('response')
-			response.stubs(:to_hash).returns({})
-			response.stubs(:code).returns('500')
-			response.stubs(:message).returns('Move along, nothing to see here.')
-			
-			http.expects(:post).with('', '', {'RETS-Session-ID' => '0', 'User-Agent' => @rets.user_agent, 'RETS-Version' => "RETS/#{@rets.rets_version}", 'Accept' => '*/*'}).at_least_once.returns(response)
-			http.expects(:get).never
-			Net::HTTP.any_instance.expects(:start).at_least_once.yields(http)
-			
-			assert_raises(RETS4R::Client::HTTPError) {@rets.login('user', 'pass')}
-		end
-		
-		class MockParser
-		end
-	end
-end