ruby-openid 1.1.4 → 2.0.1

data/test/test_kvform.rb

@@ -0,0 +1,165 @@
+require 'test/unit'
+require 'openid/kvform'
+require 'openid/util'
+require '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 ArgumentError instead of logging
+      # messages
+      if warnings > 0
+        assert_raise(ArgumentError) 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 ArgumentError instead of logging
+      # messages
+      if warnings > 0
+        assert_raise(ArgumentError) 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(ArgumentError) 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,65 @@
+require "openid/kvpost"
+require "openid/kvform"
+require "openid/message"
+require "test/unit"
+require 'testutil'
+
+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,101 @@
+require 'test/unit'
+require 'testutil'
+require 'openid/consumer/html_parse'
+
+class LinkParseTestCase < Test::Unit::TestCase
+  include OpenID::TestDataMixin
+
+  def attr_cmp(expected, found)
+    e = expected.to_a
+    f = found.to_a
+    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