okkez-multi_auth 0.0.1

data/test/unit/activation_mailer_test.rb

@@ -0,0 +1,181 @@
+# -*- coding: utf-8 -*-
+
+require 'test_helper'
+
+class ActivationMailerTest < ActionMailer::TestCase
+  def setup
+    @klass = ActivationMailer
+  end
+
+  #
+  # クラスメソッド
+  #
+
+  test "self.create_request_for_signup_params" do
+    options = {
+      :recipients     => "recipients@example.jp",
+      :activation_url => "http://activation/url",
+    }
+    expected = {
+      :subject    => "[#{MultiAuth.application_name}] ユーザ登録",
+      :from       => @klass::FromAddress,
+      :recipients => "recipients@example.jp",
+      :body       => {:activation_url => "http://activation/url"},
+    }
+    assert_equal(expected, @klass.create_request_for_signup_params(options))
+  end
+
+  test "self.create_request_for_signup_params, invalid parameter" do
+    options = {:recipients => "", :activation_url => ""}
+    assert_nothing_raised       { @klass.create_request_for_signup_params(options) }
+    assert_raise(ArgumentError) { @klass.create_request_for_signup_params(options.merge(:recipients => nil)) }
+    assert_raise(ArgumentError) { @klass.create_request_for_signup_params(options.merge(:activation_url => nil)) }
+    assert_raise(ArgumentError) { @klass.create_request_for_signup_params(options.merge(:invalid => true)) }
+  end
+
+  test "self.create_complete_for_signup_params" do
+    options = {
+      :recipients => "recipients@example.jp",
+    }
+    expected = {
+      :subject    => "[#{MultiAuth.application_name}] ユーザ登録完了",
+      :from       => @klass::FromAddress,
+      :recipients => "recipients@example.jp",
+      :body       => {},
+    }
+    assert_equal(expected, @klass.create_complete_for_signup_params(options))
+  end
+
+  test "self.create_complete_for_signup_params, invalid parameter" do
+    options = {:recipients => ""}
+    assert_nothing_raised       { @klass.create_complete_for_signup_params(options) }
+    assert_raise(ArgumentError) { @klass.create_complete_for_signup_params(options.merge(:recipients => nil)) }
+    assert_raise(ArgumentError) { @klass.create_complete_for_signup_params(options.merge(:invalid => true)) }
+  end
+
+  test "self.create_request_for_credential_params" do
+    options = {
+      :recipients     => "recipients@example.jp",
+      :activation_url => "http://activation/url",
+    }
+    expected = {
+      :subject    => "[#{MultiAuth.application_name}] メールアドレス認証登録",
+      :from       => @klass::FromAddress,
+      :recipients => "recipients@example.jp",
+      :body       => {:activation_url => "http://activation/url"},
+    }
+    assert_equal(expected, @klass.create_request_for_credential_params(options))
+  end
+
+  test "self.create_request_for_credential_params, invalid parameter" do
+    options = {:recipients => "", :activation_url => ""}
+    assert_nothing_raised       { @klass.create_request_for_credential_params(options) }
+    assert_raise(ArgumentError) { @klass.create_request_for_credential_params(options.merge(:recipients => nil)) }
+    assert_raise(ArgumentError) { @klass.create_request_for_credential_params(options.merge(:activation_url => nil)) }
+    assert_raise(ArgumentError) { @klass.create_request_for_credential_params(options.merge(:invalid => true)) }
+  end
+
+  test "self.create_complete_for_credential_params" do
+    options = {
+      :recipients => "recipients@example.jp",
+    }
+    expected = {
+      :subject    => "[#{MultiAuth.application_name}] メールアドレス認証登録完了",
+      :from       => @klass::FromAddress,
+      :recipients => "recipients@example.jp",
+      :body       => {},
+    }
+    assert_equal(expected, @klass.create_complete_for_credential_params(options))
+  end
+
+  test "self.create_complete_for_credential_params, invalid parameter" do
+    options = {:recipients => ""}
+    assert_nothing_raised       { @klass.create_complete_for_credential_params(options) }
+    assert_raise(ArgumentError) { @klass.create_complete_for_credential_params(options.merge(:recipients => nil)) }
+    assert_raise(ArgumentError) { @klass.create_complete_for_credential_params(options.merge(:invalid => true)) }
+  end
+
+  test "self.create_request_for_notice_params" do
+    options = {
+      :recipients     => "recipients@example.jp",
+      :activation_url => "http://activation/url",
+    }
+    expected = {
+      :subject    => "[#{MultiAuth.application_name}] 通知先メールアドレス登録",
+      :from       => @klass::FromAddress,
+      :recipients => "recipients@example.jp",
+      :body       => {:activation_url => "http://activation/url"},
+    }
+    assert_equal(expected, @klass.create_request_for_notice_params(options))
+  end
+
+  test "self.create_request_for_notice_params, invalid parameter" do
+    options = {:recipients => "", :activation_url => ""}
+    assert_nothing_raised       { @klass.create_request_for_notice_params(options) }
+    assert_raise(ArgumentError) { @klass.create_request_for_notice_params(options.merge(:recipients => nil)) }
+    assert_raise(ArgumentError) { @klass.create_request_for_notice_params(options.merge(:activation_url => nil)) }
+    assert_raise(ArgumentError) { @klass.create_request_for_notice_params(options.merge(:invalid => true)) }
+  end
+
+  test "self.create_complete_for_notice_params" do
+    options = {
+      :recipients => "recipients@example.jp",
+    }
+    expected = {
+      :subject    => "[#{MultiAuth.application_name}] 通知先メールアドレス登録完了",
+      :from       => @klass::FromAddress,
+      :recipients => "recipients@example.jp",
+      :body       => {},
+    }
+    assert_equal(expected, @klass.create_complete_for_notice_params(options))
+  end
+
+  test "self.create_complete_for_notice_params, invalid parameter" do
+    options = {:recipients => ""}
+    assert_nothing_raised       { @klass.create_complete_for_notice_params(options) }
+    assert_raise(ArgumentError) { @klass.create_complete_for_notice_params(options.merge(:recipients => nil)) }
+    assert_raise(ArgumentError) { @klass.create_complete_for_notice_params(options.merge(:invalid => true)) }
+  end
+
+  #
+  # インスタンスメソッド
+  #
+
+  test "request_for_signup" do
+    options = {
+      :recipients     => email_credentials(:yuya_nayutaya).email,
+      :activation_url => "http://activation/url/" + email_credentials(:yuya_nayutaya).activation_token,
+    }
+    assert_nothing_raised {
+      @klass.create_request_for_signup(options).encoded
+    }
+  end
+
+  test "complete_for_signup" do
+    options = {
+      :recipients => email_credentials(:yuya_nayutaya).email,
+    }
+    assert_nothing_raised {
+      @klass.create_complete_for_signup(options).encoded
+    }
+  end
+
+  test "request_for_credential" do
+    options = {
+      :recipients     => email_credentials(:yuya_nayutaya).email,
+      :activation_url => "http://activation/url/" + email_credentials(:yuya_nayutaya).activation_token,
+    }
+    assert_nothing_raised {
+      @klass.create_request_for_credential(options).encoded
+    }
+  end
+
+  test "complete_for_credential" do
+    options = {
+      :recipients => email_credentials(:yuya_nayutaya).email,
+    }
+    assert_nothing_raised {
+      @klass.create_complete_for_credential(options).encoded
+    }
+  end
+end

data/test/unit/email_credential_edit_form_test.rb

@@ -0,0 +1,173 @@
+# -*- coding: utf-8 -*-
+
+require 'test_helper'
+
+class EmailCredentialEditFormTest < ActiveSupport::TestCase
+  def setup
+    @klass = EmailCredentialEditForm
+    @form  = @klass.new
+    @basic = @klass.new(
+      :email                 => "email@example.jp",
+      :password              => "password",
+      :password_confirmation => "password")
+  end
+
+  #
+  # 基底クラス
+  #
+
+  test "superclass" do
+    assert_equal(ActiveForm, @klass.superclass)
+  end
+
+  #
+  # カラム
+  #
+
+  test "columns" do
+    [
+      [:email,                 nil, "str", "str"],
+      [:password,              nil, "str", "str"],
+      [:password_confirmation, 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 "validates_presence_of :password_confirmation" do
+    @basic.password_confirmation = nil
+    assert_equal(false, @basic.valid?)
+  end
+
+  test "validates_length_of :email" do
+    # MEMO: 下記の制約を満たしつつ、文字列長の検証のテストを行う
+    #       * ローカルパートは64文字以内
+    #       * ドメインパートは255文字以内
+    #       * ドメインパートのドットで区切られたパートは63文字以内
+
+    [
+      ["a@b.cd.ef.com", 13, true ],
+      [["a" * 64 + "@" + "b" * 63, "c" * 63, "d" * 3, "com"].join("."), 200, true ],
+      [["a" * 64 + "@" + "b" * 63, "c" * 63, "d" * 4, "com"].join("."), 201, false],
+    ].each { |value, length, expected|
+      assert_equal(length, value.size)
+      @basic.email = value
+      assert_equal(expected, @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?)
+    }
+  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?)
+    }
+
+    assert_equal(true, valid_chars.empty?)
+  end
+
+  test "validates_email_format_of :email" do
+    [
+      ["foo@example.com",   true ],
+      ["foo@example.co.jp", true ],
+      ["foo@example",       false],
+    ].each { |value, expected|
+      @basic.email = value
+      assert_equal(
+        {:in => value, :out => expected},
+        {:in => value, :out => @basic.valid?})
+    }
+  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 "masked_password" do
+    @form.password = nil
+    assert_equal("", @form.masked_password)
+
+    @form.password = "a"
+    assert_equal("*", @form.masked_password)
+
+    @form.password = "abc"
+    assert_equal("***", @form.masked_password)
+  end
+
+  test "to_email_credential_hash, empty" do
+    hash = @form.to_email_credential_hash
+    assert_equal(
+      [:email, :hashed_password].map(&:to_s).sort,
+      hash.keys.map(&:to_s).sort)
+    assert_equal(nil, hash[:email])
+    assert_equal(true, EmailCredential.compare_hashed_password("", hash[:hashed_password]))
+  end
+
+  test "to_email_credential_hash, full" do
+    @form.attributes = {
+      :email    => "foo@example.com",
+      :password => "foo",
+    }
+    hash = @form.to_email_credential_hash
+    assert_equal(
+      [:email, :hashed_password].map(&:to_s).sort,
+      hash.keys.map(&:to_s).sort)
+    assert_equal(@form.email, hash[:email])
+    assert_equal(true, EmailCredential.compare_hashed_password(@form.password, hash[:hashed_password]))
+  end
+end

data/test/unit/email_credential_test.rb

@@ -0,0 +1,324 @@
+# -*- coding: utf-8 -*-
+
+require 'test_helper'
+
+class EmailCredentialTest < ActiveSupport::TestCase
+  def setup
+    @klass = EmailCredential
+    @basic = @klass.new(
+      :activation_token => "0" * @klass::TokenLength,
+      :user_id          => users(:yuya).id,
+      :email            => "foo@example.com",
+      :hashed_password  => ("0" * 8) + ":" + ("0" * 64))
+
+    @yuya_gmail   = email_credentials(:yuya_gmail)
+    @risa_example = email_credentials(:risa_example)
+  end
+
+  #
+  # 関連
+  #
+
+  test "belongs_to :user" do
+    assert_equal(
+      users(:yuya),
+      @yuya_gmail.user)
+
+    assert_equal(
+      users(:risa),
+      @risa_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 :email" do
+    @basic.email = nil
+    assert_equal(false, @basic.valid?)
+  end
+
+=begin MEMO: before_validation_on_createによりテスト不可
+  test "validates_presence_of :activation_token" do
+    @basic.activation_token = ""
+    assert_equal(false, @basic.valid?)
+  end
+=end
+
+  test "validates_presence_of :hashed_password" do
+    @basic.hashed_password = nil
+    assert_equal(false, @basic.valid?)
+  end
+
+  test "validates_length_of :email" do
+    # MEMO: 下記の制約を満たしつつ、文字列長の検証のテストを行う
+    #       * ローカルパートは64文字以内
+    #       * ドメインパートは255文字以内
+    #       * ドメインパートのドットで区切られたパートは63文字以内
+
+    [
+      ["a@b.cd.ef.com", 13, true ],
+      [["a" * 64 + "@" + "b" * 63, "c" * 63, "d" * 3, "com"].join("."), 200, true ],
+      [["a" * 64 + "@" + "b" * 63, "c" * 63, "d" * 4, "com"].join("."), 201, false],
+    ].each { |value, length, expected|
+      assert_equal(length, value.size)
+      @basic.email = value
+      assert_equal(expected, @basic.valid?)
+    }
+  end
+
+  test "validates_format_of :activation_token" do
+    [
+      ["0123456789abcdef0000", true ],
+      ["0" * 19,               false],
+      ["0" * 20,               true ],
+      ["0" * 21,               false],
+      ["0" * 19 + "A",         false],
+      ["0" * 19 + "g",         false],
+    ].each { |value, expected|
+      @basic.activation_token = value
+      assert_equal(expected, @basic.valid?, value)
+    }
+  end
+
+  test "validates_format_of :hashed_password" do
+    [
+      # ソルト値部分
+      ["01234567"  + ":" + "0" * 64, true ],
+      ["89abcdef"  + ":" + "0" * 64, true ],
+      ["0000000"   + ":" + "0" * 64, false],
+      ["00000000"  + ":" + "0" * 64, true ],
+      ["000000000" + ":" + "0" * 64, false],
+      ["0000000A"  + ":" + "0" * 64, false],
+      ["0000000g"  + ":" + "0" * 64, false],
+      # ハッシュ値部分
+      ["00000000" + ":" + "0123456789abcdef" + "0" * (64 - 16), true ],
+      ["00000000" + ":" + "0" * (64 - 1),                       false],
+      ["00000000" + ":" + "0" * 64,                             true ],
+      ["00000000" + ":" + "0" * (64 + 1),                       false],
+      ["00000000" + ":" + "0" * (64 - 1) + "A",                 false],
+      ["00000000" + ":" + "0" * (64 - 1) + "g",                 false],
+    ].each { |value, expected|
+      @basic.hashed_password = value
+      assert_equal(expected, @basic.valid?, value)
+    }
+  end
+
+  test "validates_email_format_of :email" do
+    [
+      ["foo@example.com",   true ],
+      ["foo@example.co.jp", true ],
+      ["foo@example",       false],
+    ].each { |value, expected|
+      @basic.email = value
+      assert_equal(
+        {:in => value, :out => expected},
+        {:in => value, :out => @basic.valid?})
+    }
+  end
+
+  test "validates_uniqueness_of :email, on create" do
+    @basic.email = @yuya_gmail.email
+    assert_equal(false, @basic.valid?)
+  end
+
+  test "validates_uniqueness_of :email, on update" do
+    @yuya_gmail.email = @risa_example.email
+    assert_equal(false, @yuya_gmail.valid?)
+  end
+
+  test "validates_each :user_id" do
+    srand(0)
+    user = users(:yuya)
+    create_record = proc {
+      user.email_credentials.create!(
+        :activation_token => @klass.create_unique_activation_token,
+        :email            => "email#{rand(1000)}@example.com",
+        :hashed_password  => ("0" * 8) + ":" + ("0" * 64))
+    }
+
+    assert_nothing_raised {
+      (10 - user.email_credentials.size).times {
+        record = create_record[]
+        record.save!
+      }
+    }
+    assert_raise(ActiveRecord::RecordInvalid) {
+      create_record[]
+    }
+  end
+
+  #
+  # フック
+  #
+
+  test "before_validation_on_create, nil" do
+    token = "9" * @klass::TokenLength
+
+    record = @klass.new(@basic.attributes)
+    record.activation_token = nil
+
+    Kagemusha.new(@klass).
+      defs(:create_unique_activation_token) { token }.
+      swap {
+        record.save!
+      }
+
+    assert_equal(token, record.reload.activation_token)
+  end
+
+  test "before_validation_on_create, empty string" do
+    token = "9" * @klass::TokenLength
+
+    record = @klass.new(@basic.attributes)
+    record.activation_token = ""
+
+    Kagemusha.new(@klass).
+      defs(:create_unique_activation_token) { token }.
+      swap {
+        record.save!
+      }
+
+    assert_equal(token, record.reload.activation_token)
+  end
+
+  test "before_validation_on_create, already setting" do
+    token = "9" * @klass::TokenLength
+
+    record = @klass.new(@basic.attributes)
+    record.activation_token = token
+    record.save!
+
+    assert_equal(token, record.reload.activation_token)
+  end
+
+  #
+  # クラスメソッド
+  #
+
+  test "self.create_unique_activation_token, pattern" do
+    assert_match(
+      @klass::TokenPattern,
+      @klass.create_unique_activation_token)
+  end
+
+  test "self.create_unique_activation_token, duplication" do
+    dup_token1 = @yuya_gmail.activation_token
+    dup_token2 = @risa_example.activation_token
+    uniq_token = "f" * @klass::TokenLength
+    tokens = [dup_token1, dup_token2, uniq_token]
+
+    musha = Kagemusha.new(TokenUtil)
+    musha.defs(:create_token) { tokens.shift }
+    musha.swap {
+      assert_equal(
+        uniq_token,
+        @klass.create_unique_activation_token)
+    }
+  end
+
+  test "self.create_hashed_password" do
+    assert_match(
+      /\A[0-9a-f]{8}:[0-9a-f]{64}\z/,
+      @klass.create_hashed_password("a"))
+
+    # 異なるパスワードでは、異なる値になること
+    assert_not_equal(
+      @klass.create_hashed_password("a"),
+      @klass.create_hashed_password("b"))
+
+    # 同一のパスワードでも、異なる値になること
+    assert_not_equal(
+      @klass.create_hashed_password("a"),
+      @klass.create_hashed_password("a"))
+  end
+
+  test "self.compare_hashed_password" do
+    # ソルト、パスワードが一致
+    assert_equal(
+      true,
+      @klass.compare_hashed_password(
+        "password",
+        "00000000:" + Digest::SHA256.hexdigest("00000000:password")))
+
+    # ソルトが不一致、パスワードが一致
+    assert_equal(
+      false,
+      @klass.compare_hashed_password(
+        "password",
+        "00000000:" + Digest::SHA256.hexdigest("11111111:password")))
+
+    # ソルトが一致、パスワードが不一致
+    assert_equal(
+      false,
+      @klass.compare_hashed_password(
+        "password",
+        "00000000:" + Digest::SHA256.hexdigest("00000000:PASSWORD")))
+  end
+
+  test "self.authenticate" do
+    assert_equal(
+      email_credentials(:yuya_gmail),
+      @klass.authenticate(email_credentials(:yuya_gmail).email, "yuya_gmail"))
+
+    assert_equal(
+      nil,
+      @klass.authenticate(email_credentials(:yuya_gmail).email, "YUYA_GMAIL"))
+
+    assert_equal(
+      nil,
+      @klass.authenticate(nil, nil))
+  end
+
+  #
+  # インスタンスメソッド
+  #
+
+  test "authenticated?" do
+    assert_equal(true,  email_credentials(:yuya_gmail).authenticated?("yuya_gmail"))
+    assert_equal(false, email_credentials(:yuya_gmail).authenticated?("YUYA_GMAIL"))
+    assert_equal(false, email_credentials(:yuya_nayutaya).authenticated?("yuya_nayutaya"))
+  end
+
+  test "activated?" do
+    assert_equal(true,  email_credentials(:yuya_gmail).activated?)
+    assert_equal(false, email_credentials(:yuya_nayutaya).activated?)
+  end
+
+  test "activate!" do
+    credential = email_credentials(:yuya_nayutaya)
+    time = Time.local(2010, 1, 1)
+
+    assert_equal(false, credential.activated?)
+    assert_equal(true, Kagemusha::DateTime.at(time) { credential.activate! })
+    credential.reload
+    assert_equal(true, credential.activated?)
+    assert_equal(time, credential.activated_at)
+  end
+
+  test "activate!, already activated" do
+    credential = email_credentials(:yuya_gmail)
+    time = credential.activated_at
+
+    assert_equal(true, credential.activated?)
+    assert_equal(false, credential.activate!)
+    credential.reload
+    assert_equal(true, credential.activated?)
+    assert_equal(time, credential.activated_at)
+  end
+
+  test "login!" do
+    time = Time.local(2010, 1, 1)
+    assert_equal(nil, @risa_example.loggedin_at)
+    Kagemusha::DateTime.at(time) { @risa_example.login! }
+    assert_equal(time, @risa_example.reload.loggedin_at)
+  end
+end