nayutaya-wsse 0.0.0 → 0.0.1

data/lib/wsse/authenticator.rb

@@ -0,0 +1,28 @@
+# coding: utf-8
+
+require "wsse/username_token"
+
+module Wsse
+  module Authenticator
+    def self.authenticate(token, username, password)
+      return :wrong_username unless judge_username(token, username)
+      return :wrong_password unless judge_password(token, password)
+      return :success
+    end
+
+    def self.judge_username(token, username)
+      return (token.username == username)
+    end
+    private_class_method :judge_username
+
+    def self.judge_password(token, password)
+      digest = UsernameToken.create_password_digest(password, token.nonce, token.created)
+      return (token.digest == digest)
+    end
+    private_class_method :judge_password
+
+    def self.authenticate?(token, username, password)
+      return (self.authenticate(token, username, password) == :success)
+    end
+  end
+end

data/lib/wsse/core.rb

@@ -1,6 +1,5 @@
 # coding: utf-8
 
 require "wsse/version"
-
-module Wsse
-end
+require "wsse/username_token"
+require "wsse/authenticator"

data/lib/wsse/username_token.rb

@@ -0,0 +1,90 @@
+# coding: utf-8
+
+require "time"
+require "digest/sha1"
+
+module Wsse
+  class UsernameToken
+    def initialize(username, digest, nonce, created)
+      @username = username
+      @digest   = digest  # binary
+      @nonce    = nonce   # binary
+      @created  = created # Time object
+    end
+
+    attr_reader :username, :digest, :nonce, :created
+
+    def self.create_random_binary(size)
+      return size.times.map { rand(256) }.pack("C*")
+    end
+
+    def self.create_password_digest(password, nonce, created)
+      return Digest::SHA1.digest(nonce + created.utc.iso8601 + password)
+    end
+
+    def self.build(username, password, nonce = nil, created = nil)
+      nonce   ||= self.create_random_binary(20)
+      created ||= Time.now.utc
+      digest = self.create_password_digest(password, nonce, created)
+      return self.new(username, digest, nonce, created)
+    end
+
+    def self.parse_token(token)
+      if /\AUsernameToken (.+?=".+?"(?:, .+?=".+?")*)\z/ =~ token.to_s
+        return $1.scan(/(?:\A|, )(.+?)="(.+?)"/).inject({}) { |memo, (key, value)|
+          memo[key] = value
+          memo
+        }
+      else
+        return nil
+      end
+    end
+
+    def self.parse_time(value)
+      if /\A(\d{4})-(\d\d)-(\d\d)T(\d\d):(\d\d):(\d\d)Z\z/ =~ value.to_s
+        return Time.utc(*($~.captures.map { |s| s.to_i }))
+      else
+        return nil
+      end
+    end
+
+    def self.format_token_values(username, digest, nonce, created)
+      return format(
+        %|UsernameToken Username="%s", PasswordDigest="%s", Nonce="%s", Created="%s"|,
+        username, digest, nonce, created)
+    end
+
+    def self.parse(token)
+      parsed_token = self.parse_token(token)
+      return nil unless parsed_token
+
+      username = parsed_token["Username"]
+      digest   = parsed_token["PasswordDigest"]
+      nonce    = parsed_token["Nonce"]
+      created  = parsed_token["Created"]
+      return nil if [username, digest, nonce, created].include?(nil)
+
+      return self.new(
+        username,
+        digest.unpack("m")[0],
+        nonce.unpack("m")[0],
+        self.parse_time(created))
+    end
+
+    def base64encoded_digest
+      return [@digest].pack("m").chomp
+    end
+
+    def base64encoded_nonce
+      return [@nonce].pack("m").chomp
+    end
+
+    def format
+      return self.class.format_token_values(
+        self.username,
+        self.base64encoded_digest,
+        self.base64encoded_nonce,
+        self.created.utc.iso8601)
+    end
+  end
+end

data/lib/wsse/version.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
 
 module Wsse
-  VERSION = "0.0.0"
+  VERSION = "0.0.1"
 end

data/nayutaya-wsse.gemspec

@@ -5,8 +5,8 @@ Gem::Specification.new do |s|
   s.required_ruby_version     = Gem::Requirement.new(">= 1.8.6")
 
   s.name    = "nayutaya-wsse"
-  s.version = "0.0.0"
-  s.date    = "2009-10-27"
+  s.version = "0.0.1"
+  s.date    = "2009-10-29"
 
   s.authors = ["Yuya Kato"]
   s.email   = "yuyakato@gmail.com"
@@ -23,23 +23,20 @@ Gem::Specification.new do |s|
     "README",
     "Rakefile",
     "lib/wsse.rb",
+    "lib/wsse/authenticator.rb",
     "lib/wsse/core.rb",
-    "lib/wsse/http_header.rb",
-    "lib/wsse/username_token_builder.rb",
-    "lib/wsse/username_token_parser.rb",
+    "lib/wsse/username_token.rb",
     "lib/wsse/version.rb",
     "nayutaya-wsse.gemspec",
     "nayutaya-wsse.gemspec.erb",
     "test/test_helper.rb",
-    "test/wsse_http_header_test.rb",
-    "test/wsse_username_token_builder_test.rb",
-    "test/wsse_username_token_parser_test.rb",
+    "test/wsse_authenticator_test.rb",
+    "test/wsse_username_token_test.rb",
   ]
   s.test_files = [
     "test/test_helper.rb",
-    "test/wsse_http_header_test.rb",
-    "test/wsse_username_token_builder_test.rb",
-    "test/wsse_username_token_parser_test.rb",
+    "test/wsse_authenticator_test.rb",
+    "test/wsse_username_token_test.rb",
   ]
   s.extra_rdoc_files = []
 end

data/test/wsse_authenticator_test.rb

@@ -0,0 +1,32 @@
+# coding: utf-8
+
+require File.dirname(__FILE__) + "/test_helper"
+require "wsse/authenticator"
+
+class WsseAuthenticatorTest < Test::Unit::TestCase
+  def setup
+    @mod = Wsse::Authenticator
+  end
+
+  def test_authenticate__success
+    token = Wsse::UsernameToken.build("username", "password")
+    assert_equal(:success, @mod.authenticate(token, "username", "password"))
+  end
+
+  def test_authenticate__wrong_username
+    token = Wsse::UsernameToken.build("username", "password")
+    assert_equal(:wrong_username, @mod.authenticate(token, "foo", "password"))
+  end
+
+  def test_authenticate__wrong_password
+    token = Wsse::UsernameToken.build("username", "password")
+    assert_equal(:wrong_password, @mod.authenticate(token, "username", "baz"))
+  end
+
+  def test_authenticate_p
+    token = Wsse::UsernameToken.build("username", "password")
+    assert_equal(true,  @mod.authenticate?(token, "username", "password"))
+    assert_equal(false, @mod.authenticate?(token, "foo", "password"))
+    assert_equal(false, @mod.authenticate?(token, "username", "baz"))
+  end
+end

data/test/wsse_username_token_test.rb

@@ -0,0 +1,179 @@
+# coding: utf-8
+
+require File.dirname(__FILE__) + "/test_helper"
+require "wsse/username_token"
+
+class WsseUsernameTokenTest < Test::Unit::TestCase
+  def setup
+    @klass = Wsse::UsernameToken
+    @musha = Kagemusha.new(@klass)
+  end
+
+  def test_initialize_and_accessor
+    created = Time.utc(2000, 1, 1)
+    token = Wsse::UsernameToken.new("username", "digest", "nonce", created)
+    assert_equal("username", token.username)
+    assert_equal("digest",   token.digest)
+    assert_equal("nonce",    token.nonce)
+    assert_equal(created,    token.created)
+  end
+
+  def test_create_random_binary
+    srand(0)
+    assert_equal(20, @klass.create_random_binary(20).size)
+    assert_equal(30, @klass.create_random_binary(30).size)
+    assert_equal(10, 10.times.map { @klass.create_random_binary(20) }.uniq.size)
+  end
+
+  def test_create_password_digest
+    assert_equal(
+      Digest::SHA1.digest("nonce2000-01-01T00:00:00Zpassword"),
+      @klass.create_password_digest("password", "nonce", Time.utc(2000, 1, 1)))
+    assert_equal(
+      Digest::SHA1.digest("bar1999-12-31T23:59:59Zfoo"),
+      @klass.create_password_digest("foo", "bar", Time.utc(1999, 12, 31, 23, 59, 59)))
+  end
+
+  def test_build
+    created = Time.utc(2000, 1, 1)
+    digest  = @klass.create_password_digest("password", "nonce", created)
+    token = @klass.build("username", "password", "nonce", created)
+    assert_kind_of(@klass, token)
+    assert_equal("username", token.username)
+    assert_equal(digest,     token.digest)
+    assert_equal("nonce",    token.nonce)
+    assert_equal(created,    token.created)
+  end
+
+  def test_build__default_created
+    created = Time.utc(1999, 12, 31, 23, 59, 59)
+
+    token =
+      Kagemusha::DateTime.at(created) {
+        @klass.build("username", "password", "nonce")
+      }
+
+    assert_equal(created, token.created)
+  end
+
+  def test_build__default_nonce
+    nonce = "foo"
+
+    @musha.defs(:create_random_binary) { |size|
+      raise unless size == 20
+      nonce
+    }
+    token =
+      @musha.swap {
+        @klass.build("username", "password")
+      }
+
+    assert_equal(nonce, token.nonce)
+  end
+
+  def test_parse_token__1
+    # http://www.teria.com/~koseki/tools/wssegen/
+    # UserName: test, Password: test, Nonce: auto, Created: auto
+    token = %|UsernameToken Username="test", PasswordDigest="XYuMkeTAdwEwKhyU/4uw/pbvqrc=", Nonce="Mzg5ODU5MDExYTljODQ5Yg==", Created="2009-10-08T02:31:57Z"|
+    expected = {
+      "Username"       => "test",
+      "PasswordDigest" => "XYuMkeTAdwEwKhyU/4uw/pbvqrc=",
+      "Nonce"          => "Mzg5ODU5MDExYTljODQ5Yg==",
+      "Created"        => "2009-10-08T02:31:57Z",
+    }
+    assert_equal(expected, @klass.parse_token(token))
+  end
+
+  def test_parse_token__2
+    # http://d.hatena.ne.jp/keyword/%A4%CF%A4%C6%A4%CA%A5%D5%A5%A9%A5%C8%A5%E9%A5%A4%A5%D5AtomAPI
+    token = %|UsernameToken Username="hatena", PasswordDigest="ZCNaK2jrXr4+zsCaYK/YLUxImZU=", Nonce="Uh95NQlviNpJQR1MmML+zq6pFxE=", Created="2005-01-18T03:20:15Z"|
+    expected = {
+      "Username"       => "hatena",
+      "PasswordDigest" => "ZCNaK2jrXr4+zsCaYK/YLUxImZU=",
+      "Nonce"          => "Uh95NQlviNpJQR1MmML+zq6pFxE=",
+      "Created"        => "2005-01-18T03:20:15Z",
+    }
+    assert_equal(expected, @klass.parse_token(token))
+  end
+
+  def test_parse_token__3
+    # http://www.witha.jp/blog/archives/2004/06/_atom_api.html
+    token = %|UsernameToken Username="Melody", PasswordDigest="VfJavTaTy3BhKkeY/WVu9L6cdVA=", Created="2004-01-20T01:09:39Z", Nonce="7c19aeed85b93d35ba42e357f10ca19bf314d622"|
+    expected = {
+      "Username"       => "Melody",
+      "PasswordDigest" => "VfJavTaTy3BhKkeY/WVu9L6cdVA=",
+      "Nonce"          => "7c19aeed85b93d35ba42e357f10ca19bf314d622",
+      "Created"        => "2004-01-20T01:09:39Z",
+    }
+    assert_equal(expected, @klass.parse_token(token))
+  end
+
+  def test_parse_token__empty
+    assert_equal(nil, @klass.parse_token(nil))
+    assert_equal(nil, @klass.parse_token(""))
+  end
+
+  def test_parse_time
+    assert_equal(Time.utc(2000,  1,  1,  0,  0,  0), @klass.parse_time("2000-01-01T00:00:00Z"))
+    assert_equal(Time.utc(1999, 12, 31, 23, 59, 59), @klass.parse_time("1999-12-31T23:59:59Z"))
+    assert_equal(Time.utc(2001,  2,  3,  4,  5,  6), @klass.parse_time("2001-02-03T04:05:06Z"))
+  end
+
+  def test_parse_time__empty
+    assert_equal(nil, @klass.parse_time(nil))
+    assert_equal(nil, @klass.parse_time(""))
+  end
+
+  def test_parse__1
+    token = @klass.parse(%|UsernameToken Username="username", PasswordDigest="ZGlnZXN0", Nonce="bm9uY2U=", Created="2000-01-01T00:00:00Z"|)
+    assert_kind_of(@klass, token)
+    assert_equal("username", token.username)
+    assert_equal("digest",   token.digest)
+    assert_equal("nonce",    token.nonce)
+    assert_equal(Time.utc(2000, 1, 1), token.created)
+  end
+
+  def test_parse__2
+    token = @klass.parse(%|UsernameToken Username="foo", PasswordDigest="YmFy", Nonce="YmF6", Created="1999-12-31T23:59:59Z"|)
+    assert_kind_of(@klass, token)
+    assert_equal("foo", token.username)
+    assert_equal("bar", token.digest)
+    assert_equal("baz", token.nonce)
+    assert_equal(Time.utc(1999, 12, 31, 23, 59, 59), token.created)
+  end
+
+  def test_parse__3
+    assert_equal(nil, @klass.parse(%|UsernameToken PasswordDigest="ZGlnZXN0", Nonce="bm9uY2U=", Created="2000-01-01T00:00:00Z"|))
+    assert_equal(nil, @klass.parse(%|UsernameToken Username="username", Nonce="bm9uY2U=", Created="2000-01-01T00:00:00Z"|))
+    assert_equal(nil, @klass.parse(%|UsernameToken Username="username", PasswordDigest="ZGlnZXN0", Created="2000-01-01T00:00:00Z"|))
+    assert_equal(nil, @klass.parse(%|UsernameToken Username="username", PasswordDigest="ZGlnZXN0", Nonce="bm9uY2U="|))
+  end
+
+  def test_parse__empty
+    assert_equal(nil, @klass.parse(""))
+    assert_equal(nil, @klass.parse(nil))
+  end
+
+  def test_format_token_values
+    assert_equal(
+      %|UsernameToken Username="a", PasswordDigest="b", Nonce="c", Created="d"|,
+      @klass.format_token_values("a", "b", "c", "d"))
+  end
+
+  def test_base64encoded_digest
+    token = @klass.new("username", "digest", "nonce", Time.utc(2000, 1, 1))
+    assert_equal("ZGlnZXN0", token.base64encoded_digest)
+  end
+
+  def test_base64encoded_nonce
+    token = @klass.new("username", "digest", "nonce", Time.utc(2000, 1, 1))
+    assert_equal("bm9uY2U=", token.base64encoded_nonce)
+  end
+
+  def test_format
+    token = @klass.build("username", "password", "nonce", Time.utc(2000, 1, 1))
+    assert_equal(
+      %|UsernameToken Username="username", PasswordDigest="DzunnEf/2CKuhInsnmEHonW5qQs=", Nonce="bm9uY2U=", Created="2000-01-01T00:00:00Z"|,
+      token.format)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: nayutaya-wsse
 version: !ruby/object:Gem::Version 
-  version: 0.0.0
+  version: 0.0.1
 platform: ruby
 authors: 
 - Yuya Kato
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-27 00:00:00 +09:00
+date: 2009-10-29 00:00:00 +09:00
 default_executable: 
 dependencies: []
 
@@ -25,17 +25,15 @@ files:
 - README
 - Rakefile
 - lib/wsse.rb
+- lib/wsse/authenticator.rb
 - lib/wsse/core.rb
-- lib/wsse/http_header.rb
-- lib/wsse/username_token_builder.rb
-- lib/wsse/username_token_parser.rb
+- lib/wsse/username_token.rb
 - lib/wsse/version.rb
 - nayutaya-wsse.gemspec
 - nayutaya-wsse.gemspec.erb
 - test/test_helper.rb
-- test/wsse_http_header_test.rb
-- test/wsse_username_token_builder_test.rb
-- test/wsse_username_token_parser_test.rb
+- test/wsse_authenticator_test.rb
+- test/wsse_username_token_test.rb
 has_rdoc: true
 homepage: http://github.com/nayutaya/wsse/
 licenses: []
@@ -66,6 +64,5 @@ specification_version: 2
 summary: X-WSSE header builder and parser
 test_files: 
 - test/test_helper.rb
-- test/wsse_http_header_test.rb
-- test/wsse_username_token_builder_test.rb
-- test/wsse_username_token_parser_test.rb
+- test/wsse_authenticator_test.rb
+- test/wsse_username_token_test.rb

data/lib/wsse/http_header.rb

@@ -1 +0,0 @@
-# coding: utf-8

data/lib/wsse/username_token_builder.rb

@@ -1,42 +0,0 @@
-# coding: utf-8
-
-require "time"
-require "digest/sha1"
-
-module Wsse
-  module UsernameTokenBuilder
-    def self.create_created_time(time = Time.now)
-      return time.utc.iso8601
-    end
-
-    def self.create_nonce
-      return 20.times.map { rand(256) }.pack("C*")
-    end
-
-    def self.create_token_params(username, password, nonce = nil, created = nil)
-      nonce   ||= self.create_nonce
-      created ||= self.create_created_time
-      digest = Digest::SHA1.digest(nonce + created + password)
-      return {
-        "Username"       => username,
-        "PasswordDigest" => [digest].pack("m").chomp,
-        "Nonce"          => [nonce].pack("m").chomp,
-        "Created"        => created,
-      }
-    end
-
-    def self.format_token(params)
-      return format(
-        %|UsernameToken Username="%s", PasswordDigest="%s", Nonce="%s", Created="%s"|,
-        (params["Username"]       || raise(ArgumentError)),
-        (params["PasswordDigest"] || raise(ArgumentError)),
-        (params["Nonce"]          || raise(ArgumentError)),
-        (params["Created"]        || raise(ArgumentError)))
-    end
-
-    def self.create_token(username, password, nonce = nil, created = nil)
-      params = self.create_token_params(username, password, nonce, created)
-      return self.format_token(params)
-    end
-  end
-end

data/lib/wsse/username_token_parser.rb

@@ -1,24 +0,0 @@
-# coding: utf-8
-
-module Wsse
-  module UsernameTokenParser
-    def self.parse(value)
-      if /\AUsernameToken (.+?=".+?"(?:, .+?=".+?")*)\z/ =~ value.to_s
-        return $1.scan(/(?:\A|, )(.+?)="(.+?)"/).inject({}) { |memo, (key, value)|
-          memo[key] = value
-          memo
-        }
-      else
-        return nil
-      end
-    end
-
-    def self.parse_time(value)
-      if /\A(\d{4})-(\d\d)-(\d\d)T(\d\d):(\d\d):(\d\d)Z\z/ =~ value.to_s
-        return Time.utc(*($~.captures.map { |s| s.to_i }))
-      else
-        return nil
-      end
-    end
-  end
-end

data/test/wsse_http_header_test.rb

@@ -1,12 +0,0 @@
-# coding: utf-8
-
-require File.dirname(__FILE__) + "/test_helper"
-
-class WsseHttpHeaderTest < Test::Unit::TestCase
-  def setup
-  end
-
-  def test_true
-    assert true
-  end
-end

data/test/wsse_username_token_builder_test.rb

@@ -1,115 +0,0 @@
-# coding: utf-8
-
-require File.dirname(__FILE__) + "/test_helper"
-require "wsse/username_token_builder"
-
-class WsseUsernameTokenBuilderTest < Test::Unit::TestCase
-  def setup
-    @mod = Wsse::UsernameTokenBuilder
-    @musha = Kagemusha.new(@mod)
-  end
-
-  def test_create_created_time
-    assert_equal("2000-01-01T00:00:00Z", @mod.create_created_time(Time.utc(2000, 1, 1, 0, 0, 0)))
-    assert_equal("2001-12-31T23:59:59Z", @mod.create_created_time(Time.utc(2001, 12, 31, 23, 59, 59)))
-    Kagemusha::DateTime.at(Time.utc(2009, 1, 2, 3, 4, 5)) {
-      assert_equal("2009-01-02T03:04:05Z", @mod.create_created_time())
-    }
-  end
-
-  def test_create_nonce
-    srand(0)
-    assert_equal(20, @mod.create_nonce.size)
-    assert_equal(10, 10.times.map { @mod.create_nonce }.uniq.size)
-  end
-
-  def test_create_token_params
-    username = "username"
-    password = "password"
-    nonce    = "nonce"
-    created  = "2000-01-01T00:00:00Z"
-    expected = {
-      "Username"       => username,
-      "PasswordDigest" => [Digest::SHA1.digest("#{nonce}#{created}#{password}")].pack("m").chomp,
-      "Nonce"          => [nonce].pack("m").chomp,
-      "Created"        => created,
-    }
-    assert_equal(expected, @mod.create_token_params(username, password, nonce, created))
-  end
-
-  def test_create_token_params__default_created
-    username = "username1"
-    password = "password1"
-    nonce    = "nonce"
-    created  = "2001-02-03T04:05:06Z"
-    expected = {
-      "Username"       => username,
-      "PasswordDigest" => [Digest::SHA1.digest("#{nonce}#{created}#{password}")].pack("m").chomp,
-      "Nonce"          => [nonce].pack("m").chomp,
-      "Created"        => created,
-    }
-    @musha.defs(:create_created_time) { created }
-    @musha.swap {
-      assert_equal(expected, @mod.create_token_params(username, password, nonce))
-    }
-  end
-
-  def test_create_token_params__default_nonce
-    username = "username2"
-    password = "password2"
-    nonce    = "foobarbaz"
-    created  = "2001-02-03T04:05:06Z"
-    expected = {
-      "Username"       => username,
-      "PasswordDigest" => [Digest::SHA1.digest("#{nonce}#{created}#{password}")].pack("m").chomp,
-      "Nonce"          => [nonce].pack("m").chomp,
-      "Created"        => created,
-    }
-    @musha.defs(:create_nonce) { nonce }
-    @musha.defs(:create_created_time) { created }
-    @musha.swap {
-      assert_equal(expected, @mod.create_token_params(username, password))
-    }
-  end
-
-  def test_format_token
-    basic = {
-      "Username"       => "username",
-      "PasswordDigest" => "digest",
-      "Nonce"          => "nonce",
-      "Created"        => "created",
-    }
-    assert_equal(
-      %|UsernameToken Username="username", PasswordDigest="digest", Nonce="nonce", Created="created"|,
-      @mod.format_token(basic))
-    assert_raise(ArgumentError) { @mod.format_token(basic.merge("Username"       => nil)) }
-    assert_raise(ArgumentError) { @mod.format_token(basic.merge("PasswordDigest" => nil)) }
-    assert_raise(ArgumentError) { @mod.format_token(basic.merge("Nonce"          => nil)) }
-    assert_raise(ArgumentError) { @mod.format_token(basic.merge("Created"        => nil)) }
-  end
-
-  def test_create_token
-    assert_equal(
-      %|UsernameToken Username="username", PasswordDigest="DzunnEf/2CKuhInsnmEHonW5qQs=", Nonce="bm9uY2U=", Created="2000-01-01T00:00:00Z"|,
-      @mod.create_token("username", "password", "nonce", "2000-01-01T00:00:00Z"))
-  end
-
-  def test_create_token__default_created
-    @musha.defs(:create_created_time) { "2001-02-03T04:05:06Z" }
-    @musha.swap {
-      assert_equal(
-        %|UsernameToken Username="username1", PasswordDigest="lTTtMZC0IJyrV8aITFjLgdDzXzw=", Nonce="bm9uY2U=", Created="2001-02-03T04:05:06Z"|,
-        @mod.create_token("username1", "password1", "nonce"))
-    }
-  end
-
-  def test_create_token__default_nonce
-    @musha.defs(:create_nonce) { "foobarbaz" }
-    @musha.defs(:create_created_time) { "2001-02-03T04:05:06Z" }
-    @musha.swap {
-      assert_equal(
-        %|UsernameToken Username="username2", PasswordDigest="zmw1lW05c8tDlXsnU1IypUIt8uA=", Nonce="Zm9vYmFyYmF6", Created="2001-02-03T04:05:06Z"|,
-        @mod.create_token("username2", "password2"))
-    }
-  end
-end

data/test/wsse_username_token_parser_test.rb

@@ -1,66 +0,0 @@
-# coding: utf-8
-
-require File.dirname(__FILE__) + "/test_helper"
-require "wsse/username_token_parser"
-
-class WsseUsernameTokenParserTest < Test::Unit::TestCase
-  def setup
-    @mod = Wsse::UsernameTokenParser
-  end
-
-  def test_parse__1
-    # http://www.teria.com/~koseki/tools/wssegen/
-    # UserName: test, Password: test, Nonce: auto, Created: auto
-    value = %|UsernameToken Username="test", PasswordDigest="XYuMkeTAdwEwKhyU/4uw/pbvqrc=", Nonce="Mzg5ODU5MDExYTljODQ5Yg==", Created="2009-10-08T02:31:57Z"|
-    expected = {
-      "Username"       => "test",
-      "PasswordDigest" => "XYuMkeTAdwEwKhyU/4uw/pbvqrc=",
-      "Nonce"          => "Mzg5ODU5MDExYTljODQ5Yg==",
-      "Created"        => "2009-10-08T02:31:57Z",
-    }
-    assert_equal(expected, @mod.parse(value))
-  end
-
-  def test_parse__2
-    # http://d.hatena.ne.jp/keyword/%A4%CF%A4%C6%A4%CA%A5%D5%A5%A9%A5%C8%A5%E9%A5%A4%A5%D5AtomAPI
-    value = %|UsernameToken Username="hatena", PasswordDigest="ZCNaK2jrXr4+zsCaYK/YLUxImZU=", Nonce="Uh95NQlviNpJQR1MmML+zq6pFxE=", Created="2005-01-18T03:20:15Z"|
-    expected = {
-      "Username"       => "hatena",
-      "PasswordDigest" => "ZCNaK2jrXr4+zsCaYK/YLUxImZU=",
-      "Nonce"          => "Uh95NQlviNpJQR1MmML+zq6pFxE=",
-      "Created"        => "2005-01-18T03:20:15Z",
-    }
-    assert_equal(expected, @mod.parse(value))
-  end
-
-  def test_parse__3
-    # http://www.witha.jp/blog/archives/2004/06/_atom_api.html
-    value = %|UsernameToken Username="Melody", PasswordDigest="VfJavTaTy3BhKkeY/WVu9L6cdVA=", Created="2004-01-20T01:09:39Z", Nonce="7c19aeed85b93d35ba42e357f10ca19bf314d622"|
-    expected = {
-      "Username"       => "Melody",
-      "PasswordDigest" => "VfJavTaTy3BhKkeY/WVu9L6cdVA=",
-      "Nonce"          => "7c19aeed85b93d35ba42e357f10ca19bf314d622",
-      "Created"        => "2004-01-20T01:09:39Z",
-    }
-    assert_equal(expected, @mod.parse(value))
-  end
-
-  def test_parse__nil
-    assert_equal(nil, @mod.parse(nil))
-  end
-
-  def test_parse__empty
-    assert_equal(nil, @mod.parse(""))
-  end
-
-  def test_parse_time
-    assert_equal(Time.utc(2009,  1,  1,  0,  0,  0), @mod.parse_time("2009-01-01T00:00:00Z"))
-    assert_equal(Time.utc(2009, 12, 31, 23, 59, 59), @mod.parse_time("2009-12-31T23:59:59Z"))
-    assert_equal(Time.utc(2001,  2,  3,  4,  5,  6), @mod.parse_time("2001-02-03T04:05:06Z"))
-  end
-
-  def test_parse_time__empty
-    assert_equal(nil, @mod.parse_time(nil))
-    assert_equal(nil, @mod.parse_time(""))
-  end
-end