multi_auth 0.0.1

data/test/functional/signup/email_controller_test.rb

@@ -0,0 +1,369 @@
+# -*- coding: utf-8 -*-
+
+require 'test_helper'
+
+class Signup::EmailControllerTest < ActionController::TestCase
+  def setup
+    @yuya_gmail    = email_credentials(:yuya_gmail)
+    @yuya_nayutaya = email_credentials(:yuya_nayutaya)
+
+    @signup_form = EmailCredentialEditForm.new(
+      :email                 => "foo@example.com",
+      :password              => "password",
+      :password_confirmation => "password")
+
+    ActionMailer::Base.deliveries = []
+  end
+
+  test "routes" do
+    base = {:controller => "signup/email"}
+
+    assert_routing("/signup/email",           base.merge(:action => "index"))
+    assert_routing("/signup/email/validate",  base.merge(:action => "validate"))
+    assert_routing("/signup/email/validated", base.merge(:action => "validated"))
+    assert_routing("/signup/email/create",    base.merge(:action => "create"))
+    assert_routing("/signup/email/created",   base.merge(:action => "created"))
+    assert_routing("/signup/email/activation/0123456789abcdef", base.merge(:action => "activation", :activation_token => "0123456789abcdef"))
+    assert_routing("/signup/email/activate",  base.merge(:action => "activate"))
+    assert_routing("/signup/email/activated", base.merge(:action => "activated"))
+  end
+
+  test "GET index" do
+    get :index
+
+    assert_response(:success)
+    assert_template("index")
+    assert_flash_empty
+
+    assert_equal(
+      EmailCredentialEditForm.new.attributes,
+      assigns(:signup_form).attributes)
+  end
+
+  test "GET index, clean session" do
+    @request.session[:user_id]     = :dummy
+    @request.session[:signup_form] = :dummy
+
+    get :index
+
+    assert_response(:success)
+    assert_template("index")
+
+    assert_equal(nil, @request.session[:user_id])
+    assert_equal(nil, @request.session[:signup_form])
+  end
+
+  test "POST validate" do
+    assert_equal(true, @signup_form.valid?)
+
+    post :validate, :signup_form => @signup_form.attributes
+
+    assert_response(:redirect)
+    assert_redirected_to(:controller => "email", :action => "validated")
+    assert_flash_empty
+
+    assert_equal(
+      @signup_form.attributes,
+      assigns(:signup_form).attributes)
+
+    assert_equal(
+      @signup_form.attributes,
+      @request.session[:signup_form])
+  end
+
+  test "POST validate, invalid form" do
+    @request.session[:signup_form] = :dummy
+
+    @signup_form.email = nil
+    assert_equal(false, @signup_form.valid?)
+
+    post :validate, :signup_form => @signup_form.attributes
+
+    assert_response(:success)
+    assert_template("index")
+    assert_flash_error
+
+    assert_equal(nil, @request.session[:signup_form])
+
+    assert_equal(nil, assigns(:signup_form).password)
+    assert_equal(nil, assigns(:signup_form).password_confirmation)
+  end
+
+  test "POST validate, clean session" do
+    @request.session[:user_id]     = :dummy
+    @request.session[:signup_form] = :dummy
+
+    post :validate, :signup_form => @signup_form.attributes
+
+    assert_response(:redirect)
+    assert_redirected_to(:controller => "email", :action => "validated")
+
+    assert_equal(nil, @request.session[:user_id])
+  end
+
+  test "GET validate, abnormal, method not allowed" do
+    get :validate
+
+    assert_response(405)
+    assert_template(nil)
+  end
+
+  test "GET validated" do
+    assert_equal(true, @signup_form.valid?)
+
+    @request.session[:signup_form] = @signup_form.attributes
+
+    get :validated
+
+    assert_response(:success)
+    assert_template("validated")
+    assert_flash_empty
+
+    assert_equal(
+      @signup_form.attributes,
+      assigns(:signup_form).attributes)
+  end
+
+  test "GET validated, invalid form" do
+    @signup_form.email = nil
+    assert_equal(false, @signup_form.valid?)
+
+    get :validated
+
+    assert_response(:success)
+    assert_template("index")
+    assert_flash_error
+  end
+
+  test "GET validated, clean session" do
+    @request.session[:user_id]     = :dummy
+    @request.session[:signup_form] = @signup_form.attributes
+
+    get :validated
+
+    assert_response(:success)
+    assert_template("validated")
+
+    assert_equal(nil, @request.session[:user_id])
+  end
+
+  test "POST create" do
+    assert_equal(true, @signup_form.valid?)
+
+    @request.session[:signup_form] = @signup_form.attributes
+
+    assert_difference("EmailCredential.count", +1) {
+      assert_difference("User.count", +1) {
+        post :create
+      }
+    }
+
+    assert_response(:redirect)
+    assert_redirected_to(:controller => "email", :action => "created")
+    assert_flash_empty
+
+    assert_equal(
+      @signup_form.attributes,
+      assigns(:signup_form).attributes)
+
+    assert_equal(nil, assigns(:user).nickname)
+
+    assert_equal(
+      assigns(:user).id,
+      assigns(:credential).user_id)
+    assert_equal(
+      @signup_form.email,
+      assigns(:credential).email)
+    assert_equal(
+      true,
+      EmailCredential.compare_hashed_password(@signup_form.password, assigns(:credential).hashed_password))
+
+    # MEMO: ここではurl_forが使えない
+    assert_equal(
+      root_path(:only_path => false) + "signup/email/activation/" + assigns(:credential).activation_token,
+      assigns(:activation_url))
+
+    assert_equal(1, ActionMailer::Base.deliveries.size)
+  end
+
+  test "POST create, invalid form" do
+    @signup_form.email = nil
+    assert_equal(false, @signup_form.valid?)
+
+    @request.session[:signup_form] = @signup_form.attributes
+
+    post :create
+
+    assert_response(:success)
+    assert_template("index")
+    assert_flash_error
+  end
+
+  test "POST create, clean session" do
+    @request.session[:user_id]     = :dummy
+    @request.session[:signup_form] = @signup_form.attributes
+
+    post :create
+
+    assert_response(:redirect)
+    assert_redirected_to(:controller => "email", :action => "created")
+
+    assert_equal(nil, @request.session[:user_id])
+  end
+
+  test "GET create, abnormal, method not allowed" do
+    get :create
+
+    assert_response(405)
+    assert_template(nil)
+  end
+
+  test "GET created" do
+    @signup_form.email = @yuya_nayutaya.email
+    @request.session[:signup_form] = @signup_form.attributes
+
+    get :created
+
+    assert_response(:success)
+    assert_template("created")
+    assert_flash_empty
+
+    assert_equal(
+      @signup_form.attributes,
+      assigns(:signup_form).attributes)
+    assert_equal(
+      @signup_form.email,
+      assigns(:credential).email)
+  end
+
+  test "GET created, clean session" do
+    @request.session[:user_id]     = :dummy
+    @request.session[:signup_form] = {:email => @yuya_nayutaya.email}
+
+    get :created
+
+    assert_response(:success)
+    assert_template("created")
+
+    assert_equal(nil, @request.session[:user_id])
+  end
+
+  test "GET activation" do
+    get :activation, :activation_token => @yuya_nayutaya.activation_token
+
+    assert_response(:success)
+    assert_template("activation")
+    assert_flash_empty
+
+    assert_equal(@yuya_nayutaya, assigns(:credential))
+    assert_equal(false, assigns(:activated))
+  end
+
+  test "GET activation, already activated" do
+    get :activation, :activation_token => @yuya_gmail.activation_token
+
+    assert_response(:success)
+    assert_template("activation")
+    assert_flash_empty
+
+    assert_equal(@yuya_gmail, assigns(:credential))
+    assert_equal(true, assigns(:activated))
+  end
+
+  test "GET activation, clean session" do
+    @request.session[:user_id]     = :dummy
+    @request.session[:signup_form] = :dummy
+
+    get :activation, :activation_token => @yuya_nayutaya.activation_token
+
+    assert_response(:success)
+    assert_template("activation")
+
+    assert_equal(nil, @request.session[:user_id])
+    assert_equal(nil, @request.session[:signup_form])
+  end
+
+  test "GET activation, abnormal, invalid activation token" do
+    get :activation, :activation_token => "0"
+
+    assert_response(:success)
+    assert_template("activation")
+    assert_flash_empty
+
+    assert_equal(nil, assigns(:credential))
+    assert_equal(nil, assigns(:activated))
+  end
+
+  test "POST activate" do
+    time = Time.local(2010, 1, 1)
+
+    Kagemusha::DateTime.at(time) {
+      post :activate, :activation_token => @yuya_nayutaya.activation_token
+    }
+
+    assert_response(:redirect)
+    assert_redirected_to(:controller => "email", :action => "activated")
+    assert_flash_empty
+
+    assigns(:credential).reload
+    assert_equal(@yuya_nayutaya.email, assigns(:credential).email)
+    assert_equal(time, assigns(:credential).activated_at)
+  end
+
+  test "POST activate, already activated" do
+    post :activate, :activation_token => @yuya_gmail.activation_token
+
+    assert_response(:redirect)
+    assert_redirected_to(root_path)
+    assert_flash_error
+  end
+
+  test "POST activate, clean session" do
+    @request.session[:user_id]     = :dummy
+    @request.session[:signup_form] = :dummy
+
+    post :activate, :activation_token => @yuya_nayutaya.activation_token
+
+    assert_response(:redirect)
+    assert_redirected_to(:controller => "email", :action => "activated")
+
+    assert_equal(nil, @request.session[:user_id])
+    assert_equal(nil, @request.session[:signup_form])
+  end
+
+  test "POST activated, abnormal, no activation token" do
+    post :activate, :activation_token => nil
+
+    assert_response(:redirect)
+    assert_redirected_to(root_path)
+    assert_flash_error
+  end
+
+  test "GET activate, abnormal, method not allowed" do
+    get :activate
+
+    assert_response(405)
+    assert_template(nil)
+  end
+
+  test "GET activated" do
+    get :activated
+
+    assert_response(:success)
+    assert_template("activated")
+    assert_flash_empty
+  end
+
+  test "GET activated, clean session" do
+    @request.session[:user_id]     = :dummy
+    @request.session[:signup_form] = :dummy
+
+    get :activated
+
+    assert_response(:success)
+    assert_template("activated")
+
+    assert_equal(nil, @request.session[:user_id])
+    assert_equal(nil, @request.session[:signup_form])
+  end
+end

data/test/functional/signup/open_id_controller_test.rb

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+
+require 'test_helper'
+
+class Signup::OpenIdControllerTest < ActionController::TestCase
+  test "routes" do
+    base = {:controller => "signup/open_id"}
+
+    assert_routing("signup/open_id",               base.merge(:action => "index"))
+    assert_routing("signup/open_id/authenticate",  base.merge(:action => "authenticate"))
+    assert_routing("signup/open_id/authenticated", base.merge(:action => "authenticated"))
+    assert_routing("signup/open_id/create",        base.merge(:action => "create"))
+    assert_routing("signup/open_id/created",       base.merge(:action => "created"))
+  end
+
+  test "GET index" do
+    get :index
+
+    assert_response(:success)
+    assert_template("index")
+  end
+
+  test "POST authenticate, first step" do
+    post :authenticate, :openid_url => "livedoor.com"
+
+    assert_response(:redirect)
+    # FXIME 検証を追加する？
+    # FIXME 毎回リクエストが外に飛んでいるのをなんとかする
+  end
+
+  test "GET authenticate, second step" do
+    get :authenticate, :openid_url => nil
+    # TODO: 必要があれば検証を追加する
+  end
+
+  test "POST create" do
+    @request.session[:identity_url] = "http://example.com/"
+
+    post :create
+
+    assert_response(:redirect)
+    assert_redirected_to(:action => "created")
+  end
+end

data/test/functional/signup_controller_test.rb

@@ -0,0 +1,17 @@
+
+require 'test_helper'
+
+class SignupControllerTest < ActionController::TestCase
+  test "routes" do
+    base = {:controller => "signup"}
+
+    assert_routing("/signup", base.merge(:action => "index"))
+  end
+
+  test "GET index" do
+    get :index
+
+    assert_response(:success)
+    assert_template("index")
+  end
+end

data/test/performance/browsing_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+require 'performance_test_help'
+
+# Profiling results for each test method are written to tmp/performance.
+class BrowsingTest < ActionController::PerformanceTest
+  def test_homepage
+    get '/'
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,82 @@
+
+ENV["RAILS_ENV"] = "test"
+require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
+require 'test_help'
+
+require "kagemusha/datetime"
+
+begin
+  require 'redgreen'
+rescue LoadError
+  # do nothing
+end
+
+class ActiveSupport::TestCase
+  # Transactional fixtures accelerate your tests by wrapping each test method
+  # in a transaction that's rolled back on completion.  This ensures that the
+  # test database remains unchanged so your fixtures don't have to be reloaded
+  # between every test method.  Fewer database queries means faster tests.
+  #
+  # Read Mike Clark's excellent walkthrough at
+  #   http://clarkware.com/cgi/blosxom/2005/10/24#Rails10FastTesting
+  #
+  # Every Active Record database supports transactions except MyISAM tables
+  # in MySQL.  Turn off transactional fixtures in this case; however, if you
+  # don't care one way or the other, switching from MyISAM to InnoDB tables
+  # is recommended.
+  #
+  # The only drawback to using transactional fixtures is when you actually 
+  # need to test transactions.  Since your test is bracketed by a transaction,
+  # any transactions started in your code will be automatically rolled back.
+  self.use_transactional_fixtures = true
+
+  # Instantiated fixtures are slow, but give you @david where otherwise you
+  # would need people(:david).  If you don't want to migrate your existing
+  # test cases which use the @david style and don't mind the speed hit (each
+  # instantiated fixtures translates to a database query per test method),
+  # then set this back to true.
+  self.use_instantiated_fixtures  = false
+
+  # Setup all fixtures in test/fixtures/*.(yml|csv) for all tests in alphabetical order.
+  #
+  # Note: You'll currently still have to declare fixtures explicitly in integration tests
+  # -- they do not yet inherit this setting
+  fixtures :all
+
+  # Add more helper methods to be used by all tests here...
+
+  private
+
+  def assert_logged_in(user)
+    assert_equal(user.id, @request.session[:user_id])
+    assert_equal(user, assigns(:login_user))
+  end
+
+  def assert_not_logged_in
+    assert_equal(nil, @request.session[:user_id])
+    assert_equal(nil, assigns(:login_user))
+  end
+
+  def session_login(user)
+    @request.session[:user_id] = user.id
+  end
+
+  def session_logout
+    @request.session[:user_id] = nil
+  end
+
+  def assert_flash_empty
+    assert_nil(assigns(:flash_notice))
+    assert_nil(assigns(:flash_error))
+  end
+
+  def assert_flash_notice
+    assert_not_nil(assigns(:flash_notice))
+    assert_nil(assigns(:flash_error))
+  end
+
+  def assert_flash_error
+    assert_nil(assigns(:flash_notice))
+    assert_not_nil(assigns(:flash_error))
+  end
+end

data/test/unit/action_mailer_util_test.rb

@@ -0,0 +1,63 @@
+
+require 'test_helper'
+
+class ActionMailerUtilTest < ActiveSupport::TestCase
+  def setup
+    @module   = ActionMailerUtil
+    @instance = Class.new.module_eval { include(ActionMailerUtil); self }.new
+    @musha    = Kagemusha.new(@instance.class)
+  end
+
+  test "build_message" do
+    time = Time.local(2010, 1, 1)
+    options = {
+      :subject    => "SUBJECT",
+      :from       => "FROM",
+      :recipients => "RECIPIENTS",
+      :body       => {:KEY => :VALUE},
+    }
+
+    called = []
+    @musha.def(:sent_on)    { |value| called << [:sent_on,    value] }
+    @musha.def(:subject)    { |value| called << [:subject,    value] }
+    @musha.def(:from)       { |value| called << [:from,       value] }
+    @musha.def(:recipients) { |value| called << [:recipients, value] }
+    @musha.def(:body)       { |value| called << [:body,       value] }
+    @musha.swap {
+      Kagemusha::DateTime.at(time) {
+        assert_equal(nil, @instance.__send__(:build_message, options))
+      }
+    }
+
+    expected = [
+      [:sent_on,    time],
+      [:subject,    "SUBJECT"],
+      [:from,       "FROM"],
+      [:recipients, "RECIPIENTS"],
+      [:body,       {:KEY => :VALUE}],
+    ]
+    assert_equal(expected, called)
+  end
+
+  test "build_message, deficient parameter" do
+    options = {
+      :subject    => "SUBJECT",
+      :from       => "FROM",
+      :recipients => "RECIPIENTS",
+      :body       => {:KEY => :VALUE},
+    }
+
+    @musha.def(:sent_on)    { }
+    @musha.def(:subject)    { }
+    @musha.def(:from)       { }
+    @musha.def(:recipients) { }
+    @musha.def(:body)       { }
+    @musha.swap {
+      assert_nothing_raised       { @instance.__send__(:build_message, options) }
+      assert_raise(ArgumentError) { @instance.__send__(:build_message, options.merge(:subject => nil)) }
+      assert_raise(ArgumentError) { @instance.__send__(:build_message, options.merge(:from => nil)) }
+      assert_raise(ArgumentError) { @instance.__send__(:build_message, options.merge(:recipients => nil)) }
+      assert_raise(ArgumentError) { @instance.__send__(:build_message, options.merge(:body => nil)) }
+    }
+  end
+end