innards 0.1.0.pre → 0.1.0

data/lib/innards/cookie_handler.rb

@@ -0,0 +1,24 @@
+require 'uri'
+
+module Innards
+
+  # Handles Digest Authentication
+  class CookieHandler
+
+    def initialize(params)
+      @params = params
+    end
+
+    def parse cookie_header
+      cookie_header.scan(/(\w+)=(.+?);/) {
+        @params[:cookies].push([$1, $2])
+      }
+    end
+
+    def build
+      cookies = @params[:cookies]
+      URI.encode_www_form(cookies) unless cookies.empty?
+    end
+
+  end
+end

data/lib/innards/digest_handler.rb

@@ -0,0 +1,93 @@
+module Innards
+
+  # Handles Digest Authentication
+  class DigestHandler
+
+    include Innards::Exceptions
+
+    def initialize(params)
+      @params = params
+    end
+
+    def parse www_authenticate_header
+      digest = {}
+      www_authenticate_header.scan(/(\w+)="(.*?)"/) {
+        digest[$1] = $2
+      }
+      if www_authenticate_header =~ /stale=true$/
+        digest[:stale] = true
+        raise StaleDigestException.new
+      end
+      @params[:digest] = digest
+    end
+
+    def build_for path
+      digest = @params[:digest]
+      return nil if digest.empty?
+
+      cnonce = generate_md5_hash(random)
+      header = [
+        %Q(Digest username="#{@params[:login_uri].user}"),
+        %Q(realm="#{digest['realm']}"),
+        %Q(nonce="#{digest['nonce']}"),
+        %Q(uri="#{path}"),
+        %Q(response="#{build_digest(path, cnonce)}"),
+      ]
+
+      if has_qop?
+        fields = [
+          %Q(cnonce="#{cnonce}"),
+          %Q(qop="#{digest['qop']}"),
+          %Q(nc=#{request_nc})
+        ]
+        fields.each { |field| header << field }
+      end
+
+      header << %Q(opaque="#{digest['opaque']}") if has_opaque?
+      header.join(", ")
+    end
+
+    def build_digest path, cnonce
+      digest = @params[:digest]
+      digest_parts = [
+                      generate_md5_hash(generate_ha1_hash),
+                      digest['nonce'],
+                      generate_md5_hash(generate_ha2_hash(path))]
+      digest_parts.insert(2, request_nc, cnonce, digest['qop']) if has_qop?
+      generate_md5_hash(digest_parts.join(":"))
+    end
+
+    def has_opaque?
+      digest = @params[:digest]
+      digest.has_key?('opaque') and !digest['opaque'].empty?
+    end
+
+    def has_qop?
+      digest = @params[:digest]
+      digest.has_key?('qop') and !digest['qop'].empty?
+    end
+
+    def generate_ha1_hash
+      login_uri = @params[:login_uri]
+      digest = @params[:digest]
+      [login_uri.user, digest['realm'], login_uri.password].join(":")
+    end
+
+    def generate_ha2_hash(path)
+      ["GET", path].join(":")
+    end
+
+    def request_nc
+      "%08d" % @params[:request_count]
+    end
+
+    def random
+      "%x" % (Time.now.to_i + rand(65535))
+    end
+
+    def generate_md5_hash(str)
+      Digest::MD5.hexdigest(str)
+    end
+
+  end
+end

data/lib/innards/exceptions.rb

@@ -1,8 +1,35 @@
 module Innards
   module Exceptions
-    
-    class AuthenticationRequiredException < Exception
-    end
-    
+
+    # Thrown when a invalid URL is passed
+    class InvalidUrlException < StandardError; end
+
+    # Thrown when a invalid/unsupported RETS Version is passed
+    class InvalidRetsVersionException < StandardError; end
+
+    # Thrown when a invalid Auth Mode is passed
+    class InvalidAuthModeException < StandardError; end
+
+    # Thrown when a invalid User Agent is passed
+    class InvalidUserAgentException < StandardError; end
+
+    # Thrown when the rets conection requires authentication
+    class AuthenticationRequiredException < StandardError; end
+
+    # Thrown when digest data is stale and the request needs to be retried
+    class StaleDigestException < StandardError; end
+
+    # Thrown when a function is called which requres a logged in session
+    class LoginRequiredException < StandardError; end
+
+    # Invalid Search Type
+    class InvalidSearchTypeException < StandardError; end
+
+    # Invalid Search Type
+    class InvalidClassException < StandardError; end
+
+    # Invalid Search Type
+    class InvalidQueryException < StandardError; end
+
   end
 end

data/lib/innards/multipart_handler.rb

@@ -0,0 +1,31 @@
+require 'multipart_parser/reader'
+
+module Innards
+
+  # Handles Digest Authentication
+  class MultipartHandler
+
+    def initialize(content_type)
+      @boundary = MultipartParser::Reader.extract_boundary_value(content_type)
+    rescue MultipartParser::NotMultipartError
+      @boundary = ""
+    end
+
+    def parse body
+      parts = []
+      multipart_reader = MultipartParser::Reader.new @boundary
+      multipart_reader.on_part do |part|
+        part.on_data do |data|
+          parts << part.headers.merge({:data => data})
+        end
+      end
+      multipart_reader.write body.strip
+      parts
+    end
+
+    def is_multipart_response?
+      !@boundary.empty?
+    end
+
+  end
+end

data/lib/innards/parsers/get_metadata_parser.rb

@@ -0,0 +1,64 @@
+
+module Innards
+  module Parsers
+
+    # SAX Parser for RETS Metadata
+    class GetMetadataParser < ParserBase
+
+      METADATA_SECTIONS = {
+        "METADATA-RESOURCE" => :resources,
+        "METADATA-CLASS" => :classes,
+        "METADATA-TABLE" => :tables,
+        "METADATA-OBJECT" => :objects,
+        "METADATA-SEARCH_HELP" => :search_help,
+        "METADATA-EDITMASK" => :edit_masks,
+        "METADATA-LOOKUP" => :lookups,
+        "METADATA-LOOKUP_TYPE" => :lookup_types
+      }
+
+      def initialize
+        super()
+        @current_builder = {}
+      end
+
+      def start_element(name)
+        super
+      end
+
+      def end_element(name)
+        super
+        if METADATA_SECTIONS.has_key?(name.to_s)
+          @current_builder = {}
+        end
+      end
+
+      def attr(name, value)
+        super
+        METADATA_SECTIONS.each_key do |section|
+          if switch_active?(:"#{section}")
+            @current_builder[name.to_sym] = value
+          end
+        end
+      end
+
+      def text(value)
+        super
+
+        if switch_active?(:COLUMNS)
+          @current_builder[:columns] = data_splitter(value)
+        end
+
+        METADATA_SECTIONS.each_pair do |section, symbol|
+          if switch_active?(:"#{section}") and switch_active?(:DATA)
+            parsed_data = data_merger(@current_builder[:columns], data_splitter(value))
+            filtered = @current_builder.reject{ |key| key == :columns }
+
+            @metadata[symbol] = [] unless @metadata.has_key?(symbol)
+            @metadata[symbol].push parsed_data.merge(filtered)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/innards/parsers/login_parser.rb

@@ -0,0 +1,29 @@
+
+module Innards
+  module Parsers
+
+    # SAX Parser for RETS Login Response
+    class LoginParser < ParserBase
+
+      def start_element(name)
+        super
+      end
+
+      def end_element(name)
+        super
+      end
+
+      def attr(name, value)
+        super
+      end
+
+      def text(value)
+        super
+        if switch_active?(:RETS)
+          @metadata.merge! split_multiline_key_value_pairs(value)
+        end
+      end
+
+    end
+  end
+end

data/lib/innards/parsers/logout_parser.rb

@@ -0,0 +1,29 @@
+
+module Innards
+  module Parsers
+
+    # SAX Parser for RETS Logout Response
+    class LogoutParser < ParserBase
+
+      def start_element(name)
+        super
+      end
+
+      def end_element(name)
+        super
+      end
+
+      def attr(name, value)
+        super
+      end
+
+      def text(value)
+        super
+        if switch_active?(:"RETS-RESPONSE")
+          @metadata.merge! split_multiline_key_value_pairs(value)
+        end
+      end
+
+    end
+  end
+end

data/lib/innards/parsers/parser_base.rb

@@ -0,0 +1,73 @@
+require 'uri'
+require 'ox'
+
+module Innards
+  module Parsers
+
+    # Base Parser from which all RETS Response Parsers are based
+    class ParserBase < ::Ox::Sax
+
+      attr_reader :rets_response, :metadata
+
+      def initialize
+        @switches = {}
+        @metadata = {}
+      end
+
+      def start_element(name)
+        element_tracker_switch name, true
+      end
+
+      def end_element(name)
+        element_tracker_switch name, false
+      end
+
+      def attr(name, value)
+        if switch_active?(:RETS)
+          @rets_response = {} unless @rets_response.kind_of?(Hash)
+          @rets_response[name] = value
+        end
+      end
+
+      def text(value)
+      end
+
+      def split_multiline_key_value_pairs value
+        result = {}
+        value.scan(/(\w+) = (.*?)$/) do |match|
+          result[match[0].to_sym] = match[1].gsub(/http:\/\/.+?\//, "/")
+        end
+        result
+      end
+
+      def valid_rets_response_received?
+        response_code == 0
+      end
+
+      def response_code
+        @rets_response[:ReplyCode].to_i if @rets_response.has_key?(:ReplyCode)
+      end
+
+      def element_tracker_switch element, currently_in
+        @switches[element] = currently_in
+      end
+
+      def switch_active? element
+        (@switches[element] == true)
+      end
+
+      def data_splitter data
+        data.split(/\t/)
+      end
+
+      def data_merger columns, data
+        merged_data = {}
+        columns.each_with_index do |object, index|
+          merged_data[object] = data[index] unless index == 0
+        end
+        merged_data
+      end
+
+    end
+  end
+end

data/lib/innards/parsers/search_parser.rb

@@ -0,0 +1,41 @@
+
+module Innards
+  module Parsers
+
+    # SAX Parser for RETS Search Response
+    class SearchParser < ParserBase
+
+      attr_reader :columns, :results
+
+      def initialize
+        super
+        @results = []
+      end
+
+      def start_element(name)
+        super
+      end
+
+      def end_element(name)
+        super
+      end
+
+      def attr(name, value)
+        super
+      end
+
+      def text(value)
+        super
+
+        if switch_active?(:COLUMNS)
+          @columns = data_splitter(value)
+        end
+
+        if switch_active?(:DATA)
+          @results.push data_merger(@columns, data_splitter(value))
+        end
+      end
+
+    end
+  end
+end

data/lib/innards/version.rb

@@ -3,8 +3,8 @@ module Innards
     MAJOR = 0
     MINOR = 1
     PATCH = 0
-    BUILD = 'pre'
+    BUILD = nil
 
     STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')
   end
-end
+end

data/spec/innards/connection_spec.rb

@@ -0,0 +1,232 @@
+require "spec_helper"
+
+describe Innards::Connection do
+
+  context "during intialization" do
+    before do
+      @valid_hash = {:login_url => "http://www.dis.com:6103/rets/login"}
+      @invalid_hash = {:login_url => ""}
+    end
+
+    it "should validate the URL" do
+      expect { Innards::Connection.new(@valid_hash) }.not_to raise_error()
+      expect { Innards::Connection.new(@invalid_hash) }.to raise_error()
+    end
+
+    it "should valididate RETS Version" do
+      expect { Innards::Connection.new(@valid_hash.merge({:rets_version => "1.5"})) }.not_to raise_error()
+      expect { Innards::Connection.new(@valid_hash.merge({:rets_version => "1.7"})) }.not_to raise_error()
+      expect { Innards::Connection.new(@valid_hash.merge({:rets_version => "1.7.2"})) }.not_to raise_error()
+      expect { Innards::Connection.new(@valid_hash.merge({:rets_version => "1.8"})) }.not_to raise_error()
+      expect { Innards::Connection.new(@valid_hash.merge({:rets_version => "0.9"})) }.to raise_error()
+    end
+
+    it "should validate auth type" do
+      expect { Innards::Connection.new(@valid_hash.merge({:auth_mode => "basic"})) }.not_to raise_error()
+      expect { Innards::Connection.new(@valid_hash.merge({:auth_mode => "digest"})) }.not_to raise_error()
+      expect { Innards::Connection.new(@valid_hash.merge({:auth_mode => "invalid"})) }.to raise_error()
+    end
+
+    it "doesn't accept a blank user agent" do
+      expect { Innards::Connection.new(@valid_hash.merge({:user_agent => ""})) }.to raise_error()
+    end
+  end
+
+  context "during connect" do
+    before do
+      Excon.defaults[:mock] = true
+      stub_path = File.expand_path("../../stubs", __FILE__)
+      Excon.stub({:method => :get}) do |params|
+        rets_version = "RETS/1.7.2"
+        rets_server = "StubRETS/0.0.1"
+        case params[:path]
+        when "/rets/login"
+          {:body => File.read("#{stub_path}/login_success.xml"), :headers => {
+            "RETS-Version" => rets_version,
+            "RETS-Server" => rets_server,
+            "WWW-Authenticate" => "Digest realm=\"testrealm@host.com\", qop=\"auth,auth-int\", nonce=\"dcd98b7102dd2f0e8b11d0f600bfb0c093\", opaque=\"5ccc069c403ebaf9f0171e9517f40e41\"",
+            "Set-Cookie" => "name2=value2; Expires=Wed, 09 Jun 2021 10:18:14 GMT"
+          }, :status => 200}
+        when "/rets/getMetadata"
+          {:body => File.read("#{stub_path}/metadata_success.xml"), :headers => {
+            "RETS-Version" => rets_version,
+            "RETS-Server" => rets_server,
+          }, :status => 200}
+        when "/rets/staleDigest"
+          {:body => "", :headers => {
+            "RETS-Version" => rets_version,
+            "RETS-Server" => rets_server,
+            "WWW-Authenticate" => "Digest realm=\"testrealm@host.com\", qop=\"auth,auth-int\", nonce=\"dcd98b7102dd2f0e8b11d0f600bfb0c093\", opaque=\"5ccc069c403ebaf9f0171e9517f40e41\" stale=true",
+          }, :status => 200}
+        when "/rets/retsError"
+          {:body => File.read("#{stub_path}/rets_error.xml"), :headers => {
+            "RETS-Version" => rets_version,
+            "RETS-Server" => rets_server,
+          }, :status => 200}
+        when "/rets/search"
+          {:body => File.read("#{stub_path}/search_success.xml"), :headers => {
+            "RETS-Version" => rets_version,
+            "RETS-Server" => rets_server,
+          }, :status => 200}
+        when "/rets/logout"
+          {:body => File.read("#{stub_path}/logout_success.xml"), :headers => {
+            "RETS-Version" => rets_version,
+            "RETS-Server" => rets_server,
+          }, :status => 200}
+        when "/rets/getObject"
+          {:body => File.read("#{stub_path}/getobject_success.txt"), :headers => {
+            "RETS-Version" => rets_version,
+            "RETS-Server" => rets_server,
+            "Cache-Control" => "private",
+            "MIME-Version" => "1.0",
+            "Content-Type" => "multipart/parallel; boundary=\"aa58ae639983623715598443ccfe159ccf009de8\"",
+            "Transfer-Encoding" => "chunked"
+          }, :status => 200}
+        end
+      end
+      @demo_rets = Innards::Connection.new(:login_url => "http://Joe:Schmoe@www.dis.com:6103/rets/login")
+    end
+
+    after do
+      Excon.stubs.clear
+    end
+
+    it "should throw an exception if get metadata called before login" do
+      expect { @demo_rets.get_metadata }.to raise_error
+      @demo_rets.login!.should be_true
+      expect { @demo_rets.get_metadata }.not_to raise_error
+    end
+
+    it "should login and logout of the demo RETS Server returning associated metadata" do
+      @demo_rets.login!.should be_true
+      @demo_rets.params[:metadata].should be_kind_of(Hash)
+      @demo_rets.params[:metadata].should_not be_empty
+      @demo_rets.params[:metadata][:MemberName].should match "Joe Schmoe"
+      @demo_rets.params[:metadata][:MetadataVersion].should match "1.00.00001"
+      @demo_rets.params[:metadata][:MinMetadataVersion].should match "1.00.00001"
+      @demo_rets.params[:metadata][:User].should match "Joe,NULL,NULL,NULL"
+      @demo_rets.params[:metadata][:Login].should match "/rets/login"
+      @demo_rets.params[:metadata][:Logout].should match "/rets/logout"
+      @demo_rets.params[:metadata][:Search].should match "/rets/search"
+      @demo_rets.params[:metadata][:GetMetadata].should match "/rets/getMetadata"
+      @demo_rets.params[:metadata][:GetObject].should match "/rets/getObject"
+      @demo_rets.params[:metadata][:Balance].should match "116,805.54"
+      @demo_rets.params[:metadata][:TimeoutSeconds].should match "1800"
+    end
+
+    it "should throw an error on a stale digest header" do
+      @demo_rets.login!.should be_true
+      @demo_rets.params[:metadata][:GetMetadata] = "/rets/staleDigest"
+      expect { @demo_rets.get_metadata }.to raise_error
+    end
+
+    it "should get the associated metadata for the server" do
+
+      @demo_rets.login!.should be_true
+      metadata = @demo_rets.get_metadata
+
+      metadata.should have_key(:resources)
+      metadata[:resources].should_not be_empty
+
+      metadata.should have_key(:classes)
+      metadata[:classes].should_not be_empty
+
+      metadata.should have_key(:tables)
+      metadata[:tables].should_not be_empty
+
+      metadata.should have_key(:objects)
+      metadata[:objects].should_not be_empty
+
+      metadata.should have_key(:search_help)
+      metadata[:search_help].should_not be_empty
+
+      metadata.should have_key(:edit_masks)
+      metadata[:edit_masks].should_not be_empty
+
+      metadata.should have_key(:lookups)
+      metadata[:lookups].should_not be_empty
+
+      metadata.should have_key(:lookup_types)
+      metadata[:lookup_types].should_not be_empty
+
+    end
+
+    it "should return false on get metadata error" do
+      @demo_rets.login!.should be_true
+      @demo_rets.params[:metadata][:GetMetadata] = "/rets/retsError"
+      @demo_rets.get_metadata.should be_false
+    end
+
+    it "should throw an error if logout called before login" do
+      expect { @demo_rets.logout! }.to raise_error
+    end
+
+    it "should correctly log out" do
+      @demo_rets.login!.should be_true
+      expect { @demo_rets.logout! }.not_to raise_error
+      @demo_rets.params[:metadata][:ConnectTime].should match "6"
+      @demo_rets.params[:metadata][:Billing].should match "0.04"
+      @demo_rets.params[:metadata][:SignOffMessage].should match "Goodbye"
+    end
+
+    it "should return false on logout error" do
+      @demo_rets.login!.should be_true
+      @demo_rets.params[:metadata][:Logout] = "/rets/retsError"
+      @demo_rets.logout!.should be_false
+    end
+
+    it "should perform a basic search" do
+      @demo_rets.login!.should be_true
+
+      expect {
+        @demo_rets.search()
+      }.to raise_error
+
+      expect {
+        @demo_rets.search(:SearchType => "Property",
+                          :Class => "",
+                          :Query => "(ListPrice=0+)")
+      }.to raise_error
+
+      expect {
+        @demo_rets.search(:SearchType => "Property",
+                          :Class => "RES",
+                          :Query => "")
+      }.to raise_error
+
+      expect {
+        @demo_rets.search(:SearchType => "Property",
+                          :Class => "RES",
+                          :Query => "(ListPrice=0+)")
+      }.not_to raise_error
+
+      results = @demo_rets.search(:SearchType => "Property",
+                                  :Class => "RES",
+                                  :Query => "(ListPrice=0+)")
+      results.should be_kind_of(Array)
+      results.each do |result|
+        result.should be_kind_of(Hash)
+      end
+    end
+
+    it "should return false on search error" do
+      @demo_rets.login!.should be_true
+      @demo_rets.params[:metadata][:Search] = "/rets/retsError"
+      @demo_rets.search(:SearchType => "Property",
+                        :Class => "RES",
+                        :Query => "(ListPrice=0+)").should be_false
+    end
+
+    it "should perform a GetObject request" do
+      @demo_rets.login!.should be_true
+
+      result = @demo_rets.get_object(:Type => "Photo",
+                                     :Resource => "Property",
+                                     :ID => "2:*")
+      result.should be_true
+
+    end
+
+  end
+
+end