entp-ruby-openid 2.2

data/test/test_xrds.rb

@@ -0,0 +1,167 @@
+require "test_helper"
+require 'openid/yadis/xrds'
+
+
+module OpenID
+  module Yadis
+
+    module XRDSTestMixin
+      include TestDataMixin
+
+      XRD_FILE = 'valid-populated-xrds.xml'
+      NOXRDS_FILE = 'not-xrds.xml'
+      NOXRD_FILE = 'no-xrd.xml'
+
+      XRDS_DATA_DIR = TEST_DATA_DIR.join('test_xrds')
+
+      def read_data_file(filename)
+        super(filename, false, XRDS_DATA_DIR)
+      end
+    end
+
+    class ParseXRDSTestCase < Test::Unit::TestCase
+      include XRDSTestMixin
+
+      # Check that parsing succeeds at all.
+      def test_parse
+        result = Yadis.parseXRDS(read_data_file(XRD_FILE))
+        assert_not_nil result
+      end
+
+      def test_parse_no_xrds_xml
+        xmldoc = read_data_file(NOXRDS_FILE)
+        assert_raise(Yadis::XRDSError) {
+          Yadis.parseXRDS(xmldoc)
+        }
+      end
+
+      def test_parse_no_xrds_empty
+        assert_raise(Yadis::XRDSError) {
+          Yadis.parseXRDS('')
+        }
+      end
+
+      def test_is_xrds
+        isnt = REXML::Document.new(read_data_file(NOXRDS_FILE))
+        should_be = Yadis.parseXRDS(read_data_file(XRD_FILE))
+        assert_equal false, Yadis::is_xrds?(isnt)
+        assert Yadis::is_xrds?(should_be)
+      end
+    end
+
+    class GetYadisXRDTestCase < Test::Unit::TestCase
+      include XRDSTestMixin
+
+      # XXX: Test to make sure this really gets the _right_ XRD.
+      def test_get_xrd
+        doc = Yadis.parseXRDS(read_data_file(XRD_FILE))
+        result = Yadis::get_yadis_xrd(doc)
+        assert_not_nil result
+        assert_equal 'XRD', result.name
+        assert_equal Yadis::XRD_NS_2_0, result.namespace
+      end
+
+      def test_no_xrd
+        xmldoc = read_data_file(NOXRD_FILE)
+        doc = Yadis.parseXRDS(xmldoc)
+        assert_raise(Yadis::XRDSError) {
+          Yadis.get_yadis_xrd(doc)
+        }
+      end
+    end
+
+    class EachServiceTestCase < Test::Unit::TestCase
+      include XRDSTestMixin
+
+      def test_get_xrd
+        doc = Yadis.parseXRDS(read_data_file(XRD_FILE))
+        count = 0
+        result = Yadis::each_service(doc) { |e|
+          assert_equal 'Service', e.name
+          count += 1
+        }
+        assert_not_nil result
+        assert_equal 5, count
+      end
+
+      def test_no_xrd
+        xmldoc = read_data_file(NOXRD_FILE)
+        doc = Yadis.parseXRDS(xmldoc)
+        assert_raise(Yadis::XRDSError) {
+          Yadis.each_service(doc)
+        }
+      end
+
+      def test_equal_j3h
+        doc = Yadis.parseXRDS(read_data_file('=j3h.2007.11.14.xrds'))
+        count = 0
+        result = Yadis::each_service(doc) { |e|
+          assert_equal 'Service', e.name
+          count += 1
+        }
+        assert_not_nil result
+        assert_equal 2, count
+      end
+    end
+
+    # XXX: test prioSort!
+
+    class ExpandServiceTestCase < Test::Unit::TestCase
+      @@service_xml = <<END
+<Service>
+<Type>urn://foo</Type>
+<Type>urn://bar</Type>
+<URI priority='2'>http://2.invalid/</URI>
+<URI>http://0.invalid/</URI>
+<URI priority='1'>http://1.invalid/</URI>
+</Service>
+END
+
+      # XXX - not sorted!
+      def test_expand_service
+        service_element = REXML::Document.new(@@service_xml).root
+        result = Yadis::expand_service(service_element)
+        assert_equal 3, result.length
+        types, uri, result_element = result[0]
+        assert_same service_element, result_element
+        assert_equal 'http://0.invalid/', uri
+        assert_equal ['urn://foo', 'urn://bar'], types
+        types, uri, result_element = result[1]
+        assert_equal 'http://1.invalid/', uri
+        types, uri, result_element = result[2]
+        assert_equal 'http://2.invalid/', uri
+      end
+    end
+
+    class PrioSortTestCase < Test::Unit::TestCase
+      def new_uri(priority)
+        e = REXML::Element.new("URI")
+        e.add_attribute("priority", priority.to_s) unless e.nil?
+        return e
+      end
+
+      def test_sorting
+        l = [
+             e7 = new_uri(7),
+             e1 = new_uri(1),
+             e0 = new_uri(nil),
+             e2 = new_uri(2),
+            ]
+        sorted = Yadis::prio_sort(l)
+        assert_same e0, sorted[0]
+        assert_same e1, sorted[1]
+        assert_same e2, sorted[2]
+        assert_same e7, sorted[3]
+      end
+    end
+
+    class GetCanonicalIDTestCase < Test::Unit::TestCase
+      include XRDSTestMixin
+
+      def test_multisegment_xri
+        xmldoc = Yadis.parseXRDS(read_data_file('subsegments.xrds'))
+        result = Yadis.get_canonical_id('xri://=nishitani*masaki', xmldoc)
+      end
+    end
+  end
+end

data/test/test_xri.rb

@@ -0,0 +1,48 @@
+require "test_helper"
+require 'openid/yadis/xri'
+
+module OpenID
+
+  module Yadis
+
+    class XriDiscoveryTestCase < Test::Unit::TestCase
+
+      def test_isXRI?
+        assert_equal(:xri, XRI.identifier_scheme('=john.smith'))
+        assert_equal(:xri, XRI.identifier_scheme('@smiths/john'))
+        assert_equal(:xri, XRI.identifier_scheme('xri://=john'))
+        assert_equal(:xri, XRI.identifier_scheme('@ootao*test1'))
+        assert_equal(:uri, XRI.identifier_scheme('smoker.myopenid.com'))
+        assert_equal(:uri, XRI.identifier_scheme('http://smoker.myopenid.com'))
+        assert_equal(:uri, XRI.identifier_scheme('https://smoker.myopenid.com'))
+      end
+    end
+
+    class XriEscapingTestCase < Test::Unit::TestCase
+      def test_escaping_percents
+        assert_equal('@example/abc%252Fd/ef', 
+                     XRI.escape_for_iri('@example/abc%2Fd/ef'))
+      end
+
+      def test_escaping_xref
+        # no escapes
+        assert_equal('@example/foo/(@bar)',
+                     XRI.escape_for_iri('@example/foo/(@bar)'))
+        # escape slashes
+        assert_equal('@example/foo/(@bar%2Fbaz)',
+                     XRI.escape_for_iri('@example/foo/(@bar/baz)'))
+        # escape query ? and fragment #
+        assert_equal('@example/foo/(@baz%3Fp=q%23r)?i=j#k',
+                     XRI.escape_for_iri('@example/foo/(@baz?p=q#r)?i=j#k'))
+      end
+    end
+
+    class XriTransformationTestCase < Test::Unit::TestCase
+      def test_to_iri_normal
+        assert_equal('xri://@example', XRI.to_iri_normal('@example'))
+      end
+      # iri_to_url:
+      #   various ucschar to hex
+    end
+  end
+end

data/test/test_xrires.rb

@@ -0,0 +1,67 @@
+require "test_helper"
+require 'openid/yadis/xrires'
+
+module OpenID
+  module Yadis
+
+    class XRDSFetcher
+      def initialize(results)
+        @results = results
+      end
+
+      def fetch(url, body=nil, headers=nil, redirect_limit=nil)
+        if !@results.empty?
+          return @results.shift
+        end
+
+        nil
+      end
+    end
+
+    class ProxyQueryTestCase < Test::Unit::TestCase
+      def setup
+        @proxy_url = 'http://xri.example.com/'
+        @proxy = XRI::ProxyResolver.new(@proxy_url)
+        @servicetype = 'xri://+i-service*(+forwarding)*($v*1.0)'
+        @servicetype_enc = 'xri%3A%2F%2F%2Bi-service%2A%28%2Bforwarding%29%2A%28%24v%2A1.0%29'
+      end
+
+      def unesc(s)
+        CGI::unescape(s)
+      end
+
+      def test_proxy_url
+        st = @servicetype
+        ste = @servicetype_enc
+        args_esc = "_xrd_r=application%2Fxrds%2Bxml&_xrd_t=" + ste
+        pqu = @proxy.method('query_url')
+        h = @proxy_url
+
+        assert_equal(unesc(h + '=foo?' + args_esc), unesc(pqu.call('=foo', st)))
+        assert_equal(unesc(h + '=foo/bar?baz&' + args_esc),
+                     unesc(pqu.call('=foo/bar?baz', st)))
+        assert_equal(unesc(h + '=foo/bar?baz=quux&' + args_esc),
+                     unesc(pqu.call('=foo/bar?baz=quux', st)))
+        assert_equal(unesc(h + '=foo/bar?mi=fa&so=la&' + args_esc),
+                     unesc(pqu.call('=foo/bar?mi=fa&so=la', st)))
+
+        # With no service endpoint selection.
+        args_esc = "_xrd_r=application%2Fxrds%2Bxml"
+        assert_equal(unesc(h + '=foo?' + args_esc), unesc(pqu.call('=foo', nil)))
+      end
+
+      def test_proxy_url_qmarks
+        st = @servicetype
+        ste = @servicetype_enc
+        args_esc = "_xrd_r=application%2Fxrds%2Bxml&_xrd_t=" + ste
+        pqu = @proxy.method('query_url')
+        h = @proxy_url
+
+        assert_equal(unesc(h + '=foo/bar?' + args_esc),
+                     unesc(pqu.call('=foo/bar??', st)))
+        assert_equal(unesc(h + '=foo/bar?' + args_esc),
+                     unesc(pqu.call('=foo/bar???', st)))
+      end
+    end
+  end
+end

data/test/test_yadis_discovery.rb

@@ -0,0 +1,218 @@
+require "test_helper"
+require 'uri'
+
+require 'openid/yadis/discovery'
+require 'openid/fetchers'
+require 'openid/util'
+require 'support/yadis_data'
+
+module OpenID
+
+  module YadisDiscovery
+    include FetcherMixin
+    include YadisData
+
+    STATUS_HEADER_RE = /Status: (\d+) .*?$/m
+
+    four04_pat = "\nContent-Type: text/plain\n\nNo such file %s"
+
+    def self.mkResponse(data)
+      status_mo = data.scan(STATUS_HEADER_RE)
+      headers_str, body = data.split("\n\n", 2)
+      headers = {}
+      headers_str.split("\n", -1).each { |line|
+        k, v = line.split(':', 2)
+        k = k.strip().downcase
+        v = v.strip()
+        headers[k] = v
+      }
+      status = status_mo[0][0].to_i
+      return HTTPResponse._from_raw_data(status, body,
+                                         headers)
+    end
+
+    class TestFetcher
+      include YadisData
+
+      def initialize(base_url)
+        @base_url = base_url
+      end
+
+      def fetch(url, headers, body, redirect_limit=nil)
+        current_url = url
+        while true
+          parsed = URI::parse(current_url)
+          # parsed[2][1:]
+          path = parsed.path[1..-1]
+          begin
+            data = generateSample(path, @base_url)
+          rescue ArgumentError
+            return HTTPResponse._from_raw_data(404, '', {},
+                                               current_url)
+          end
+
+          response = YadisDiscovery.mkResponse(data)
+          if ["301", "302", "303", "307"].member?(response.code)
+            current_url = response['location']
+          else
+            response.final_url = current_url
+            return response
+          end
+        end
+      end
+    end
+
+    class MockFetcher
+      def initialize
+        @count = 0
+      end
+
+      def fetch(uri, headers=nil, body=nil, redirect_limit=nil)
+        @count += 1
+        if @count == 1
+          headers = {
+            'X-XRDS-Location'.downcase => 'http://unittest/404',
+          }
+          return HTTPResponse._from_raw_data(200, '', headers, uri)
+        else
+          return HTTPResponse._from_raw_data(404, '', {}, uri)
+        end
+      end
+    end
+
+    class TestSecondGet < Test::Unit::TestCase
+      include FetcherMixin
+
+      def test_404
+        uri = "http://something.unittest/"
+        assert_raise(DiscoveryFailure) {
+          with_fetcher(MockFetcher.new) { Yadis.discover(uri) }
+        }
+      end
+    end
+
+    class DiscoveryTestCase
+      include YadisData
+      include FetcherMixin
+
+      def initialize(testcase, input_name, id_name, result_name, success)
+        @base_url = 'http://invalid.unittest/'
+        @testcase = testcase
+        @input_name = input_name
+        @id_name = id_name
+        @result_name = result_name
+        @success = success
+      end
+
+      def setup
+        @input_url, @expected = generateResult(@base_url,
+                                               @input_name,
+                                               @id_name,
+                                               @result_name,
+                                               @success)
+      end
+
+      def do_discovery
+        with_fetcher(TestFetcher.new(@base_url)) do
+          Yadis.discover(@input_url)
+        end
+      end
+
+      def runCustomTest
+        setup
+
+        if @expected.respond_to?("ancestors") and @expected.ancestors.member?(DiscoveryFailure)
+          @testcase.assert_raise(DiscoveryFailure) {
+            do_discovery
+          }
+        else
+          result = do_discovery
+          @testcase.assert_equal(@input_url, result.request_uri)
+
+          msg = sprintf("Identity URL mismatch: actual = %s, expected = %s",
+                        result.normalized_uri, @expected.normalized_uri)
+          @testcase.assert_equal(@expected.normalized_uri, result.normalized_uri, msg)
+
+          msg = sprintf("Content mismatch: actual = %s, expected = %s",
+                        result.response_text, @expected.response_text)
+          @testcase.assert_equal(@expected.response_text, result.response_text, msg)
+
+          expected_keys = @expected.instance_variables
+          expected_keys.sort!
+
+          actual_keys = result.instance_variables
+          actual_keys.sort!
+
+          @testcase.assert_equal(actual_keys, expected_keys)
+
+          @expected.instance_variables.each { |k|
+            exp_v = @expected.instance_variable_get(k)
+            act_v = result.instance_variable_get(k)
+            @testcase.assert_equal(act_v, exp_v, [k, exp_v, act_v])
+          }
+        end
+      end
+    end
+
+    class NoContentTypeFetcher
+      def fetch(url, body=nil, headers=nil, redirect_limit=nil)
+        return OpenID::HTTPResponse._from_raw_data(200, "", {}, nil)
+      end
+    end
+
+    class BlankContentTypeFetcher
+      def fetch(url, body=nil, headers=nil, redirect_limit=nil)
+        return OpenID::HTTPResponse._from_raw_data(200, "", {"Content-Type" => ""}, nil)
+      end
+    end
+
+    class TestYadisDiscovery < Test::Unit::TestCase
+      include FetcherMixin
+
+      def test_yadis_discovery
+        YadisData::TESTLIST.each { |success, input_name, id_name, result_name|
+          test = DiscoveryTestCase.new(self, input_name, id_name, result_name, success)
+          test.runCustomTest
+        }
+      end
+
+      def test_is_xrds_yadis_location
+        result = Yadis::DiscoveryResult.new('http://request.uri/')
+        result.normalized_uri = "http://normalized/"
+        result.xrds_uri = "http://normalized/xrds"
+
+        assert(result.is_xrds)
+      end
+
+      def test_is_xrds_content_type
+        result = Yadis::DiscoveryResult.new('http://request.uri/')
+        result.normalized_uri = result.xrds_uri = "http://normalized/"
+        result.content_type = Yadis::YADIS_CONTENT_TYPE
+
+        assert(result.is_xrds)
+      end
+
+      def test_is_xrds_neither
+        result = Yadis::DiscoveryResult.new('http://request.uri/')
+        result.normalized_uri = result.xrds_uri = "http://normalized/"
+        result.content_type = "another/content-type"
+
+        assert(!result.is_xrds)
+      end
+
+      def test_no_content_type
+        with_fetcher(NoContentTypeFetcher.new) do
+          result = Yadis.discover("http://bogus")
+          assert_equal(nil, result.content_type)
+        end
+      end
+
+      def test_blank_content_type
+        with_fetcher(BlankContentTypeFetcher.new) do
+          result = Yadis.discover("http://bogus")
+          assert_equal("", result.content_type)
+        end
+      end
+    end
+  end
+end