multi_auth 0.0.1

data/test/unit/email_login_form_test.rb

@@ -0,0 +1,76 @@
+
+require 'test_helper'
+
+class EmailLoginFormTest < ActiveSupport::TestCase
+  def setup
+    @klass = EmailLoginForm
+    @form  = @klass.new
+    @basic = @klass.new(
+      :email    => "email@example.jp",
+      :password => "password")
+  end
+
+  #
+  # 基底クラス
+  #
+
+  test "superclass" do
+    assert_equal(ActiveForm, @klass.superclass)
+  end
+
+  #
+  # カラム
+  #
+
+  test "columns" do
+    [
+      [:email,    nil, "str", "str"],
+      [:password, nil, "str", "str"],
+    ].each { |name, default, set_value, get_value|
+      form = @klass.new
+      assert_equal(default, form.__send__(name))
+      form.__send__("#{name}=", set_value)
+      assert_equal(get_value, form.__send__(name))
+    }
+  end
+
+  #
+  # 検証
+  #
+
+  test "basic is valid" do
+    assert_equal(true, @basic.valid?)
+  end
+
+  test "validates_presence_of :email" do
+    @basic.email = nil
+    assert_equal(false, @basic.valid?)
+  end
+
+  test "validates_presence_of :password" do
+    @basic.password = nil
+    assert_equal(false, @basic.valid?)
+  end
+
+  #
+  # インスタンスメソッド
+  #
+
+  test "authenticate, success" do
+    @form.email    = email_credentials(:yuya_gmail).email
+    @form.password = "yuya_gmail"
+    assert_equal(
+      email_credentials(:yuya_gmail),
+      @form.authenticate)
+  end
+
+  test "authenticate, not activated" do
+    @form.email    = email_credentials(:yuya_nayutaya).email
+    @form.password = "yuya_nayutaya"
+    assert_equal(nil, @form.authenticate)
+  end
+
+  test "authenticate, empty" do
+    assert_equal(nil, @form.authenticate)
+  end
+end

data/test/unit/email_password_edit_form_test.rb

@@ -0,0 +1,117 @@
+
+require 'test_helper'
+
+class EmailPasswordEditFormTest < ActiveSupport::TestCase
+  def setup
+    @klass = EmailPasswordEditForm
+    @form  = @klass.new
+    @basic = @klass.new(
+      :password              => "password",
+      :password_confirmation => "password")
+  end
+
+  #
+  # 基底クラス
+  #
+
+  test "superclass" do
+    assert_equal(ActiveForm, @klass.superclass)
+  end
+
+  #
+  # カラム
+  #
+
+  test "columns" do
+    [
+      [:password,              nil, "1", "1"],
+      [:password_confirmation, nil, "1", "1"],
+    ].each { |name, default, set_value, get_value|
+      form = @klass.new
+      assert_equal(default, form.__send__(name), name)
+      form.__send__("#{name}=", set_value)
+      assert_equal(get_value, form.__send__(name), name)
+    }
+  end
+
+  #
+  # 検証
+  #
+
+  test "basic is valid" do
+    assert_equal(true, @basic.valid?)
+  end
+
+  test "validates_presence_of :password" do
+    @basic.password = nil
+    assert_equal(false, @basic.valid?)
+  end
+
+  test "validates_presence_of :password_confirmation" do
+    @basic.password_confirmation = nil
+    assert_equal(false, @basic.valid?)
+  end
+
+  test "validates_length_of :password" do
+    [
+      ["a" *  3, false],
+      ["a" *  4, true ],
+      ["a" * 20, true ],
+      ["a" * 21, false],
+    ].each { |value, expected|
+      @basic.password              = value
+      @basic.password_confirmation = value
+      assert_equal(expected, @basic.valid?, value)
+    }
+  end
+
+  test "validates_format_of :password" do
+    valid_chars = (0x21..0x7E).map { |c| c.chr }.join
+
+    [
+      [valid_chars.slice!(0, 20), true ],
+      [valid_chars.slice!(0, 20), true ],
+      [valid_chars.slice!(0, 20), true ],
+      [valid_chars.slice!(0, 20), true ],
+      [valid_chars.slice!(0, 20), true ],
+      ["aaaa",   true ],
+      ["aaa ",   false],
+      ["日本語", false],
+    ].each { |value, expected|
+      @basic.password              = value
+      @basic.password_confirmation = value
+      assert_equal(expected, @basic.valid?, value)
+    }
+
+    assert_equal(true, valid_chars.empty?)
+  end
+
+  test "validates_each, password" do
+    @basic.password              = "aaaa"
+    @basic.password_confirmation = "aaaa"
+    assert_equal(true, @basic.valid?)
+
+    @basic.password              = "aaaa"
+    @basic.password_confirmation = "AAAA"
+    assert_equal(false, @basic.valid?)
+  end
+
+  #
+  # インスタンスメソッド
+  #
+
+  test "to_email_credential_hash, empty" do
+    hash = @form.to_email_credential_hash
+    assert_equal([:hashed_password], hash.keys)
+    assert_equal(true, EmailCredential.compare_hashed_password("", hash[:hashed_password]))
+  end
+
+  test "to_email_credential_hash, full" do
+    @form.attributes = {
+      :password => "foo",
+    }
+    hash = @form.to_email_credential_hash
+    assert_equal([:hashed_password], hash.keys)
+    assert_equal(true, EmailCredential.compare_hashed_password(@form.password, hash[:hashed_password]))
+  end
+end

data/test/unit/helpers/auth_helper_test.rb

@@ -0,0 +1,4 @@
+require 'test_helper'
+
+class AuthHelperTest < ActionView::TestCase
+end

data/test/unit/helpers/credentials/email_helper_test.rb

@@ -0,0 +1,4 @@
+require 'test_helper'
+
+class Credentials::EmailHelperTest < ActionView::TestCase
+end

data/test/unit/helpers/credentials/open_id_helper_test.rb

@@ -0,0 +1,4 @@
+require 'test_helper'
+
+class Credentials::OpenIdHelperTest < ActionView::TestCase
+end

data/test/unit/helpers/credentials_helper_test.rb

@@ -0,0 +1,4 @@
+require 'test_helper'
+
+class CredentialsHelperTest < ActionView::TestCase
+end

data/test/unit/helpers/email_auth_helper_test.rb

@@ -0,0 +1,4 @@
+require 'test_helper'
+
+class EmailAuthHelperTest < ActionView::TestCase
+end

data/test/unit/helpers/email_signup_helper_test.rb

@@ -0,0 +1,4 @@
+require 'test_helper'
+
+class EmailSignupHelperTest < ActionView::TestCase
+end

data/test/unit/helpers/open_id_auth_helper_test.rb

@@ -0,0 +1,4 @@
+require 'test_helper'
+
+class OpenIdAuthHelperTest < ActionView::TestCase
+end

data/test/unit/helpers/open_id_signup_helper_test.rb

@@ -0,0 +1,4 @@
+require 'test_helper'
+
+class OpenIdSignupHelperTest < ActionView::TestCase
+end

data/test/unit/helpers/password_auth_helper_test.rb

@@ -0,0 +1,4 @@
+require 'test_helper'
+
+class PasswordAuthHelperTest < ActionView::TestCase
+end

data/test/unit/helpers/password_signup_helper_test.rb

@@ -0,0 +1,4 @@
+require 'test_helper'
+
+class PasswordSignupHelperTest < ActionView::TestCase
+end

data/test/unit/helpers/signup_helper_test.rb

@@ -0,0 +1,4 @@
+require 'test_helper'
+
+class SignupHelperTest < ActionView::TestCase
+end

data/test/unit/notice_formatter_test.rb

@@ -0,0 +1,153 @@
+# -*- coding: utf-8 -*-
+
+require 'test_helper'
+
+class NoticeFormatterTest < ActiveSupport::TestCase
+  def setup
+    @module = NoticeFormatter
+  end
+
+  test "replace_keywords, empty" do
+    assert_equal("", @module.replace_keywords("", {}))
+  end
+
+  test "replace_keywords" do
+    assert_equal(
+      "A",
+      @module.replace_keywords("{a}", "a" => "A"))
+    assert_equal(
+      "A,B",
+      @module.replace_keywords("{a},{b}", "a" => "A", "b" => "B"))
+    assert_equal(
+      "A,B,A,B",
+      @module.replace_keywords("{a},{b},{a},{b}", "a" => "A", "b" => "B"))
+  end
+
+  test "add_namespace" do
+    expected = {
+      "name:a" => "b",
+      "name:c" => "d",
+    }
+    assert_equal(expected, @module.add_namespace("name", {"a" => "b", "c" => "d"}))
+  end
+
+  test "format_integer_value" do
+    assert_equal("1", @module.format_integer_value(1))
+    assert_equal("-", @module.format_integer_value(nil))
+  end
+
+  test "format_integer_json_value" do
+    assert_equal("1", @module.format_integer_json_value(1))
+    assert_equal("null", @module.format_integer_json_value(nil))
+  end
+
+  test "format_string_value" do
+    assert_equal("a", @module.format_string_value("a"))
+    assert_equal("あ", @module.format_string_value("あ"))
+    assert_equal("-", @module.format_string_value(""))
+    assert_equal("-", @module.format_string_value(nil))
+  end
+
+  test "format_string_json_value" do
+    assert_equal('"a"', @module.format_string_json_value("a"))
+    assert_equal('"\\u3042"', @module.format_string_json_value("あ"))
+    assert_equal("null", @module.format_string_json_value(""))
+    assert_equal("null", @module.format_string_json_value(nil))
+  end
+
+  test "format_part_of_date" do
+    expected = {
+      "date"      => "2009-01-02",
+      "date:json" => '"2009-01-02"',
+      "date:ja"   => "2009年01月02日",
+      "yyyy"      => "2009",
+      "mm"        => "01",
+      "dd"        => "02",
+    }
+    assert_equal(expected, @module.format_part_of_date(Date.new(2009, 1, 2)))
+  end
+
+  test "format_part_of_date, nil" do
+    expected = {
+      "date"      => "-",
+      "date:json" => "null",
+      "date:ja"   => "-",
+      "yyyy"      => "-",
+      "mm"        => "-",
+      "dd"        => "-",
+    }
+    assert_equal(expected, @module.format_part_of_date(nil))
+  end
+
+  test "format_part_of_time" do
+    expected = {
+      "time"      => "01:02:03",
+      "time:json" => '"01:02:03"',
+      "time:ja"   => "01時02分03秒",
+      "hh"        => "01",
+      "nn"        => "02",
+      "ss"        => "03",
+    }
+    assert_equal(expected, @module.format_part_of_time(Time.local(2009, 12, 31, 1, 2, 3)))
+  end
+
+  test "format_part_of_time, nil" do
+    expected = {
+      "time"      => "-",
+      "time:json" => "null",
+      "time:ja"   => "-",
+      "hh"        => "-",
+      "nn"        => "-",
+      "ss"        => "-",
+    }
+    assert_equal(expected, @module.format_part_of_time(nil))
+  end
+
+  test "format_part_of_datetime" do
+    datetime = Time.local(2009, 12, 31, 12, 34, 56)
+    expected = {
+      "datetime"      => "2009-12-31 12:34:56",
+      "datetime:json" => '"2009-12-31 12:34:56"',
+      "datetime:ja"   => "2009年12月31日 12時34分56秒",
+    }
+    expected.merge!(@module.format_part_of_date(datetime))
+    expected.merge!(@module.format_part_of_time(datetime))
+    assert_equal(expected, @module.format_part_of_datetime(datetime))
+  end
+
+  test "format_part_of_datetime, nil" do
+    expected = {
+      "datetime"      => "-",
+      "datetime:json" => "null",
+      "datetime:ja"   => "-",
+    }
+    expected.merge!(@module.format_part_of_date(nil))
+    expected.merge!(@module.format_part_of_time(nil))
+    assert_equal(expected, @module.format_part_of_datetime(nil))
+  end
+
+  test "format_part_of_user" do
+    expected = {
+      "user:token"         => "0" * User::TokenLength,
+      "user:token:json"    => '"' + "0" * User::TokenLength + '"',
+      "user:nickname"      => "nickname",
+      "user:nickname:json" => '"nickname"',
+    }
+    user = User.new(
+      :user_token => "0" * User::TokenLength,
+      :nickname   => "nickname")
+    assert_equal(expected, @module.format_part_of_user(user))
+  end
+
+  test "format_part_of_user, nil" do
+    expected = {
+      "user:token"         => "-",
+      "user:token:json"    => "null",
+      "user:nickname"      => "-",
+      "user:nickname:json" => "null",
+    }
+    assert_equal(expected, @module.format_part_of_user(User.new))
+    assert_equal(expected, @module.format_part_of_user(nil))
+  end
+
+end

data/test/unit/open_id_credential_test.rb

@@ -0,0 +1,108 @@
+# -*- coding: utf-8 -*-
+
+require 'test_helper'
+
+class OpenIdCredentialTest < ActiveSupport::TestCase
+  def setup
+    @klass = OpenIdCredential
+    @basic = @klass.new(
+      :user_id      => users(:yuya).id,
+      :identity_url => "http://example.jp/identity_url")
+
+    @yuya_livedoor  = open_id_credentials(:yuya_livedoor)
+    @shinya_example = open_id_credentials(:shinya_example)
+  end
+
+  #
+  # 関連
+  #
+
+  test "belongs_to :user" do
+    assert_equal(
+      users(:yuya),
+      @yuya_livedoor.user)
+
+    assert_equal(
+      users(:shinya),
+      @shinya_example.user)
+  end
+
+  #
+  # 検証
+  #
+
+  test "all fixtures are valid" do
+    assert_equal(true, @klass.all.all?(&:valid?))
+  end
+
+  test "basic is valid" do
+    assert_equal(true, @basic.valid?)
+  end
+
+  test "validates_presence_of :identity_url" do
+    @basic.identity_url = nil
+    assert_equal(false, @basic.valid?)
+    assert_equal(true, @basic.errors.invalid?(:identity_url))
+  end
+
+  test "validates_length_of :identity_url" do
+    @basic.identity_url = "http://example.com/" + "a" * 182
+    assert_equal(201, @basic.identity_url.size)
+
+    assert_equal(false, @basic.valid?)
+    assert_equal(true, @basic.errors.invalid?(:identity_url))
+  end
+
+  test "validates_format_of :identity_url" do
+    [
+     ["http://example.com/foo",  true,  false],
+     ["https://example.com/foo", true,  false],
+     ["ftp://example.com/foo",   false, true ],
+     ["HTTP://EXAMPLE.COM/foo",  false, true ],
+    ].each{|value, expected1, expected2|
+      @basic.identity_url = value
+      assert_equal(expected1, @basic.valid?)
+      assert_equal(expected2, @basic.errors.invalid?(:identity_url))
+    }
+  end
+
+  test "validates_uniqueness_of :identity_url, on create" do
+    @basic.identity_url = @yuya_livedoor.identity_url
+    assert_equal(false, @basic.valid?)
+  end
+
+  test "validates_uniqueness_of :identity_url, on update" do
+    @yuya_livedoor.identity_url = @shinya_example.identity_url
+    assert_equal(false, @yuya_livedoor.valid?)
+  end
+
+  test "validates_each :user_id" do
+    srand(0)
+    user = users(:yuya)
+    create_record = proc {
+      user.open_id_credentials.create!(
+        :identity_url => "http://example.jp/identity_url#{rand(1000)}")
+    }
+
+    assert_nothing_raised {
+      (10 - user.open_id_credentials.size).times {
+        record = create_record[]
+        record.save!
+      }
+    }
+    assert_raise(ActiveRecord::RecordInvalid) {
+      create_record[]
+    }
+  end
+
+  #
+  # インスタンスメソッド
+  #
+
+  test "login!" do
+    time = Time.local(2010, 1, 1)
+    assert_equal(nil, @shinya_example.loggedin_at)
+    Kagemusha::DateTime.at(time) { @shinya_example.login! }
+    assert_equal(time, @shinya_example.reload.loggedin_at)
+  end
+end

data/test/unit/open_id_login_form_test.rb

@@ -0,0 +1,57 @@
+
+require 'test_helper'
+
+class OpenIdLoginFormTest < ActiveSupport::TestCase
+  def setup
+    @klass = OpenIdLoginForm
+    @basic = @klass.new(
+      :openid_url => "example.jp")
+  end
+
+  #
+  # 基底クラス
+  #
+
+  test "superclass" do
+    assert_equal(ActiveForm, @klass.superclass)
+  end
+
+  #
+  # カラム
+  #
+
+  test "columns" do
+    [
+      [:openid_url, nil, "1", "1"],
+    ].each { |name, default, set_value, get_value|
+      form = @klass.new
+      assert_equal(default, form.__send__(name), name)
+      form.__send__("#{name}=", set_value)
+      assert_equal(get_value, form.__send__(name), name)
+    }
+  end
+
+  #
+  # 検証
+  #
+
+  test "basic is valid" do
+    assert_equal(true, @basic.valid?)
+  end
+
+  test "validates_presence_of :openid_url" do
+    @basic.openid_url = nil
+    assert_equal(false, @basic.valid?)
+  end
+
+  test "validates_length_of :openid_url" do
+    [
+      ["a" *   1, true ],
+      ["a" * 200, true ],
+      ["a" * 201, false],
+    ].each { |value, expected|
+      @basic.openid_url = value
+      assert_equal(expected, @basic.valid?, value)
+    }
+  end
+end

data/test/unit/session_test.rb

@@ -0,0 +1,53 @@
+
+require 'test_helper'
+
+class SessionTest < ActiveSupport::TestCase
+  def setup
+    @klass  = Session
+    @record = @klass.new
+  end
+
+  #
+  # クラスメソッド
+  #
+
+  test "self.cleanup, 1 hour" do
+    session_a = create_empty_session(Time.local(2009, 1, 1, 11, 59, 59), "a")
+    session_b = create_empty_session(Time.local(2009, 1, 1, 12,  0,  0), "b")
+    session_c = create_empty_session(Time.local(2009, 1, 1, 12,  0,  1), "c")
+
+    assert_difference("Session.count", -1) {
+      Kagemusha::DateTime.at(2009, 1, 1, 13, 0, 0) {
+        assert_equal(nil, @klass.cleanup(1.hour))
+      }
+    }
+
+    assert_nil(@klass.find_by_id(session_a.id))
+    assert_not_nil(@klass.find_by_id(session_b.id))
+    assert_not_nil(@klass.find_by_id(session_c.id))
+  end
+
+  test "self.cleanup, 2 hours" do
+    session_a = create_empty_session(Time.local(2009, 12, 31, 0, 30, 29), "a")
+    session_b = create_empty_session(Time.local(2009, 12, 31, 0, 30, 30), "b")
+    session_c = create_empty_session(Time.local(2009, 12, 31, 0, 30, 31), "c")
+
+    assert_difference("Session.count", -1) {
+      Kagemusha::DateTime.at(2009, 12, 31, 2, 30, 30) {
+        assert_equal(nil, @klass.cleanup(2.hours))
+      }
+    }
+
+    assert_nil(@klass.find_by_id(session_a.id))
+    assert_not_nil(@klass.find_by_id(session_b.id))
+    assert_not_nil(@klass.find_by_id(session_c.id))
+  end
+
+  private
+
+  def create_empty_session(time, key)
+    return Kagemusha::DateTime.at(time) {
+      Session.create!(:session_id => key, :data => "")
+    }
+  end
+end

data/test/unit/token_util_test.rb

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+
+require 'test_helper'
+
+class TokenUtilTest < ActiveSupport::TestCase
+  def setup
+    @mod = TokenUtil
+  end
+
+  test "create_token" do
+    assert_match(/\A[0-9a-f]{10}\z/, @mod.create_token(10))
+    assert_match(/\A[0-9a-f]{20}\z/, @mod.create_token(20))
+    assert_match(/\A[0-9a-f]{30}\z/, @mod.create_token(30))
+
+    srand(0)
+    assert_not_equal(
+      @mod.create_token(20),
+      @mod.create_token(20))
+  end
+
+  test "create_unique_token" do
+    assert_match(/\A[0-9a-f]{10}\z/, @mod.create_unique_token(User, :user_token, 10))
+    assert_match(/\A[0-9a-f]{20}\z/, @mod.create_unique_token(User, :user_token, 20))
+    assert_match(/\A[0-9a-f]{30}\z/, @mod.create_unique_token(User, :user_token, 30))
+
+    srand(0)
+    assert_not_equal(
+      @mod.create_unique_token(User, :user_token, 20),
+      @mod.create_unique_token(User, :user_token, 20))
+  end
+
+  test "create_unique_token, conflict" do
+    [
+     [User,   :user_token],
+    ].each { |klass, column|
+      exist_token  = klass.first[column]
+      unique_token = "0" * exist_token.size
+      assert_equal(true,  klass.exists?(column => exist_token))
+      assert_equal(false, klass.exists?(column => unique_token))
+
+      tokens = [exist_token, unique_token]
+      musha = Kagemusha.new(@mod)
+      musha.defs(:create_token) { tokens.shift }
+      musha.swap {
+        assert_equal(
+          unique_token,
+          @mod.create_unique_token(klass, column, exist_token.size))
+      }
+    }
+  end
+end