ruby-openid 1.1.4 → 2.0.1

data/test/service.rb

@@ -1,47 +0,0 @@
-require 'test/unit'
-require "openid/service"
-
-class FakeYadis
-  
-  def uri
-    return ''
-  end
-  
-  def xrds_uri
-    ''
-  end
-
-end
-
-class OpenIDServiceEndpointTestCase < Test::Unit::TestCase
-
-  def test_parse
-    File.open('data/brian.xrds') do |f|
-      xrds = XRDS.new(f.read)
-      assert_not_nil(xrds)
-      assert_equal(xrds.services.length, 1)
-      
-      service = xrds.services[0]
-      service.yadis = FakeYadis.new
-      
-      openid_service = OpenID::OpenIDServiceEndpoint.from_endpoint(service)
-      assert_not_nil(openid_service)
-      assert_equal(openid_service.server_url, 'http://www.myopenid.com/server')
-    end
-    File.open('data/brianellin.mylid.xrds') do |f|
-      xrds = XRDS.new(f.read)
-      assert_not_nil(xrds)
-      assert_equal(xrds.services.length, 9)
-      
-      service = xrds.services[8]
-      assert_not_nil(service)
-      service.yadis = FakeYadis.new
-      
-      openid_service = OpenID::OpenIDServiceEndpoint.from_endpoint(service)
-      assert_not_nil(openid_service)
-      assert_equal(openid_service.server_url, 'http://mylid.net/brianellin')
-    end
-  end
-
-end
-

data/test/storetestcase.rb

@@ -1,172 +0,0 @@
-require 'openid/util'
-require 'openid/association'
-
-module StoreTestCase 
-  
-  @@allowed_handle = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
-  @@allowed_nonce = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
-  
-  def _gen_nonce
-    OpenID::Util.random_string(8, @@allowed_nonce)
-  end
-
-  def _gen_handle(n)
-    OpenID::Util.random_string(n, @@allowed_handle)
-  end
-
-  def _gen_secret(n, chars=nil)
-    OpenID::Util.random_string(n, chars)
-  end
-
-  def _gen_assoc(issued, lifetime=600)
-    secret = _gen_secret(20)
-    handle = _gen_handle(128)
-    OpenID::Association.new(handle, secret, Time.now.to_i + issued, lifetime,
-                            'HMAC-SHA1') 
-  end
-    
-  def _check_retrieve(url, handle=nil, expected=nil)
-    ret_assoc = @store.get_association(url, handle)
-
-    if expected.nil? or @store.dumb?
-      assert_nil(ret_assoc)
-    else
-      assert_equal(ret_assoc, expected)
-      assert_equal(ret_assoc.handle, expected.handle)
-      assert_equal(ret_assoc.secret, expected.secret)
-    end
-  end
-
-  def _check_remove(url, handle, expected)
-    present = @store.remove_association(url, handle)
-    expected_present = ((not @store.dumb?) and expected)
-    assert ((not expected_present and not present) or \
-            (expected_present and present))    
-  end
-
-  def test_store
-    server_url = "http://www.myopenid.com/openid"
-    assoc = _gen_assoc(issued=0)
-
-    # Make sure that a missing association returns no result
-    _check_retrieve(server_url)
-
-    # Check that after storage, getting returns the same result
-    @store.store_association(server_url, assoc)
-    _check_retrieve(server_url, nil, assoc)
-
-    # more than once
-    _check_retrieve(server_url, nil, assoc)
-
-    # Storing more than once has no ill effect
-    @store.store_association(server_url, assoc)
-    _check_retrieve(server_url, nil, assoc)
-
-    # Removing an association that does not exist returns not present
-    _check_remove(server_url, assoc.handle + 'x', false)
-
-    # Removing an association that does not exist returns not present
-    _check_remove(server_url + 'x', assoc.handle, false)
-
-    # Removing an association that is present returns present
-    _check_remove(server_url, assoc.handle, true)
-
-    # but not present on subsequent calls
-    _check_remove(server_url, assoc.handle, false)
-
-    # Put assoc back in the store
-    @store.store_association(server_url, assoc)
-
-    # More recent and expires after assoc
-    assoc2 = _gen_assoc(issued=1)
-    @store.store_association(server_url, assoc2)
-
-    # After storing an association with a different handle, but the
-    # same server_url, the handle with the later expiration is returned.
-    _check_retrieve(server_url, nil, assoc2)
-
-    # We can still retrieve the older association
-    _check_retrieve(server_url, assoc.handle, assoc)
-
-    # Plus we can retrieve the association with the later expiration
-    # explicitly
-    _check_retrieve(server_url, assoc2.handle, assoc2)
-
-    # More recent, and expires earlier than assoc2 or assoc. Make sure
-    # that we're picking the one with the latest issued date and not
-    # taking into account the expiration.
-    assoc3 = _gen_assoc(issued=2, lifetime=100)
-    @store.store_association(server_url, assoc3)
-
-    _check_retrieve(server_url, nil, assoc3)
-    _check_retrieve(server_url, assoc.handle, assoc)
-    _check_retrieve(server_url, assoc2.handle, assoc2)
-    _check_retrieve(server_url, assoc3.handle, assoc3)
-
-    _check_remove(server_url, assoc2.handle, true)
-
-    _check_retrieve(server_url, nil, assoc3)
-    _check_retrieve(server_url, assoc.handle, assoc)
-    _check_retrieve(server_url, assoc2.handle, nil)
-    _check_retrieve(server_url, assoc3.handle, assoc3)
-
-    _check_remove(server_url, assoc2.handle, false)
-    _check_remove(server_url, assoc3.handle, true)
-
-    _check_retrieve(server_url, nil, assoc)
-    _check_retrieve(server_url, assoc.handle, assoc)
-    _check_retrieve(server_url, assoc2.handle, nil)
-    _check_retrieve(server_url, assoc3.handle, nil)
-
-    _check_remove(server_url, assoc2.handle, false)
-    _check_remove(server_url, assoc.handle, true)
-    _check_remove(server_url, assoc3.handle, false)
-
-    _check_retrieve(server_url, nil, nil)
-    _check_retrieve(server_url, assoc.handle, nil)
-    _check_retrieve(server_url, assoc2.handle, nil)
-    _check_retrieve(server_url, assoc3.handle, nil)
-
-    _check_remove(server_url, assoc2.handle, false)
-    _check_remove(server_url, assoc.handle, false)
-    _check_remove(server_url, assoc3.handle, false)
-  end
-    
-  def test_nonce
-    nonce1 = _gen_nonce
-    
-    assert_not_nil(nonce1)
-
-    # a nonce is present by default
-    present = @store.use_nonce(nonce1)
-    assert_equal(present, false)
-
-    # Storing once causes use_nonce to return true the first, and only
-    # the first, time it is called after the store.
-    @store.store_nonce(nonce1)
-    present = @store.use_nonce(nonce1)
-    assert present
-    present = @store.use_nonce(nonce1)
-    assert_equal(present, false)
-    
-    # Storing twice has the same effect as storing once.
-    @store.store_nonce(nonce1)
-    @store.store_nonce(nonce1)
-    present = @store.use_nonce(nonce1)
-    assert present
-    present = @store.use_nonce(nonce1)
-    assert_equal(present, false)
-    
-    ### Auth key stuff
-    
-    # there is no key to start with, so generate a new key and return it
-    key = @store.get_auth_key
-    
-    # the second time we should return the same key as before
-    key2 = @store.get_auth_key
-    assert key == key2
-  end
-
-end
-
-

data/test/teststore.rb

@@ -1,47 +0,0 @@
-require 'test/unit'
-require 'fileutils'
-require 'pathname'
-require 'tmpdir'
-
-require 'openid/filestore'
-require 'storetestcase'
-
-class FileStoreTestCase < Test::Unit::TestCase
-  include StoreTestCase
-
-  @@dir = Pathname.new(Dir.tmpdir).join('filstoretest')
-
-  def setup
-    FileUtils.rm_rf(@@dir)
-    @store = OpenID::FilesystemStore.new(@@dir)    
-  end
-
-  def teardown
-    FileUtils.rm_rf(@@dir)
-  end
-end
-
-class DumbStoreTestCase < Test::Unit::TestCase
-  include StoreTestCase
-
-  def setup
-    @store = OpenID::DumbStore.new('unit-test')
-  end
-
-  def test_nonce
-    assert_equal(true, @store.use_nonce('anything'))
-  end
-
-end
-
-class MemoryStoreTestCase < Test::Unit::TestCase
-  include StoreTestCase
-
-  @@dir = Pathname.new(Dir.tmpdir).join('filstoretest')
-
-  def setup
-    @store = OpenID::MemoryStore.new
-  end
-
-end
-

data/test/trustroot.rb

@@ -1,117 +0,0 @@
-require 'test/unit'
-require 'openid/trustroot'
-
-class TrustRootTestCase < Test::Unit::TestCase
-
-  def test_parse_bad
-
-    def assert_bad(s)
-      tr = OpenID::TrustRoot.parse(s)
-      assert_nil(tr)
-    end
-
-    assert_bad('baz.org')
-    assert_bad('*.foo.com')
-    assert_bad('http://*.schtuff.*/')
-    assert_bad('ftp://foo.com')
-    assert_bad('ftp://*.foo.com')
-    assert_bad('http://*.foo.com:80:90/')
-    assert_bad('foo.*.com')
-    assert_bad('http://foo.*.com')
-    assert_bad('http://www.*')
-    assert_bad('')
-    assert_bad(' ')
-    assert_bad(' \t\n ')
-    assert_bad(nil)
-    assert_bad(5)
-  end
-
-  def test_parse_good
-    
-    def assert_good(s)
-      tr = OpenID::TrustRoot.parse(s)
-      assert_not_nil(tr)
-    end
-
-    assert_good('http://*/')
-    assert_good('https://*/')
-    assert_good('http://*.schtuff.com/')
-    assert_good('http://*.schtuff.com')
-    assert_good('http://www.schtuff.com/')
-    assert_good('http://www.schtuff.com')
-    assert_good('http://*.this.that.schtuff.com/')
-    assert_good('http://*.com/')
-    assert_good('http://*.com')
-    assert_good('http://*.foo.com/path')
-    assert_good('http://x.foo.com/path?action=foo2')
-    assert_good('http://*.foo.com/path?action=foo2')
-    assert_good('http://localhost:8081/')
-  end
-
-  def test_sane
-
-    def assert_sane(s, expected)
-      tr = OpenID::TrustRoot.parse(s)
-      assert_not_nil(tr)
-      assert_equal(tr.sane?, expected, s)
-    end
-
-    assert_sane('http://*/', false)
-    assert_sane('https://*/', false)
-    assert_sane('http://*.schtuff.com/', true)
-    assert_sane('http://*.foo.schtuff.com/', true)
-    assert_sane('http://*.com/', false)
-    assert_sane('http://*.com.au/', false)
-    assert_sane('http://*.co.uk/', false)
-    assert_sane('http://localhost:8082/?action=openid', true)
-    assert_sane('http://*.foo.notatld', false)
-    assert_sane('http://*.museum/', false)
-    assert_sane('http://kink.fm/', true)
-    assert_sane('http://beta.lingu.no/', true)
-  end
-
-  def test_validate
-    
-    def assert_valid(s, url, expected)
-      tr = OpenID::TrustRoot.parse(s)
-      assert_not_nil(tr)
-      assert_equal(tr.sane?, true)
-      assert_equal(tr.validate_url(url), expected)
-    end
-
-    assert_valid('http://*.foo.com', 'http://foo.com', true)
-    assert_valid('http://*.foo.com/', 'http://foo.com/', true)
-    assert_valid('http://*.foo.com', 'http://b.foo.com', true)
-    assert_valid('http://*.foo.com', 'http://b.foo.com/', true)
-    assert_valid('http://*.foo.com', 'http://b.foo.com/', true)
-    assert_valid('http://*.foo.com', 'http://b.foo.com', true)
-    assert_valid('http://*.b.foo.com', 'http://b.foo.com', true)
-    assert_valid('http://*.b.foo.com', 'http://x.b.foo.com', true)
-    assert_valid('http://*.bar.co.uk', 'http://www.bar.co.uk', true)
-    assert_valid('http://*.uoregon.edu', 'http://x.cs.uoregon.edu', true)
-
-    assert_valid('http://*.cs.uoregon.edu', 'http://x.uoregon.edu', false)
-    assert_valid('http://*.foo.com', 'http://bar.com', false)
-    assert_valid('http://*.foo.com', 'http://www.bar.com', false)
-    assert_valid('http://*.bar.co.uk', 'http://xxx.co.uk', false)
-
-    # path validity
-    assert_valid('http://x.com/abc', 'http://x.com/', false)
-    assert_valid('http://x.com/abc', 'http://x.com/a', false)
-    assert_valid('http://*.x.com/abc', 'http://foo.x.com/abc', true)
-    assert_valid('http://*.x.com/abc', 'http://foo.x.com', false)
-    assert_valid('http://*.x.com', 'http://foo.x.com/gallery', true)
-    assert_valid('http://foo.x.com', 'http://foo.x.com/gallery', true)
-    assert_valid('http://foo.x.com/gallery', 'http://foo.x.com/gallery/xxx', true)
-    assert_valid('http://localhost:8081/x?action=openid',
-                'http://localhost:8081/x?action=openid', true)
-    assert_valid('http://*.x.com/gallery', 'http://foo.x.com/gallery', true)
-
-    assert_valid('http://localhost:8082/?action=openid',
-                'http://localhost:8082/?action=openid', true)
-    assert_valid('http://goathack.livejournal.org:8020/',
-                'http://goathack.livejournal.org:8020/openid/login.bml', true)
-
-  end
-
-end