entp-ruby-openid 2.2

data/test/test_kvform.rb

@@ -0,0 +1,164 @@
+require "test_helper"
+require 'openid/kvform'
+require 'openid/util'
+
+include OpenID
+
+class KVFormTests < Test::Unit::TestCase
+  include OpenID::TestUtil
+
+  def test_kvdict
+    [
+     # (kvform, parsed dictionary, expected warnings)
+     ["", {}, 0],
+     ["\n  \n     \n", {}, 0],
+     ["college:harvey mudd\n", {"college" => "harvey mudd"}, 0],
+     ["city:claremont\nstate:CA\n",
+      {"city" => "claremont", "state" => "CA"}, 0],
+     ["is_valid:true\ninvalidate_handle:{HMAC-SHA1:2398410938412093}\n",
+      {"is_valid" => "true",
+        "invalidate_handle" => "{HMAC-SHA1:2398410938412093}"}, 0],
+
+     # Warnings from lines with no colon:
+     ["x\n", {}, 1],
+     ["x\nx\n", {}, 2],
+     ["East is least\n", {}, 1],
+
+     # But not from blank lines (because LJ generates them)
+     ["x\n\n", {}, 1],
+
+     # Warning from empty key
+     [":\n", {''=>''}, 1],
+     [":missing key\n", {''=>'missing key'}, 1],
+
+     # Warnings from leading or trailing whitespace in key or value
+     [" street:foothill blvd\n", {"street"=>"foothill blvd"}, 1],
+     ["major: computer science\n", {"major"=>"computer science"}, 1],
+     [" dorm : east \n", {"dorm"=>"east"}, 2],
+
+     # Warnings from missing trailing newline
+     ["e^(i*pi)+1:0", {"e^(i*pi)+1" => "0"}, 1],
+     ["east:west\nnorth:south", {"east"=>"west", "north"=>"south"}, 1],
+    ].each { |case_|
+      _run_kvdictTest(case_)
+    }
+  end
+
+  def _run_kvdictTest(case_)
+    kv, dct, warnings = case_
+
+    d = nil
+    d2 = nil
+    assert_log_line_count(warnings) {
+      # Convert KVForm to dict
+      d = Util.kv_to_dict(kv)
+
+      # Strict mode should raise KVFormError instead of logging
+      # messages
+      if warnings > 0
+        assert_raise(KVFormError) do
+          Util.kv_to_seq(kv, true)
+        end
+      end
+
+      # make sure it parses to expected dict
+      assert_equal(dct, d)
+    }
+
+    # Convert back to KVForm and round-trip back to dict to make sure
+    # that *** dict -> kv -> dict is identity. ***
+    kv = Util.dict_to_kv(d)
+
+    silence_logging {
+      d2 = Util.kv_to_dict(kv)
+    }
+
+    assert_equal(d, d2)
+  end
+
+  def test_kvseq
+    [
+     [[], "", 0],
+
+     [[["openid", "useful"], ["a", "b"]], "openid:useful\na:b\n", 0],
+
+     # Warnings about leading whitespace
+     [[[" openid", "useful"], ["a", "b"]], " openid:useful\na:b\n", 2],
+
+     # Warnings about leading and trailing whitespace
+     [[[" openid ", " useful "],
+       [" a ", " b "]], " openid : useful \n a : b \n", 8],
+
+     # warnings about leading and trailing whitespace, but not about
+     # internal whitespace.
+     [[[" open id ", " use ful "],
+       [" a ", " b "]], " open id : use ful \n a : b \n", 8],
+
+     [[["foo", "bar"]], "foo:bar\n", 0],
+    ].each { |case_|
+      _run_kvseqTest(case_)
+    }
+  end
+
+  def _cleanSeq(seq)
+    # Create a new sequence by stripping whitespace from start and end
+    # of each value of each pair
+    seq.collect { |k, v| [k.strip(), v.strip()] }
+  end
+
+  def _run_kvseqTest(case_)
+    seq, kvform, warnings = case_
+
+    assert_log_line_count(warnings) {
+      # seq serializes to expected kvform
+      actual = Util.seq_to_kv(seq)
+
+      assert_equal(kvform, actual)
+      assert actual.is_a?(String)
+
+      # Strict mode should raise KVFormError instead of logging
+      # messages
+      if warnings > 0
+        assert_raise(KVFormError) do
+          Util.seq_to_kv(seq, true)
+        end
+      end
+
+      # Parse back to sequence. Expected to be unchanged, except
+      # stripping whitespace from start and end of values
+      # (i. e. ordering, case, and internal whitespace is preserved)
+      seq = Util.kv_to_seq(actual)
+      clean_seq = _cleanSeq(seq)
+
+      assert_equal(seq, clean_seq)
+    }
+  end
+
+  def test_kvexc
+    [
+     [["openid", "use\nful"]],
+     [["open\nid", "useful"]],
+     [["open\nid", "use\nful"]],
+     [["open:id", "useful"]],
+     [["foo", "bar"], ["ba\n d", "seed"]],
+     [["foo", "bar"], ["bad:", "seed"]],
+    ].each { |case_|
+      _run_kvexcTest(case_)
+    }
+  end
+
+  def _run_kvexcTest(case_)
+    seq = case_
+
+    assert_raise(KVFormError) do
+      Util.seq_to_kv(seq)
+    end
+  end
+
+  def test_convert
+    assert_log_line_count(2) {
+      result = Util.seq_to_kv([[1, 1]])
+      assert_equal(result, "1:1\n")
+    }
+  end
+end

data/test/test_kvpost.rb

@@ -0,0 +1,64 @@
+require 'test_helper'
+require "openid/kvpost"
+require "openid/kvform"
+require "openid/message"
+
+module OpenID
+  class KVPostTestCase < Test::Unit::TestCase
+    include FetcherMixin
+
+    def mk_resp(status, resp_hash)
+      return MockResponse.new(status, Util.dict_to_kv(resp_hash))
+    end
+
+    def test_msg_from_http_resp_success
+      resp = mk_resp(200, {'mode' => 'seitan'})
+      msg = Message.from_http_response(resp, 'http://invalid/')
+      assert_equal({'openid.mode' => 'seitan'}, msg.to_post_args)
+    end
+
+    def test_400
+      args = {'error' => 'I ate too much cheese',
+        'error_code' => 'sadness'}
+      resp = mk_resp(400, args)
+      begin
+        val = Message.from_http_response(resp, 'http://invalid/')
+      rescue ServerError => why
+        assert_equal(why.error_text, 'I ate too much cheese')
+        assert_equal(why.error_code, 'sadness')
+        assert_equal(why.message.to_args, args)
+      else
+        fail("Expected exception. Got: #{val}")
+      end
+    end
+
+    def test_500
+      args = {'error' => 'I ate too much cheese',
+        'error_code' => 'sadness'}
+      resp = mk_resp(500, args)
+      assert_raises(HTTPStatusError) {
+        Message.from_http_response(resp, 'http://invalid')
+      }
+    end
+
+    def make_kv_post_with_response(status, args)
+      resp = mk_resp(status, args)
+      mock_fetcher = Class.new do
+        define_method(:fetch) do |url, body, xxx, yyy|
+          resp
+        end
+      end
+      fetcher = mock_fetcher.new
+
+      with_fetcher(mock_fetcher.new) do
+        OpenID.make_kv_post(Message.from_openid_args(args), 'http://invalid/')
+      end
+    end
+
+    def test_make_kv_post
+      assert_raises(HTTPStatusError) {
+        make_kv_post_with_response(500, {})
+      }
+    end
+  end
+end

data/test/test_linkparse.rb

@@ -0,0 +1,100 @@
+require "test_helper"
+require 'openid/consumer/html_parse'
+
+class LinkParseTestCase < Test::Unit::TestCase
+  include OpenID::TestDataMixin
+
+  def attr_cmp(expected, found)
+    e = expected.to_a.sort
+    f = found.to_a.sort
+    while (ep = e.shift)
+      ek, ev = ep
+      fk, fv = f.shift
+      ok = false
+      while ek[-1] == '*'[0] # optional entry detected
+        if fk == ek[0...-1] and fv==ev # optional entry found
+          ok = true
+          break
+        else # not found. okay, move on to next expected pair
+          ek, ev = e.shift
+        end
+        if ek.nil?
+          if fk == nil
+            ok = true
+          end
+          break
+        end
+      end
+      next if ok
+      next if fk == ek and fv == ev
+      return false
+    end
+    return f.empty?
+  end
+
+  def test_attrcmp
+    good = [
+     [{'foo' => 'bar'},{'foo' => 'bar'}],
+     [{'foo*' => 'bar'},{'foo' => 'bar'}],
+     [{'foo' => 'bar', 'bam*' => 'baz'},{'foo' => 'bar'}],
+     [{'foo' => 'bar', 'bam*' => 'baz', 'tak' => 'tal'},
+        {'foo' => 'bar', 'tak' => 'tal'}],
+     ]
+    bad = [
+     [{},{'foo' => 'bar'}],
+     [{'foo' => 'bar'}, {'bam' => 'baz'}],
+     [{'foo' => 'bar'}, {}],
+     [{'foo*' => 'bar'},{'foo*' => 'bar'}],
+     [{'foo' => 'bar', 'tak' => 'tal'}, {'foo' => 'bar'}]
+    ]
+    good.each{|c|assert(attr_cmp(c[0],c[1]),c.inspect)}
+    bad.each{|c|assert(!attr_cmp(c[0],c[1]),c.inspect)}
+
+  end
+
+  def test_linkparse
+    cases = read_data_file('linkparse.txt', false).split("\n\n\n")
+
+    numtests = nil
+    testnum = 0
+    cases.each {|c|
+      headers, html = c.split("\n\n",2)
+      expected_links = []
+      name = ""
+      testnum += 1
+      headers.split("\n").each{|h|
+        k,v = h.split(":",2)
+        v = '' if v.nil?
+        if k == "Num Tests"
+          assert(numtests.nil?, "datafile parsing error: there can be only one NumTests")
+          numtests = v.to_i
+          testnum = 0
+          next
+        elsif k == "Name"
+          name = v.strip
+        elsif k == "Link" or k == "Link*"
+          attrs = {}
+          v.strip.split.each{|a|
+            kk,vv = a.split('=')
+            attrs[kk]=vv
+          }
+          expected_links << [k== "Link*", attrs]
+        else
+          assert(false, "datafile parsing error: bad header #{h}")
+        end
+      }
+      links = OpenID::parse_link_attrs(html)
+
+      found = links.dup
+      expected = expected_links.dup
+      while(fl = found.shift)
+        optional, el = expected.shift
+        while optional and !attr_cmp(el, fl) and not expected.empty?
+          optional, el = expected.shift
+        end
+        assert(attr_cmp(el,fl), "#{name}: #{fl.inspect} does not match #{el.inspect}")
+      end
+    }
+    assert_equal(numtests, testnum, "Number of tests")
+  end
+end

data/test/test_message.rb

@@ -0,0 +1,1115 @@
+require 'test_helper'
+require 'support/test_util'
+require 'openid/message'
+
+require 'rexml/document'
+
+module OpenID
+  module GetArgsMixin
+
+    # Tests a standard set of behaviors of Message.get_arg with
+    # variations on handling defaults.
+    def get_arg_tests(ns, key, expected=nil)
+      assert_equal(expected, @m.get_arg(ns, key))
+
+      if expected.nil?
+        assert_equal(@m.get_arg(ns, key, :a_default), :a_default)
+        assert_raise(Message::KeyNotFound) { @m.get_arg(ns, key, NO_DEFAULT) }
+      else
+        assert_equal(@m.get_arg(ns, key, :a_default), expected)
+        assert_equal(@m.get_arg(ns, key, NO_DEFAULT), expected)
+      end
+
+    end
+
+  end
+
+  class EmptyMessageTestCase < Test::Unit::TestCase
+    include GetArgsMixin
+
+    def setup
+      @m = Message.new
+    end
+
+    def test_get_aliased_arg_no_default
+      assert_raises(Message::KeyNotFound) do
+        @m.get_aliased_arg('ns.pork', NO_DEFAULT)
+      end
+
+      ns_uri = "urn:pork"
+      @m.namespaces.add_alias(ns_uri, 'pork_alias')
+
+      # Should return ns_uri.
+      assert_equal(ns_uri, @m.get_aliased_arg('ns.pork_alias', NO_DEFAULT))
+    end
+
+    def test_to_post_args
+      assert_equal({}, @m.to_post_args)
+    end
+
+    def test_to_args
+      assert_equal({}, @m.to_args)
+    end
+
+    def test_to_kvform
+      assert_equal('', @m.to_kvform)
+    end
+
+    def test_from_kvform
+      kvform = "foo:bar\none:two\n"
+      args = {'foo' => 'bar', 'one' => 'two'}
+      expected_result = Message.from_openid_args(args)
+
+      assert_equal(expected_result, Message.from_kvform(kvform))
+    end
+
+    def test_to_url_encoded
+      assert_equal('', @m.to_url_encoded)
+    end
+
+    def test_to_url
+      base_url = 'http://base.url/'
+      assert_equal(base_url, @m.to_url(base_url))
+    end
+
+    def test_get_openid
+      assert_equal(nil, @m.get_openid_namespace)
+    end
+
+    def test_get_key_openid
+      assert_raise(UndefinedOpenIDNamespace) {
+        @m.get_key(OPENID_NS, nil)
+      }
+    end
+
+    def test_get_key_bare
+      assert_equal('foo', @m.get_key(BARE_NS, 'foo'))
+    end
+
+    def test_get_key_ns1
+      assert_equal(nil, @m.get_key(OPENID1_NS, 'foo'))
+    end
+
+    def test_get_key_ns2
+      assert_equal(nil, @m.get_key(OPENID2_NS, 'foo'))
+    end
+
+    def test_get_key_ns3
+      assert_equal(nil, @m.get_key('urn:something-special', 'foo'))
+    end
+
+    def test_has_key
+      assert_raise(UndefinedOpenIDNamespace) {
+        @m.has_key?(OPENID_NS, 'foo')
+      }
+    end
+
+    def test_has_key_bare
+      assert_equal(false, @m.has_key?(BARE_NS, 'foo'))
+    end
+
+    def test_has_key_ns1
+      assert_equal(false, @m.has_key?(OPENID1_NS, 'foo'))
+    end
+
+    def test_has_key_ns2
+      assert_equal(false, @m.has_key?(OPENID2_NS, 'foo'))
+    end
+
+    def test_has_key_ns3
+      assert_equal(false, @m.has_key?('urn:xxx', 'foo'))
+    end
+
+    def test_get_arg
+      assert_raise(UndefinedOpenIDNamespace) {
+        @m.get_args(OPENID_NS)
+      }
+    end
+
+    def test_get_arg_bare
+      get_arg_tests(ns=BARE_NS, key='foo')
+    end
+
+    def test_get_arg_ns1
+      get_arg_tests(ns=OPENID1_NS, key='foo')
+    end
+
+    def test_get_arg_ns2
+      get_arg_tests(ns=OPENID2_NS, key='foo')
+    end
+
+    def test_get_arg_ns3
+      get_arg_tests(ns='urn:nothing-significant', key='foo')
+    end
+
+    def test_get_args
+      assert_raise(UndefinedOpenIDNamespace) {
+        @m.get_args(OPENID_NS)
+      }
+    end
+
+    def test_get_args_bare
+      assert_equal({}, @m.get_args(BARE_NS))
+    end
+
+    def test_get_args_ns1
+      assert_equal({}, @m.get_args(OPENID1_NS))
+    end
+
+    def test_get_args_ns2
+      assert_equal({}, @m.get_args(OPENID2_NS))
+    end
+
+    def test_get_args_ns3
+      assert_equal({}, @m.get_args('urn:xxx'))
+    end
+
+    def test_update_args
+      assert_raise(UndefinedOpenIDNamespace) {
+        @m.update_args(OPENID_NS, {'does not'=>'matter'})
+      }
+    end
+
+    def _test_update_args_ns(ns)
+      updates = {
+        'camper van beethoven' => 'david l',
+        'magnolia electric, co' => 'jason m'
+      }
+      assert_equal({}, @m.get_args(ns))
+      @m.update_args(ns, updates)
+      assert_equal(updates, @m.get_args(ns))
+    end
+
+    def test_update_args_bare
+      _test_update_args_ns(BARE_NS)
+    end
+    def test_update_args_ns1
+      _test_update_args_ns(OPENID1_NS)
+    end
+    def test_update_args_ns2
+      _test_update_args_ns(OPENID2_NS)
+    end
+    def test_update_args_ns3
+      _test_update_args_ns('urn:xxx')
+    end
+
+    def test_set_arg
+      assert_raise(UndefinedOpenIDNamespace) {
+        @m.set_arg(OPENID_NS,'does not','matter')
+      }
+    end
+
+    def _test_set_arg_ns(ns)
+      key = 'Camper Van Beethoven'
+      value = 'David Lowery'
+      assert_equal(nil, @m.get_arg(ns, key))
+      @m.set_arg(ns, key, value)
+      assert_equal(value, @m.get_arg(ns, key))
+    end
+
+    def test_set_arg_bare
+      _test_set_arg_ns(BARE_NS)
+    end
+    def test_set_arg_ns1
+      _test_set_arg_ns(OPENID1_NS)
+    end
+    def test_set_arg_ns2
+      _test_set_arg_ns(OPENID2_NS)
+    end
+    def test_set_arg_ns3
+      _test_set_arg_ns('urn:xxx')
+    end
+
+    def test_del_arg
+      assert_raise(UndefinedOpenIDNamespace) {
+        @m.set_arg(OPENID_NS, 'does not', 'matter')
+      }
+    end
+
+    def _test_del_arg_ns(ns)
+      key = 'Fleeting Joys'
+      assert_equal(nil, @m.del_arg(ns, key))
+    end
+
+    def test_del_arg_bare
+      _test_del_arg_ns(BARE_NS)
+    end
+    def test_del_arg_ns1
+      _test_del_arg_ns(OPENID1_NS)
+    end
+    def test_del_arg_ns2
+      _test_del_arg_ns(OPENID2_NS)
+    end
+    def test_del_arg_ns3
+      _test_del_arg_ns('urn:xxx')
+    end
+
+    def test_isOpenID1
+      assert_equal(false, @m.is_openid1)
+    end
+
+    def test_isOpenID2
+      assert_equal(false, @m.is_openid2)
+    end
+
+    def test_set_openid_namespace
+      assert_raise(InvalidOpenIDNamespace) {
+        @m.set_openid_namespace('http://invalid/', false)
+      }
+    end
+  end
+
+  class OpenID1MessageTest < Test::Unit::TestCase
+    include GetArgsMixin
+
+    def setup
+      @m = Message.from_post_args({'openid.mode' => 'error',
+                                            'openid.error' => 'unit test'})
+    end
+
+    def test_has_openid_ns
+      assert_equal(OPENID1_NS, @m.get_openid_namespace)
+      assert_equal(OPENID1_NS,
+                   @m.namespaces.get_namespace_uri(NULL_NAMESPACE))
+    end
+
+    def test_get_aliased_arg
+      assert_equal('error', @m.get_aliased_arg('mode'))
+    end
+
+    def test_get_aliased_arg_ns
+      assert_equal(OPENID1_NS, @m.get_aliased_arg('ns'))
+    end
+
+    def test_get_aliased_arg_with_ns
+      @m = Message.from_post_args(
+          {'openid.mode' => 'error',
+           'openid.error' => 'unit test',
+           'openid.ns.invalid' => 'http://invalid/',
+           'openid.invalid.stuff' => 'things',
+           'openid.invalid.stuff.blinky' => 'powerplant',
+          })
+      assert_equal('http://invalid/', @m.get_aliased_arg('ns.invalid'))
+      assert_equal('things', @m.get_aliased_arg('invalid.stuff'))
+      assert_equal('powerplant', @m.get_aliased_arg('invalid.stuff.blinky'))
+    end
+
+    def test_get_aliased_arg_with_ns_default
+      @m = Message.from_post_args({})
+      assert_equal('monkeys!', @m.get_aliased_arg('ns.invalid',
+                                                  default="monkeys!"))
+    end
+
+    def test_to_post_args
+      assert_equal({'openid.mode' => 'error',
+                     'openid.error' => 'unit test'},
+                   @m.to_post_args)
+    end
+
+    def test_to_post_args_ns
+      invalid_ns = 'http://invalid/'
+      @m.namespaces.add_alias(invalid_ns, 'foos')
+      @m.set_arg(invalid_ns, 'ball', 'awesome')
+      @m.set_arg(BARE_NS, 'xey', 'value')
+      assert_equal({'openid.mode' => 'error',
+                     'openid.error' => 'unit test',
+                     'openid.foos.ball' => 'awesome',
+                     'xey' => 'value',
+                     'openid.ns.foos' => 'http://invalid/'
+                   }, @m.to_post_args)
+    end
+
+    def test_to_args
+      assert_equal({'mode' => 'error',
+                     'error' => 'unit test'},
+                   @m.to_args)
+    end
+
+    def test_to_kvform
+      assert_equal("error:unit test\nmode:error\n",
+                   @m.to_kvform)
+    end
+
+    def test_to_url_encoded
+      assert_equal('openid.error=unit+test&openid.mode=error',
+                   @m.to_url_encoded)
+    end
+
+    def test_to_url
+      base_url = 'http://base.url/'
+      actual = @m.to_url(base_url)
+      actual_base = actual[0...base_url.length]
+      assert_equal(base_url, actual_base)
+      assert_equal('?', actual[base_url.length].chr)
+      query = actual[base_url.length+1..-1]
+      assert_equal({'openid.mode'=>['error'],'openid.error'=>['unit test']},
+                   CGI.parse(query))
+    end
+
+    def test_get_openid
+      assert_equal(OPENID1_NS, @m.get_openid_namespace)
+    end
+
+    def test_get_key_openid
+      assert_equal('openid.mode', @m.get_key(OPENID_NS, 'mode'))
+    end
+
+    def test_get_key_bare
+      assert_equal('mode', @m.get_key(BARE_NS, 'mode'))
+    end
+
+    def test_get_key_ns1
+      assert_equal('openid.mode', @m.get_key(OPENID1_NS, 'mode'))
+    end
+
+    def test_get_key_ns2
+      assert_equal(nil, @m.get_key(OPENID2_NS, 'mode'))
+    end
+
+    def test_get_key_ns3
+      assert_equal(nil, @m.get_key('urn:xxx', 'mode'))
+    end
+
+    def test_has_key
+      assert_equal(true, @m.has_key?(OPENID_NS, 'mode'))
+    end
+    def test_has_key_bare
+      assert_equal(false, @m.has_key?(BARE_NS, 'mode'))
+    end
+    def test_has_key_ns1
+      assert_equal(true, @m.has_key?(OPENID1_NS, 'mode'))
+    end
+    def test_has_key_ns2
+      assert_equal(false, @m.has_key?(OPENID2_NS, 'mode'))
+    end
+    def test_has_key_ns3
+      assert_equal(false, @m.has_key?('urn:xxx', 'mode'))
+    end
+
+    def test_get_arg
+      assert_equal('error', @m.get_arg(OPENID_NS, 'mode'))
+    end
+
+    def test_get_arg_bare
+      get_arg_tests(ns=BARE_NS, key='mode')
+    end
+
+    def test_get_arg_ns
+      get_arg_tests(ns=OPENID_NS, key='mode', expected='error')
+    end
+
+    def test_get_arg_ns1
+      get_arg_tests(ns=OPENID1_NS, key='mode', expected='error')
+    end
+
+    def test_get_arg_ns2
+      get_arg_tests(ns=OPENID2_NS, key='mode')
+    end
+
+    def test_get_arg_ns3
+      get_arg_tests(ns='urn:nothing-significant', key='mode')
+    end
+
+    def test_get_args
+      assert_equal({'mode'=>'error','error'=>'unit test'},
+                   @m.get_args(OPENID_NS))
+    end
+    def test_get_args_bare
+      assert_equal({}, @m.get_args(BARE_NS))
+    end
+    def test_get_args_ns1
+      assert_equal({'mode'=>'error','error'=>'unit test'},
+                   @m.get_args(OPENID1_NS))
+    end
+    def test_get_args_ns2
+      assert_equal({}, @m.get_args(OPENID2_NS))
+    end
+    def test_get_args_ns3
+      assert_equal({}, @m.get_args('urn:xxx'))
+    end
+
+    def _test_update_args_ns(ns, before=nil)
+      if before.nil?
+        before = {}
+      end
+      update_args = {
+        'Camper van Beethoven'=>'David Lowery',
+        'Magnolia Electric Co.'=>'Jason Molina'
+      }
+      assert_equal(before, @m.get_args(ns))
+      @m.update_args(ns, update_args)
+      after = before.dup
+      after.update(update_args)
+      assert_equal(after, @m.get_args(ns))
+    end
+
+    def test_update_args
+      _test_update_args_ns(OPENID_NS, {'mode'=>'error','error'=>'unit test'})
+    end
+    def test_update_args_bare
+      _test_update_args_ns(BARE_NS)
+    end
+    def test_update_args_ns1
+      _test_update_args_ns(OPENID1_NS, {'mode'=>'error','error'=>'unit test'})
+    end
+    def test_update_args_ns2
+      _test_update_args_ns(OPENID2_NS)
+    end
+    def test_update_args_ns3
+      _test_update_args_ns('urn:xxx')
+    end
+
+    def _test_set_arg_ns(ns)
+      key = 'awesometown'
+      value = 'funny'
+      assert_equal(nil, @m.get_arg(ns,key))
+      @m.set_arg(ns, key, value)
+      assert_equal(value, @m.get_arg(ns,key))
+    end
+
+    def test_set_arg; _test_set_arg_ns(OPENID_NS); end
+    def test_set_arg_bare; _test_set_arg_ns(BARE_NS); end
+    def test_set_arg_ns1; _test_set_arg_ns(OPENID1_NS); end
+    def test_set_arg_ns2; _test_set_arg_ns(OPENID2_NS); end
+    def test_set_arg_ns3; _test_set_arg_ns('urn:xxx'); end
+
+    def _test_del_arg_ns(ns)
+      key = 'marry an'
+      value = 'ice cream sandwich'
+      @m.set_arg(ns, key, value)
+      assert_equal(value, @m.get_arg(ns,key))
+      @m.del_arg(ns,key)
+      assert_equal(nil, @m.get_arg(ns,key))
+    end
+
+    def test_del_arg; _test_del_arg_ns(OPENID_NS); end
+    def test_del_arg_bare; _test_del_arg_ns(BARE_NS); end
+    def test_del_arg_ns1; _test_del_arg_ns(OPENID1_NS); end
+    def test_del_arg_ns2; _test_del_arg_ns(OPENID2_NS); end
+    def test_del_arg_ns3; _test_del_arg_ns('urn:yyy'); end
+
+    def test_isOpenID1
+      assert_equal(true, @m.is_openid1)
+    end
+
+    def test_isOpenID2
+      assert_equal(false, @m.is_openid2)
+    end
+
+    def test_equal
+      assert_equal(Message.new, Message.new)
+      assert_not_equal(Message.new, nil)
+    end
+
+    def test_from_openid_args_undefined_ns
+      expected = 'almost.complete'
+      msg = Message.from_openid_args({'coverage.is' => expected})
+      actual = msg.get_arg(OPENID1_NS, 'coverage.is')
+      assert_equal(expected, actual)
+    end
+
+    # XXX: we need to implement the KVForm module before we can fix this
+    def TODOtest_from_kvform
+      kv = 'foos:ball\n'
+      msg = Message.from_kvform(kv)
+      assert_equal(msg.get(OPENID1_NS, 'foos'), 'ball')
+    end
+
+    def test_initialize_sets_namespace
+      msg = Message.new(OPENID1_NS)
+      assert_equal(OPENID1_NS, msg.get_openid_namespace)
+    end
+  end
+
+  class OpenID1ExplicitMessageTest < Test::Unit::TestCase
+    # XXX - check to make sure the test suite will get built the way this
+    # expects.
+    def setup
+      @m = Message.from_post_args({'openid.mode'=>'error',
+                                          'openid.error'=>'unit test',
+                                          'openid.ns'=>OPENID1_NS})
+    end
+
+    def test_to_post_args
+      assert_equal({'openid.mode' => 'error',
+                    'openid.error' => 'unit test',
+                    'openid.ns'=>OPENID1_NS,
+                    },
+                   @m.to_post_args)
+    end
+
+    def test_to_post_args_ns
+      invalid_ns = 'http://invalid/'
+      @m.namespaces.add_alias(invalid_ns, 'foos')
+      @m.set_arg(invalid_ns, 'ball', 'awesome')
+      @m.set_arg(BARE_NS, 'xey', 'value')
+      assert_equal({'openid.mode' => 'error',
+                     'openid.error' => 'unit test',
+                     'openid.foos.ball' => 'awesome',
+                     'xey' => 'value',
+                     'openid.ns'=>OPENID1_NS,
+                     'openid.ns.foos' => 'http://invalid/'
+                   }, @m.to_post_args)
+    end
+
+    def test_to_args
+      assert_equal({'mode' => 'error',
+                     'error' => 'unit test',
+                     'ns'=>OPENID1_NS
+                     },
+                   @m.to_args)
+    end
+
+    def test_to_kvform
+      assert_equal("error:unit test\nmode:error\nns:#{OPENID1_NS}\n",
+                   @m.to_kvform)
+    end
+
+    def test_to_url_encoded
+      assert_equal('openid.error=unit+test&openid.mode=error&openid.ns=http%3A%2F%2Fopenid.net%2Fsignon%2F1.0',
+                   @m.to_url_encoded)
+    end
+
+    def test_to_url
+      base_url = 'http://base.url/'
+      actual = @m.to_url(base_url)
+      actual_base = actual[0...base_url.length]
+      assert_equal(base_url, actual_base)
+      assert_equal('?', actual[base_url.length].chr)
+      query = actual[base_url.length+1..-1]
+      assert_equal({'openid.mode'=>['error'],
+                    'openid.error'=>['unit test'],
+                    'openid.ns'=>[OPENID1_NS],
+                    },
+                   CGI.parse(query))
+    end
+
+
+  end
+
+  class OpenID2MessageTest < Test::Unit::TestCase
+    include TestUtil
+
+    def setup
+      @m = Message.from_post_args({'openid.mode'=>'error',
+                                          'openid.error'=>'unit test',
+                                          'openid.ns'=>OPENID2_NS})
+      @m.set_arg(BARE_NS, 'xey', 'value')
+    end
+
+    def test_to_args_fails
+      assert_raises(ArgumentError) {
+        @m.to_args
+      }
+    end
+
+    def test_fix_ns_non_string
+      # Using has_key to invoke _fix_ns since _fix_ns should be private
+      assert_raises(ArgumentError) {
+        @m.has_key?(:non_string_namespace, "key")
+      }
+    end
+
+    def test_fix_ns_non_uri
+      # Using has_key to invoke _fix_ns since _fix_ns should be private
+      assert_log_matches(/identifiers SHOULD be URIs/) {
+        @m.has_key?("foo", "key")
+      }
+    end
+
+    def test_fix_ns_sreg_literal
+      # Using has_key to invoke _fix_ns since _fix_ns should be private
+      assert_log_matches(/identifiers SHOULD be URIs/, /instead of "sreg"/) {
+        @m.has_key?("sreg", "key")
+      }
+    end
+
+    def test_copy
+      n = @m.copy
+      assert_equal(@m, n)
+    end
+
+    def test_to_post_args
+      assert_equal({'openid.mode' => 'error',
+                     'openid.error' => 'unit test',
+                     'openid.ns' => OPENID2_NS,
+                     'xey' => 'value',
+                   }, @m.to_post_args)
+    end
+
+    def test_to_post_args_ns
+      invalid_ns = 'http://invalid/'
+      @m.namespaces.add_alias(invalid_ns, 'foos')
+      @m.set_arg(invalid_ns, 'ball', 'awesome')
+      assert_equal({'openid.mode' => 'error',
+                     'openid.error' => 'unit test',
+                     'openid.ns' => OPENID2_NS,
+                     'openid.ns.foos' => invalid_ns,
+                     'openid.foos.ball' => 'awesome',
+                     'xey' => 'value',
+                   }, @m.to_post_args)
+    end
+
+    def test_to_args
+      @m.del_arg(BARE_NS, 'xey')
+      assert_equal({'mode' => 'error',
+                   'error' => 'unit test',
+                   'ns' => OPENID2_NS},
+                   @m.to_args)
+    end
+
+    def test_to_kvform
+      @m.del_arg(BARE_NS, 'xey')
+      assert_equal("error:unit test\nmode:error\nns:#{OPENID2_NS}\n",
+                   @m.to_kvform)
+    end
+
+    def _test_urlencoded(s)
+      expected_list = ["openid.error=unit+test",
+                       "openid.mode=error",
+                       "openid.ns=#{CGI.escape(OPENID2_NS)}",
+                       "xey=value"]
+      # Hard to do this with string comparison since the mapping doesn't
+      # preserve order.
+      encoded_list = s.split('&')
+      encoded_list.sort!
+      assert_equal(expected_list, encoded_list)
+    end
+
+    def test_to_urlencoded
+      _test_urlencoded(@m.to_url_encoded)
+    end
+
+    def test_to_url
+      base_url = 'http://base.url/'
+      actual = @m.to_url(base_url)
+      actual_base = actual[0...base_url.length]
+      assert_equal(base_url, actual_base)
+      assert_equal('?', actual[base_url.length].chr)
+      query = actual[base_url.length+1..-1]
+      _test_urlencoded(query)
+    end
+
+    def test_get_openid
+      assert_equal(OPENID2_NS, @m.get_openid_namespace)
+    end
+
+    def test_get_key_openid
+      assert_equal('openid.mode', @m.get_key(OPENID2_NS, 'mode'))
+    end
+
+    def test_get_key_bare
+      assert_equal('mode', @m.get_key(BARE_NS, 'mode'))
+    end
+
+    def test_get_key_ns1
+      assert_equal(nil, @m.get_key(OPENID1_NS, 'mode'))
+    end
+
+    def test_get_key_ns2
+      assert_equal('openid.mode', @m.get_key(OPENID2_NS, 'mode'))
+    end
+
+    def test_get_key_ns3
+      assert_equal(nil, @m.get_key('urn:xxx', 'mode'))
+    end
+
+    def test_has_key_openid
+      assert_equal(true, @m.has_key?(OPENID_NS,'mode'))
+    end
+
+    def test_has_key_bare
+      assert_equal(false, @m.has_key?(BARE_NS,'mode'))
+    end
+
+    def test_has_key_ns1
+      assert_equal(false, @m.has_key?(OPENID1_NS,'mode'))
+    end
+
+    def test_has_key_ns2
+      assert_equal(true, @m.has_key?(OPENID2_NS,'mode'))
+    end
+
+    def test_has_key_ns3
+      assert_equal(false, @m.has_key?('urn:xxx','mode'))
+    end
+
+    # XXX - getArgTest
+    def test_get_arg_openid
+      assert_equal('error', @m.get_arg(OPENID_NS,'mode'))
+    end
+
+    def test_get_arg_bare
+      assert_equal(nil, @m.get_arg(BARE_NS,'mode'))
+    end
+
+    def test_get_arg_ns1
+      assert_equal(nil, @m.get_arg(OPENID1_NS,'mode'))
+    end
+
+    def test_get_arg_ns2
+      assert_equal('error', @m.get_arg(OPENID2_NS,'mode'))
+    end
+
+    def test_get_arg_ns3
+      assert_equal(nil, @m.get_arg('urn:bananastand','mode'))
+    end
+
+    def test_get_args_openid
+      assert_equal({'mode'=>'error','error'=>'unit test'},
+                   @m.get_args(OPENID_NS))
+    end
+
+    def test_get_args_bare
+      assert_equal({'xey'=>'value'},
+                   @m.get_args(BARE_NS))
+    end
+
+    def test_get_args_ns1
+      assert_equal({},
+                   @m.get_args(OPENID1_NS))
+    end
+
+    def test_get_args_ns2
+      assert_equal({'mode'=>'error','error'=>'unit test'},
+                   @m.get_args(OPENID2_NS))
+    end
+
+    def test_get_args_ns3
+      assert_equal({},
+                   @m.get_args('urn:loose seal'))
+    end
+
+    def _test_update_args_ns(ns, before=nil)
+      before = {} unless before
+      update_args = {'aa'=>'bb','cc'=>'dd'}
+
+      assert_equal(before, @m.get_args(ns))
+      @m.update_args(ns, update_args)
+      after = before.dup
+      after.update(update_args)
+      assert_equal(after, @m.get_args(ns))
+    end
+
+    def test_update_args_openid
+      _test_update_args_ns(OPENID_NS, {'mode'=>'error','error'=>'unit test'})
+    end
+
+    def test_update_args_bare
+      _test_update_args_ns(BARE_NS, {'xey'=>'value'})
+    end
+
+    def test_update_args_ns1
+      _test_update_args_ns(OPENID1_NS)
+    end
+
+    def test_update_args_ns2
+      _test_update_args_ns(OPENID2_NS, {'mode'=>'error','error'=>'unit test'})
+    end
+
+    def test_update_args_ns3
+      _test_update_args_ns('urn:sven')
+    end
+
+    def _test_set_arg_ns(ns)
+      key = "logan's"
+      value = "run"
+      assert_equal(nil, @m.get_arg(ns,key))
+      @m.set_arg(ns, key, value)
+      assert_equal(value, @m.get_arg(ns,key))
+    end
+
+    def test_set_arg_openid; _test_set_arg_ns(OPENID_NS); end
+    def test_set_arg_bare; _test_set_arg_ns(BARE_NS); end
+    def test_set_arg_ns1; _test_set_arg_ns(OPENID1_NS); end
+    def test_set_arg_ns2; _test_set_arg_ns(OPENID2_NS); end
+    def test_set_arg_ns3; _test_set_arg_ns('urn:g'); end
+
+    def test_bad_alias
+      # Make sure dotted aliases and OpenID protocol fields are not allowed
+      # as namespace aliases.
+
+      fields = OPENID_PROTOCOL_FIELDS + ['dotted.alias']
+
+      fields.each { |f|
+        args = {"openid.ns.#{f}" => "blah#{f}",
+          "openid.#{f}.foo" => "test#{f}"}
+
+        # .fromPostArgs covers .fromPostArgs, .fromOpenIDArgs,
+        # ._fromOpenIDArgs, and .fromOpenIDArgs (since it calls
+        # .fromPostArgs).
+        assert_raise(AssertionError) {
+          Message.from_post_args(args)
+        }
+      }
+    end
+
+    def test_from_post_args
+      msg = Message.from_post_args({'foos' => 'ball'})
+      assert_equal('ball', msg.get_arg(BARE_NS, 'foos'))
+    end
+
+    def _test_del_arg_ns(ns)
+      key = 'no'
+      value = 'socks'
+      assert_equal(nil, @m.get_arg(ns, key))
+      @m.set_arg(ns, key, value)
+      assert_equal(value, @m.get_arg(ns, key))
+      @m.del_arg(ns, key)
+      assert_equal(nil, @m.get_arg(ns, key))
+    end
+
+    def test_del_arg_openid; _test_del_arg_ns(OPENID_NS); end
+    def test_del_arg_bare; _test_del_arg_ns(BARE_NS); end
+    def test_del_arg_ns1; _test_del_arg_ns(OPENID1_NS); end
+    def test_del_arg_ns2; _test_del_arg_ns(OPENID2_NS); end
+    def test_del_arg_ns3; _test_del_arg_ns('urn:tofu'); end
+
+    def test_overwrite_extension_arg
+      ns = 'urn:unittest_extension'
+      key = 'mykey'
+      value_1 = 'value_1'
+      value_2 = 'value_2'
+
+      @m.set_arg(ns, key, value_1)
+      assert_equal(value_1, @m.get_arg(ns, key))
+      @m.set_arg(ns, key, value_2)
+      assert_equal(value_2, @m.get_arg(ns, key))
+    end
+
+    def test_argList
+      assert_raise(ArgumentError) {
+        Message.from_post_args({'arg' => [1, 2, 3]})
+      }
+    end
+
+    def test_isOpenID1
+      assert_equal(false, @m.is_openid1)
+    end
+
+    def test_isOpenID2
+      assert_equal(true, @m.is_openid2)
+    end
+  end
+
+  class MessageTest < Test::Unit::TestCase
+    def setup
+      @postargs = {
+        'openid.ns' => OPENID2_NS,
+        'openid.mode' => 'checkid_setup',
+        'openid.identity' => 'http://bogus.example.invalid:port/',
+        'openid.assoc_handle' => 'FLUB',
+        'openid.return_to' => 'Neverland',
+        'openid.ax.value.fullname' => "Bob&Smith'"
+      }
+
+      @action_url = 'scheme://host:port/path?query'
+
+      @form_tag_attrs = {
+        'company' => 'janrain',
+        'class' => 'fancyCSS',
+      }
+
+      @submit_text = 'GO!'
+
+      ### Expected data regardless of input
+
+      @required_form_attrs = {
+        'accept-charset' => 'UTF-8',
+        'enctype' => 'application/x-www-form-urlencoded',
+        'method' => 'post',
+      }
+    end
+
+    def _checkForm(html, message_, action_url,
+                   form_tag_attrs, submit_text)
+      @xml = REXML::Document.new(html)
+
+      # Get root element
+      form = @xml.root
+
+      # Check required form attributes
+      @required_form_attrs.each { |k, v|
+        assert(form.attributes[k] == v,
+               "Expected '#{v}' for required form attribute '#{k}', got '#{form.attributes[k]}'")
+      }
+
+      # Check extra form attributes
+      @form_tag_attrs.each { |k, v|
+        # Skip attributes that already passed the required attribute
+        # check, since they should be ignored by the form generation
+        # code.
+        if @required_form_attrs.include?(k)
+          continue
+        end
+
+        assert(form.attributes[k] == v,
+               "Form attribute '#{k}' should be '#{v}', found '#{form.attributes[k]}'")
+
+        # Check hidden fields against post args
+        hiddens = []
+        form.each { |e|
+          if (e.is_a?(REXML::Element)) and
+              (e.name.upcase() == 'INPUT') and
+              (e.attributes['type'].upcase() == 'HIDDEN')
+            # For each post arg, make sure there is a hidden with that
+            # value.  Make sure there are no other hiddens.
+            hiddens += [e]
+          end
+        }
+
+        message_.to_post_args().each { |name, value|
+          success = false
+
+          hiddens.each { |e|
+            if e.attributes['name'] == name
+              assert(e.attributes['value'] == value,
+                     "Expected value of hidden input '#{e.attributes['name']}' " +
+                     "to be '#{value}', got '#{e.attributes['value']}'")
+              success = true
+              break
+            end
+          }
+
+          if !success
+            flunk "Post arg '#{name}' not found in form"
+          end
+        }
+
+        hiddens.each { |e|
+          assert(message_.to_post_args().keys().include?(e.attributes['name']),
+                 "Form element for '#{e.attributes['name']}' not in " +
+                 "original message")
+        }
+
+        # Check action URL
+        assert(form.attributes['action'] == action_url,
+               "Expected form 'action' to be '#{action_url}', got '#{form.attributes['action']}'")
+
+        # Check submit text
+        submits = []
+        form.each { |e|
+          if (e.is_a?(REXML::Element)) and
+              (e.name.upcase() == 'INPUT') and
+              e.attributes['type'].upcase() == 'SUBMIT'
+            submits += [e]
+          end
+        }
+
+        assert(submits.length == 1,
+               "Expected only one 'input' with type = 'submit', got #{submits.length}")
+
+        assert(submits[0].attributes['value'] == submit_text,
+               "Expected submit value to be '#{submit_text}', " +
+               "got '#{submits[0].attributes['value']}'")
+      }
+
+    end
+
+    def test_toFormMarkup
+      m = Message.from_post_args(@postargs)
+      html = m.to_form_markup(@action_url, @form_tag_attrs,
+                              @submit_text)
+      _checkForm(html, m, @action_url,
+                 @form_tag_attrs, @submit_text)
+    end
+
+    def test_overrideMethod
+      # Be sure that caller cannot change form method to GET.
+      m = Message.from_post_args(@postargs)
+
+      tag_attrs = @form_tag_attrs.clone
+      tag_attrs['method'] = 'GET'
+
+      html = m.to_form_markup(@action_url, @form_tag_attrs,
+                              @submit_text)
+      _checkForm(html, m, @action_url,
+                 @form_tag_attrs, @submit_text)
+    end
+
+    def test_overrideRequired
+      # Be sure that caller CANNOT change the form charset for
+      # encoding type.
+      m = Message.from_post_args(@postargs)
+
+      tag_attrs = @form_tag_attrs.clone
+      tag_attrs['accept-charset'] = 'UCS4'
+      tag_attrs['enctype'] = 'invalid/x-broken'
+
+      html = m.to_form_markup(@action_url, tag_attrs,
+                              @submit_text)
+      _checkForm(html, m, @action_url,
+                 tag_attrs, @submit_text)
+    end
+  end
+
+  class NamespaceMapTestCase < Test::Unit::TestCase
+
+    def test_onealias
+      nsm = NamespaceMap.new
+      uri = 'http://example.com/foo'
+      _alias = 'foo'
+      nsm.add_alias(uri, _alias)
+      assert_equal(uri, nsm.get_namespace_uri(_alias))
+      assert_equal(_alias, nsm.get_alias(uri))
+    end
+
+
+    def test_iteration
+      nsm = NamespaceMap.new
+      uripat = "http://example.com/foo%i"
+      nsm.add(uripat % 0)
+
+      (1..23).each { |i|
+        assert_equal(false, nsm.member?(uripat % i))
+        nsm.add(uripat % i)
+      }
+      nsm.each { |uri, _alias|
+        assert_equal(uri[22..-1], _alias[3..-1])
+      }
+
+      nsm = NamespaceMap.new
+      alias_ = 'bogus'
+      uri = 'urn:bogus'
+
+      nsm.add_alias(uri, alias_)
+
+      assert_equal(nsm.aliases(), [alias_])
+      assert_equal(nsm.namespace_uris(), [uri])
+    end
+
+    def test_register_default_alias
+      invalid_ns = 'http://invalid/'
+      alias_ = 'invalid'
+      Message.register_namespace_alias(invalid_ns, alias_)
+      # Doing it again doesn't raise an exception
+      Message.register_namespace_alias(invalid_ns, alias_)
+
+      # Once it's registered, you can't register it again
+      assert_raises(NamespaceAliasRegistrationError) {
+        Message.register_namespace_alias(invalid_ns, 'another_alias')
+      }
+
+      # Once it's registered, you can't register another URL with that alias
+      assert_raises(NamespaceAliasRegistrationError) {
+        Message.register_namespace_alias('http://janrain.com/', alias_)
+      }
+
+      # It gets used automatically by the Message class:
+      msg = Message.from_openid_args({'invalid.stuff' => 'things'})
+      assert(msg.is_openid1)
+      assert_equal(alias_, msg.namespaces.get_alias(invalid_ns))
+      assert_equal(invalid_ns, msg.namespaces.get_namespace_uri(alias_))
+    end
+
+    def test_alias_defined_twice
+      nsm = NamespaceMap.new
+      uri = 'urn:bogus'
+
+      nsm.add_alias(uri, 'foos')
+      assert_raises(IndexError) {
+        nsm.add_alias(uri, 'ball')
+      }
+    end
+  end
+end