multi_auth 0.1.0 → 0.2.0

data/test/functional/auth/name_controller_test.rb

@@ -0,0 +1,77 @@
+require 'test_helper'
+
+class Auth::NameControllerTest < ActionController::TestCase
+  def setup
+    @login_form = NameLoginForm.new
+  end
+
+  test "toutes" do
+    base = { :controller => "auth/name" }
+
+    assert_routing("/auth/name",       base.merge(:action => "index"))
+    assert_routing("/auth/name/login", base.merge(:action => "login"))
+  end
+
+  test "GET index" do
+    session_login(users(:yuya))
+
+    get :index
+
+    assert_response(:success)
+    assert_template("index")
+    assert_flash_empty
+    assert_not_logged_in
+
+    assert_equal(NameLoginForm.new.attributes, assigns(:login_form).attributes)
+  end
+
+  test "POST login" do
+    session_login(users(:shinya))
+
+    time = Time.local(2010, 1, 1)
+    @login_form.attributes = {
+      :name     => name_credentials(:nayutaya).name,
+      :password => "nayutaya",
+    }
+    assert_equal(true, @login_form.valid?)
+
+    Kagemusha::DateTime.at(time) {
+      post :login, :login_form => @login_form.attributes
+    }
+
+    assert_response(:redirect)
+    assert_redirected_to(:controller => "/auth", :action => "logged_in")
+    assert_flash_empty
+    assert_logged_in(users(:yuya))
+
+    assert_equal(
+      @login_form.attributes,
+      assigns(:login_form).attributes)
+
+    assert_equal(name_credentials(:nayutaya), assigns(:name_credential))
+    assert_equal(time, assigns(:name_credential).loggedin_at)
+  end
+
+  test "POST login, invalid form" do
+    session_login(users(:shinya))
+
+    assert_equal(false, @login_form.valid?)
+
+    post :login, :login_form => @login_form.attributes
+
+    assert_response(:success)
+    assert_template("index")
+    assert_flash_error
+    assert_not_logged_in
+
+    assert_equal(nil, assigns(:login_form).password)
+    assert_equal(nil, assigns(:email_credential))
+  end
+
+  test "GET login, abnormal, method not allowed" do
+    get :login
+
+    assert_response(405)
+    assert_template(nil)
+  end
+end

data/test/functional/credentials/email_controller_test.rb

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 
 require 'test_helper'
 
@@ -13,7 +14,7 @@ class Credentials::EmailControllerTest < ActionController::TestCase
       :password              => "password",
       :password_confirmation => "password")
 
-    @password_edit_form = EmailPasswordEditForm.new(
+    @password_edit_form = PasswordEditForm.new(
       :password              => "password",
       :password_confirmation => "password")
 
@@ -165,9 +166,7 @@ class Credentials::EmailControllerTest < ActionController::TestCase
 
     assert_equal(@yuya_gmail, assigns(:email_credential))
 
-    assert_equal(
-      EmailPasswordEditForm.new.attributes,
-      assigns(:edit_form).attributes)
+    assert_equal(PasswordEditForm.new.attributes, assigns(:edit_form).attributes)
   end
 
   test "GET edit_password, abnormal, no login" do

data/test/functional/credentials/name_controller_test.rb

@@ -0,0 +1,292 @@
+# -*- coding: utf-8 -*-
+require 'test_helper'
+
+class Credentials::NameControllerTest < ActionController::TestCase
+  def setup
+    @yuya      = users(:yuya)
+    @nayutaya  = name_credentials(:nayutaya)
+    @risa_risa = name_credentials(:risa_risa)
+
+    @edit_form = NameCredentialEditForm.new(
+      :name                  => "name",
+      :password              => "password",
+      :password_confirmation => "password")
+
+    @password_edit_form = PasswordEditForm.new(
+      :password              => "password",
+      :password_confirmation => "password")
+
+    session_login(@yuya)
+  end
+
+  test "routes" do
+    base = {:controller => "credentials/name"}
+
+    assert_routing("/credentials/name/new",    base.merge(:action => "new"))
+    assert_routing("/credentials/name/create", base.merge(:action => "create"))
+
+    assert_routing("/credential/name/1234567890/edit_password",   base.merge(:action => "edit_password",   :name_credential_id => "1234567890"))
+    assert_routing("/credential/name/1234567890/update_password", base.merge(:action => "update_password", :name_credential_id => "1234567890"))
+    assert_routing("/credential/name/1234567890/delete",          base.merge(:action => "delete",          :name_credential_id => "1234567890"))
+    assert_routing("/credential/name/1234567890/destroy",         base.merge(:action => "destroy",         :name_credential_id => "1234567890"))
+  end
+
+  test "GET new" do
+    get :new
+
+    assert_response(:success)
+    assert_template("new")
+    assert_flash_empty
+    assert_logged_in(@yuya)
+
+    assert_equal(
+      NameCredentialEditForm.new.attributes,
+      assigns(:edit_form).attributes)
+  end
+
+  test "GET new, abnormal, no login" do
+    session_logout
+
+    get :new
+
+    assert_response(:redirect)
+    assert_redirected_to(root_path)
+    assert_flash_error
+  end
+
+  test "POST create" do
+    assert_equal(true, @edit_form.valid?)
+
+    assert_difference("NameCredential.count", +1) {
+      post :create, :edit_form => @edit_form.attributes
+    }
+
+    assert_response(:redirect)
+    assert_redirected_to(:controller => "/credentials", :action => "index")
+    assert_flash_notice
+    assert_logged_in(@yuya)
+    assert_equal(@edit_form.attributes, assigns(:edit_form).attributes)
+    assigns(:name_credential).reload
+    assert_equal(@yuya.id, assigns(:name_credential).user_id)
+    assert_equal(@edit_form.name, assigns(:name_credential).name)
+    assert_equal(true, NameCredential.compare_hashed_password(@edit_form.password, assigns(:name_credential).hashed_password))
+  end
+
+  test "POST create, invalid form" do
+    @edit_form.name = nil
+    assert_equal(false, @edit_form.valid?)
+
+    assert_difference("NameCredential.count", 0) {
+      post :create, :edit_form => @edit_form.attributes
+    }
+
+    assert_response(:success)
+    assert_template("new")
+    assert_flash_error
+
+    assert_equal(nil, assigns(:edit_form).password)
+    assert_equal(nil, assigns(:edit_form).password_confirmation)
+  end
+
+  test "GET create, abnormal, method not allowed" do
+    get :create
+
+    assert_response(405)
+    assert_template(nil)
+  end
+
+  test "POST create, abnormal, no login" do
+    session_logout
+
+    post :create
+
+    assert_response(:redirect)
+    assert_redirected_to(root_path)
+    assert_flash_error
+  end
+
+  test "GET edit_password" do
+    get :edit_password, :name_credential_id => @nayutaya.id
+
+    assert_response(:success)
+    assert_template("edit_password")
+    assert_flash_empty
+    assert_logged_in(@yuya)
+
+    assert_equal(@nayutaya, assigns(:name_credential))
+
+    assert_equal(PasswordEditForm.new.attributes, assigns(:edit_form).attributes)
+  end
+
+  test "GET edit_password, abnormal, no login" do
+    session_logout
+
+    get :edit_password, :name_credential_id => @nayutaya.id
+
+    assert_response(:redirect)
+    assert_redirected_to(root_path)
+    assert_flash_error
+  end
+
+  test "GET edit_password, abnormal, invalid name credential id" do
+    get :edit_password, :name_credential_id => "0"
+
+    assert_response(:redirect)
+    assert_redirected_to(root_path)
+    assert_flash_error
+  end
+
+  test "GET edit_password, abnormal, other's name credential" do
+    get :edit_password, :name_credential_id => @risa_risa.id
+
+    assert_response(:redirect)
+    assert_redirected_to(root_path)
+    assert_flash_error
+  end
+
+  test "POST update_password" do
+    assert_equal(true, @password_edit_form.valid?)
+
+    post :update_password, :name_credential_id => @nayutaya.id, :edit_form => @password_edit_form.attributes
+
+    assert_response(:redirect)
+    assert_redirected_to(:controller => "/credentials", :action => "index")
+    assert_flash_notice
+    assert_logged_in(@yuya)
+
+    assert_equal(@nayutaya, assigns(:name_credential))
+
+    assert_equal(
+      @password_edit_form.attributes,
+      assigns(:edit_form).attributes)
+
+    assigns(:name_credential).reload
+    assert_equal(
+      true,
+      NameCredential.compare_hashed_password(@password_edit_form.password, assigns(:name_credential).hashed_password))
+  end
+
+  test "POST update_password, invalid form" do
+    @password_edit_form.password = "x"
+    assert_equal(false, @password_edit_form.valid?)
+
+    post :update_password, :name_credential_id => @nayutaya.id, :edit_form => @password_edit_form.attributes
+
+    assert_response(:success)
+    assert_template("edit_password")
+    assert_flash_error
+
+    assert_equal(nil, assigns(:edit_form).password)
+    assert_equal(nil, assigns(:edit_form).password_confirmation)
+  end
+
+  test "GET update_password, abnormal, method not allowed" do
+    get :update_password, :name_credential_id => @nayutaya.id
+
+    assert_response(405)
+    assert_template(nil)
+  end
+
+  test "POST update_password, abnormal, no login" do
+    session_logout
+
+    post :update_password, :name_credential_id => @nayutaya.id
+
+    assert_response(:redirect)
+    assert_redirected_to(root_path)
+    assert_flash_error
+  end
+
+  test "POST update_password, abnormal, invalid name credential id" do
+    post :update_password, :name_credential_id => "0"
+
+    assert_response(:redirect)
+    assert_redirected_to(root_path)
+    assert_flash_error
+  end
+
+  test "GET delete" do
+    get :delete, :name_credential_id => @nayutaya.id
+
+    assert_response(:success)
+    assert_template("delete")
+    assert_flash_empty
+    assert_logged_in(@yuya)
+
+    assert_equal(@nayutaya, assigns(:name_credential))
+  end
+
+  test "GET delete, abnormal, no login" do
+    session_logout
+
+    get :delete, :name_credential_id => @nayutaya.id
+
+    assert_response(:redirect)
+    assert_redirected_to(root_path)
+    assert_flash_error
+  end
+
+  test "GET delete, abnormal, invalid name credential id" do
+    get :delete, :name_credential_id => "0"
+
+    assert_response(:redirect)
+    assert_redirected_to(root_path)
+    assert_flash_error
+  end
+
+  test "GET delete, abnormal, other's name credential" do
+    get :delete, :name_credential_id => @risa_risa.id
+
+    assert_response(:redirect)
+    assert_redirected_to(root_path)
+    assert_flash_error
+  end
+
+  test "POST destroy" do
+    assert_difference("NameCredential.count", -1) {
+      post :destroy, :name_credential_id => @nayutaya.id
+    }
+
+    assert_response(:redirect)
+    assert_redirected_to(:controller => "/credentials", :action => "index")
+    assert_flash_notice
+    assert_logged_in(@yuya)
+
+    assert_equal(@nayutaya, assigns(:name_credential))
+
+    assert_equal(nil, NameCredential.find_by_id(@nayutaya.id))
+  end
+
+  test "GET destroy, abnormal, method not allowed" do
+    get :destroy, :name_credential_id => @nayutaya.id
+
+    assert_response(405)
+    assert_template(nil)
+  end
+
+  test "POST destroy, abnormal, no login" do
+    session_logout
+
+    post :destroy, :name_credential_id => @nayutaya.id
+
+    assert_response(:redirect)
+    assert_redirected_to(root_path)
+    assert_flash_error
+  end
+
+  test "POST destroy, abnormal, invalid name credential id" do
+    post :destroy, :name_credential_id => "0"
+
+    assert_response(:redirect)
+    assert_redirected_to(root_path)
+    assert_flash_error
+  end
+
+  test "POST destroy, abnormal, other's name credential" do
+    post :destroy, :name_credential_id => @risa_risa.id
+
+    assert_response(:redirect)
+    assert_redirected_to(root_path)
+    assert_flash_error
+  end
+end

data/test/unit/name_credential_edit_form_test.rb

@@ -0,0 +1,151 @@
+# -*- coding: utf-8 -*-
+require 'test_helper'
+
+class NameCredentialEditFormTest < ActiveSupport::TestCase
+  def setup
+    @klass = NameCredentialEditForm
+    @form  = @klass.new
+    @basic = @klass.new(:name => "name",
+                        :password => "password", :password_confirmation => "password")
+  end
+
+  #
+  # 基底クラス
+  #
+
+  test "superclass" do
+    assert_equal(ActiveForm, @klass.superclass)
+  end
+
+  #
+  # カラム
+  #
+
+  test "columns" do
+    [
+      [:name,                  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 :name" do
+    @basic.name = 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 :name" do
+    [
+      ["a" * 13, 13, true ],
+      ["a" * 200, 200, true ],
+      ["a" * 201, 201, false],
+    ].each { |value, length, expected|
+      assert_equal(length, value.size)
+      @basic.name = 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_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_name_credential_hash, empty" do
+    hash = @form.to_name_credential_hash
+    assert_equal(
+      [:name, :hashed_password].map(&:to_s).sort,
+      hash.keys.map(&:to_s).sort)
+    assert_equal(nil, hash[:name])
+    assert_equal(true, NameCredential.compare_hashed_password("", hash[:hashed_password]))
+  end
+
+  test "to_name_credential_hash, full" do
+    @form.attributes = {
+      :name    => "foo@example.com",
+      :password => "foo",
+    }
+    hash = @form.to_name_credential_hash
+    assert_equal(
+      [:name, :hashed_password].map(&:to_s).sort,
+      hash.keys.map(&:to_s).sort)
+    assert_equal(@form.name, hash[:name])
+    assert_equal(true, NameCredential.compare_hashed_password(@form.password, hash[:hashed_password]))
+  end
+end