diff options
Diffstat (limited to 'vendor/gems/ruby-openid-2.1.4/test/test_discover.rb')
| -rw-r--r-- | vendor/gems/ruby-openid-2.1.4/test/test_discover.rb | 838 |
1 files changed, 0 insertions, 838 deletions
diff --git a/vendor/gems/ruby-openid-2.1.4/test/test_discover.rb b/vendor/gems/ruby-openid-2.1.4/test/test_discover.rb deleted file mode 100644 index 13b115ce1..000000000 --- a/vendor/gems/ruby-openid-2.1.4/test/test_discover.rb +++ /dev/null @@ -1,838 +0,0 @@ - -require 'testutil' -require 'util' - -require 'test/unit' -require 'openid/fetchers' -require 'openid/yadis/discovery' -require 'openid/consumer/discovery' -require 'openid/yadis/xrires' -require 'openid/yadis/xri' -require 'openid/message' -require 'openid/util' - -### Tests for conditions that trigger DiscoveryFailure - -module OpenID - class SimpleMockFetcher - def initialize(test, responses) - @test = test - @responses = responses.dup - end - - def fetch(url, body=nil, headers=nil, limit=nil) - response = @responses.shift - @test.assert(body.nil?) - @test.assert_equal(response.final_url, url) - return response - end - end - - class TestDiscoveryFailure < Test::Unit::TestCase - def initialize(*args) - super(*args) - - @responses = [ - [HTTPResponse._from_raw_data(nil, nil, {}, 'http://network.error/')], - [HTTPResponse._from_raw_data(404, nil, {}, 'http://not.found/')], - [HTTPResponse._from_raw_data(400, nil, {}, 'http://bad.request/')], - [HTTPResponse._from_raw_data(500, nil, {}, 'http://server.error/')], - [HTTPResponse._from_raw_data(200, nil, {'x-xrds-location' => 'http://xrds.missing/'}, - 'http://header.found/'), - HTTPResponse._from_raw_data(404, nil, {}, 'http://xrds.missing/')], - ] - end - - def test_discovery_failure - - @responses.each { |response_set| - @url = response_set[0].final_url - OpenID.fetcher = SimpleMockFetcher.new(self, response_set) - - expected_status = response_set[-1].code - begin - OpenID.discover(@url) - rescue DiscoveryFailure => why - assert_equal(why.http_response.code, expected_status) - else - flunk('Did not raise DiscoveryFailure') - end - - OpenID.fetcher = nil - } - end - end - - ### Tests for raising/catching exceptions from the fetcher through - ### the discover function - - class ErrorRaisingFetcher - # Just raise an exception when fetch is called - - def initialize(thing_to_raise) - @thing_to_raise = thing_to_raise - end - - def fetch(url, body=nil, headers=nil, limit=nil) - raise @thing_to_raise - end - end - - class DidFetch < Exception - # Custom exception just to make sure it's not handled differently - end - - class TestFetchException < Test::Unit::TestCase - # Discovery should only raise DiscoveryFailure - - def initialize(*args) - super(*args) - - @cases = [ - DidFetch.new(), - Exception.new(), - ArgumentError.new(), - RuntimeError.new(), - ] - end - - def test_fetch_exception - @cases.each { |exc| - OpenID.fetcher = ErrorRaisingFetcher.new(exc) - assert_raises(DiscoveryFailure) { - OpenID.discover('http://doesnt.matter/') - } - OpenID.fetcher = nil - } - end - end - - ### Tests for openid.consumer.discover.discover - - class TestNormalization < Test::Unit::TestCase - def test_addingProtocol - f = ErrorRaisingFetcher.new(RuntimeError.new()) - OpenID.fetcher = f - - begin - OpenID.discover('users.stompy.janrain.com:8000/x') - rescue DiscoveryFailure => why - assert why.to_s.match("Failed to fetch") - rescue RuntimeError - end - - OpenID.fetcher = nil - end - end - - class DiscoveryMockFetcher - def initialize(documents) - @redirect = nil - @documents = documents - @fetchlog = [] - end - - def fetch(url, body=nil, headers=nil, limit=nil) - @fetchlog << [url, body, headers] - if @redirect - final_url = @redirect - else - final_url = url - end - - begin - ctype, body = @documents.fetch(url) - rescue IndexError - status = 404 - ctype = 'text/plain' - body = '' - else - status = 200 - end - - return HTTPResponse._from_raw_data(status, body, {'content-type' => ctype}, final_url) - end - end - - class BaseTestDiscovery < Test::Unit::TestCase - attr_accessor :id_url, :fetcher_class - - def initialize(*args) - super(*args) - @id_url = "http://someuser.unittest/" - @documents = {} - @fetcher_class = DiscoveryMockFetcher - end - - def _checkService(s, server_url, claimed_id=nil, - local_id=nil, canonical_id=nil, - types=nil, used_yadis=false, - display_identifier=nil) - assert_equal(server_url, s.server_url) - if types == ['2.0 OP'] - assert(!claimed_id) - assert(!local_id) - assert(!s.claimed_id) - assert(!s.local_id) - assert(!s.get_local_id()) - assert(!s.compatibility_mode()) - assert(s.is_op_identifier()) - assert_equal(s.preferred_namespace(), - OPENID_2_0_MESSAGE_NS) - else - assert_equal(claimed_id, s.claimed_id) - assert_equal(local_id, s.get_local_id()) - end - - if used_yadis - assert(s.used_yadis, "Expected to use Yadis") - else - assert(!s.used_yadis, - "Expected to use old-style discovery") - end - - openid_types = { - '1.1' => OPENID_1_1_TYPE, - '1.0' => OPENID_1_0_TYPE, - '2.0' => OPENID_2_0_TYPE, - '2.0 OP' => OPENID_IDP_2_0_TYPE, - } - - type_uris = types.collect { |t| openid_types[t] } - - assert_equal(type_uris, s.type_uris) - assert_equal(canonical_id, s.canonical_id) - - if canonical_id.nil? - assert_equal(claimed_id, s.display_identifier) - else - assert_equal(display_identifier, s.display_identifier) - end - end - - def setup - # @documents = @documents.dup - @fetcher = @fetcher_class.new(@documents) - OpenID.fetcher = @fetcher - end - - def teardown - OpenID.fetcher = nil - end - - def test_blank - # XXX to avoid > 0 test requirement - end - end - -# def readDataFile(filename): -# module_directory = os.path.dirname(os.path.abspath(__file__)) -# filename = os.path.join( -# module_directory, 'data', 'test_discover', filename) -# return file(filename).read() - - class TestDiscovery < BaseTestDiscovery - include TestDataMixin - - def _discover(content_type, data, - expected_services, expected_id=nil) - if expected_id.nil? - expected_id = @id_url - end - - @documents[@id_url] = [content_type, data] - id_url, services = OpenID.discover(@id_url) - - assert_equal(expected_services, services.length) - assert_equal(expected_id, id_url) - return services - end - - def test_404 - assert_raise(DiscoveryFailure) { - OpenID.discover(@id_url + '/404') - } - end - - def test_noOpenID - services = _discover('text/plain', - "junk", 0) - - services = _discover( - 'text/html', - read_data_file('test_discover/openid_no_delegate.html', false), - 1) - - _checkService( - services[0], - "http://www.myopenid.com/server", - @id_url, - @id_url, - nil, - ['1.1'], - false) - end - - def test_malformed_meta_tag - @id_url = "http://user.myopenid.com/" - - services = _discover( - 'text/html', - read_data_file('test_discover/malformed_meta_tag.html', false), - 2) - - _checkService( - services[0], - "http://www.myopenid.com/server", - @id_url, - @id_url, - nil, - ['2.0'], - false) - - _checkService( - services[1], - "http://www.myopenid.com/server", - @id_url, - @id_url, - nil, - ['1.1'], - false) - end - - def test_html1 - services = _discover('text/html', - read_data_file('test_discover/openid.html', false), - 1) - - _checkService(services[0], - "http://www.myopenid.com/server", - @id_url, - 'http://smoker.myopenid.com/', - nil, - ['1.1'], - false) - end - - def test_html1Fragment - # Ensure that the Claimed Identifier does not have a fragment if - # one is supplied in the User Input. - content_type = 'text/html' - data = read_data_file('test_discover/openid.html', false) - expected_services = 1 - - @documents[@id_url] = [content_type, data] - expected_id = @id_url - @id_url = @id_url + '#fragment' - id_url, services = OpenID.discover(@id_url) - - assert_equal(expected_services, services.length) - assert_equal(expected_id, id_url) - - _checkService(services[0], - "http://www.myopenid.com/server", - expected_id, - 'http://smoker.myopenid.com/', - nil, - ['1.1'], - false) - end - - def test_html2 - services = _discover('text/html', - read_data_file('test_discover/openid2.html', false), - 1) - - _checkService(services[0], - "http://www.myopenid.com/server", - @id_url, - 'http://smoker.myopenid.com/', - nil, - ['2.0'], - false) - end - - def test_html1And2 - services = _discover( - 'text/html', - read_data_file('test_discover/openid_1_and_2.html', false), - 2) - - services.zip(['2.0', '1.1']).each { |s, t| - _checkService(s, - "http://www.myopenid.com/server", - @id_url, - 'http://smoker.myopenid.com/', - nil, - [t], - false) - } - end - - def test_yadisEmpty - services = _discover('application/xrds+xml', - read_data_file('test_discover/yadis_0entries.xml', false), - 0) - end - - def test_htmlEmptyYadis - # HTML document has discovery information, but points to an - # empty Yadis document. The XRDS document pointed to by - # "openid_and_yadis.html" - @documents[@id_url + 'xrds'] = ['application/xrds+xml', - read_data_file('test_discover/yadis_0entries.xml', false)] - - services = _discover('text/html', - read_data_file('test_discover/openid_and_yadis.html', false), - 1) - - _checkService(services[0], - "http://www.myopenid.com/server", - @id_url, - 'http://smoker.myopenid.com/', - nil, - ['1.1'], - false) - end - - def test_yadis1NoDelegate - services = _discover('application/xrds+xml', - read_data_file('test_discover/yadis_no_delegate.xml', false), - 1) - - _checkService(services[0], - "http://www.myopenid.com/server", - @id_url, - @id_url, - nil, - ['1.0'], - true) - end - - def test_yadis2NoLocalID - services = _discover('application/xrds+xml', - read_data_file('test_discover/openid2_xrds_no_local_id.xml', false), - 1) - - _checkService(services[0], - "http://www.myopenid.com/server", - @id_url, - @id_url, - nil, - ['2.0'], - true) - end - - def test_yadis2 - services = _discover('application/xrds+xml', - read_data_file('test_discover/openid2_xrds.xml', false), - 1) - - _checkService(services[0], - "http://www.myopenid.com/server", - @id_url, - 'http://smoker.myopenid.com/', - nil, - ['2.0'], - true) - end - - def test_yadis2OP - services = _discover('application/xrds+xml', - read_data_file('test_discover/yadis_idp.xml', false), - 1) - - _checkService(services[0], - "http://www.myopenid.com/server", - nil, nil, nil, - ['2.0 OP'], - true) - end - - def test_yadis2OPDelegate - # The delegate tag isn't meaningful for OP entries. - services = _discover('application/xrds+xml', - read_data_file('test_discover/yadis_idp_delegate.xml', false), - 1) - - _checkService(services[0], - "http://www.myopenid.com/server", - nil, nil, nil, - ['2.0 OP'], - true) - end - - def test_yadis2BadLocalID - assert_raise(DiscoveryFailure) { - _discover('application/xrds+xml', - read_data_file('test_discover/yadis_2_bad_local_id.xml', false), - 1) - } - end - - def test_yadis1And2 - services = _discover('application/xrds+xml', - read_data_file('test_discover/openid_1_and_2_xrds.xml', false), - 1) - - _checkService(services[0], - "http://www.myopenid.com/server", - @id_url, - 'http://smoker.myopenid.com/', - nil, - ['2.0', '1.1'], - true) - end - - def test_yadis1And2BadLocalID - assert_raise(DiscoveryFailure) { - _discover('application/xrds+xml', - read_data_file('test_discover/openid_1_and_2_xrds_bad_delegate.xml', false), - 1) - } - end - end - - class MockFetcherForXRIProxy - - def initialize(documents, proxy_url=Yadis::XRI::ProxyResolver::DEFAULT_PROXY) - @documents = documents - @fetchlog = [] - @proxy_url = nil - end - - def fetch(url, body=nil, headers=nil, limit=nil) - @fetchlog << [url, body, headers] - - u = URI::parse(url) - proxy_host = u.host - xri = u.path - query = u.query - - if !headers and !query - raise ArgumentError.new("No headers or query; you probably didn't " + - "mean to do that.") - end - - if xri.starts_with?('/') - xri = xri[1..-1] - end - - begin - ctype, body = @documents.fetch(xri) - rescue IndexError - status = 404 - ctype = 'text/plain' - body = '' - else - status = 200 - end - - return HTTPResponse._from_raw_data(status, body, - {'content-type' => ctype}, url) - end - end - - class TestXRIDiscovery < BaseTestDiscovery - - include TestDataMixin - include TestUtil - - def initialize(*args) - super(*args) - - @fetcher_class = MockFetcherForXRIProxy - - @documents = {'=smoker' => ['application/xrds+xml', - read_data_file('test_discover/yadis_2entries_delegate.xml', false)], - '=smoker*bad' => ['application/xrds+xml', - read_data_file('test_discover/yadis_another_delegate.xml', false)]} - end - - def test_xri - user_xri, services = OpenID.discover_xri('=smoker') - - _checkService(services[0], - "http://www.myopenid.com/server", - Yadis::XRI.make_xri("=!1000"), - 'http://smoker.myopenid.com/', - Yadis::XRI.make_xri("=!1000"), - ['1.0'], - true, - '=smoker') - - _checkService(services[1], - "http://www.livejournal.com/openid/server.bml", - Yadis::XRI.make_xri("=!1000"), - 'http://frank.livejournal.com/', - Yadis::XRI.make_xri("=!1000"), - ['1.0'], - true, - '=smoker') - end - - def test_xri_normalize - user_xri, services = OpenID.discover_xri('xri://=smoker') - - _checkService(services[0], - "http://www.myopenid.com/server", - Yadis::XRI.make_xri("=!1000"), - 'http://smoker.myopenid.com/', - Yadis::XRI.make_xri("=!1000"), - ['1.0'], - true, - '=smoker') - - _checkService(services[1], - "http://www.livejournal.com/openid/server.bml", - Yadis::XRI.make_xri("=!1000"), - 'http://frank.livejournal.com/', - Yadis::XRI.make_xri("=!1000"), - ['1.0'], - true, - '=smoker') - end - - def test_xriNoCanonicalID - silence_logging { - user_xri, services = OpenID.discover_xri('=smoker*bad') - assert(services.empty?) - } - end - - def test_useCanonicalID - # When there is no delegate, the CanonicalID should be used with - # XRI. - endpoint = OpenIDServiceEndpoint.new() - endpoint.claimed_id = Yadis::XRI.make_xri("=!1000") - endpoint.canonical_id = Yadis::XRI.make_xri("=!1000") - assert_equal(endpoint.get_local_id, Yadis::XRI.make_xri("=!1000")) - end - end - - class TestXRIDiscoveryIDP < BaseTestDiscovery - include TestDataMixin - - def initialize(*args) - super(*args) - - @fetcher_class = MockFetcherForXRIProxy - - @documents = {'=smoker' => ['application/xrds+xml', - read_data_file('test_discover/yadis_2entries_idp.xml', false)] } - end - - def test_xri - user_xri, services = OpenID.discover_xri('=smoker') - assert(!services.empty?, "Expected services, got zero") - assert_equal(services[0].server_url, - "http://www.livejournal.com/openid/server.bml") - end - end - - class TestPreferredNamespace < Test::Unit::TestCase - def initialize(*args) - super(*args) - - @cases = [ - [OPENID1_NS, []], - [OPENID1_NS, ['http://jyte.com/']], - [OPENID1_NS, [OPENID_1_0_TYPE]], - [OPENID1_NS, [OPENID_1_1_TYPE]], - [OPENID2_NS, [OPENID_2_0_TYPE]], - [OPENID2_NS, [OPENID_IDP_2_0_TYPE]], - [OPENID2_NS, [OPENID_2_0_TYPE, - OPENID_1_0_TYPE]], - [OPENID2_NS, [OPENID_1_0_TYPE, - OPENID_2_0_TYPE]], - ] - end - - def test_preferred_namespace - - @cases.each { |expected_ns, type_uris| - endpoint = OpenIDServiceEndpoint.new() - endpoint.type_uris = type_uris - actual_ns = endpoint.preferred_namespace() - assert_equal(actual_ns, expected_ns) - } - end - end - - class TestIsOPIdentifier < Test::Unit::TestCase - def setup - @endpoint = OpenIDServiceEndpoint.new() - end - - def test_none - assert(!@endpoint.is_op_identifier()) - end - - def test_openid1_0 - @endpoint.type_uris = [OPENID_1_0_TYPE] - assert(!@endpoint.is_op_identifier()) - end - - def test_openid1_1 - @endpoint.type_uris = [OPENID_1_1_TYPE] - assert(!@endpoint.is_op_identifier()) - end - - def test_openid2 - @endpoint.type_uris = [OPENID_2_0_TYPE] - assert(!@endpoint.is_op_identifier()) - end - - def test_openid2OP - @endpoint.type_uris = [OPENID_IDP_2_0_TYPE] - assert(@endpoint.is_op_identifier()) - end - - def test_multipleMissing - @endpoint.type_uris = [OPENID_2_0_TYPE, - OPENID_1_0_TYPE] - assert(!@endpoint.is_op_identifier()) - end - - def test_multiplePresent - @endpoint.type_uris = [OPENID_2_0_TYPE, - OPENID_1_0_TYPE, - OPENID_IDP_2_0_TYPE] - assert(@endpoint.is_op_identifier()) - end - end - - class TestFromOPEndpointURL < Test::Unit::TestCase - def setup - @op_endpoint_url = 'http://example.com/op/endpoint' - @endpoint = OpenIDServiceEndpoint.from_op_endpoint_url(@op_endpoint_url) - end - - def test_isOPEndpoint - assert(@endpoint.is_op_identifier()) - end - - def test_noIdentifiers - assert_equal(@endpoint.get_local_id, nil) - assert_equal(@endpoint.claimed_id, nil) - end - - def test_compatibility - assert(!@endpoint.compatibility_mode()) - end - - def test_canonical_id - assert_equal(@endpoint.canonical_id, nil) - end - - def test_serverURL - assert_equal(@endpoint.server_url, @op_endpoint_url) - end - end - - class TestDiscoverFunction < Test::Unit::TestCase - def test_discover_function - # XXX these were all different tests in python, but they're - # combined here so I only have to use with_method_overridden - # once. - discoverXRI = Proc.new { |identifier| - return 'XRI' - } - - discoverURI = Proc.new { |identifier| - return 'URI' - } - - OpenID.extend(OverrideMethodMixin) - - OpenID.with_method_overridden(:discover_uri, discoverURI) do - OpenID.with_method_overridden(:discover_xri, discoverXRI) do - assert_equal('URI', OpenID.discover('http://woo!')) - assert_equal('URI', OpenID.discover('not a URL or XRI')) - assert_equal('XRI', OpenID.discover('xri://=something')) - assert_equal('XRI', OpenID.discover('=something')) - end - end - end - end - - class TestEndpointSupportsType < Test::Unit::TestCase - def setup - @endpoint = OpenIDServiceEndpoint.new() - end - - def failUnlessSupportsOnly(*types) - ['foo', - OPENID_1_1_TYPE, - OPENID_1_0_TYPE, - OPENID_2_0_TYPE, - OPENID_IDP_2_0_TYPE].each { |t| - if types.member?(t) - assert(@endpoint.supports_type(t), - sprintf("Must support %s", t)) - else - assert(!@endpoint.supports_type(t), - sprintf("Shouldn't support %s", t)) - end - } - end - - def test_supportsNothing - failUnlessSupportsOnly() - end - - def test_openid2 - @endpoint.type_uris = [OPENID_2_0_TYPE] - failUnlessSupportsOnly(OPENID_2_0_TYPE) - end - - def test_openid2provider - @endpoint.type_uris = [OPENID_IDP_2_0_TYPE] - failUnlessSupportsOnly(OPENID_IDP_2_0_TYPE, - OPENID_2_0_TYPE) - end - - def test_openid1_0 - @endpoint.type_uris = [OPENID_1_0_TYPE] - failUnlessSupportsOnly(OPENID_1_0_TYPE) - end - - def test_openid1_1 - @endpoint.type_uris = [OPENID_1_1_TYPE] - failUnlessSupportsOnly(OPENID_1_1_TYPE) - end - - def test_multiple - @endpoint.type_uris = [OPENID_1_1_TYPE, - OPENID_2_0_TYPE] - failUnlessSupportsOnly(OPENID_1_1_TYPE, - OPENID_2_0_TYPE) - end - - def test_multipleWithProvider - @endpoint.type_uris = [OPENID_1_1_TYPE, - OPENID_2_0_TYPE, - OPENID_IDP_2_0_TYPE] - failUnlessSupportsOnly(OPENID_1_1_TYPE, - OPENID_2_0_TYPE, - OPENID_IDP_2_0_TYPE) - end - end - - class TestEndpointDisplayIdentifier < Test::Unit::TestCase - def test_strip_fragment - @endpoint = OpenIDServiceEndpoint.new() - @endpoint.claimed_id = 'http://recycled.invalid/#123' - assert_equal 'http://recycled.invalid/', @endpoint.display_identifier - end - end - - - class TestNormalizeURL < Test::Unit::TestCase - def test_no_host - assert_raise(DiscoveryFailure) { - OpenID::normalize_url('http:///too-many.invalid/slashes') - } - end - end -end |