hashrocket-clearance 0.4.0

data/lib/clearance/spec/models/user_spec.rb

@@ -0,0 +1,33 @@
+module Clearance
+  module Spec
+    module Models
+      module UserModel
+        def self.included(base)
+          base.class_eval do
+            describe "normal vs. facebook users" do
+              it "distinguishes normal user" do
+                u = User.new
+                u.facebook_id = nil
+                u.should be_normal_user
+                u.should_not be_facebook_user
+              end
+
+              it "distinguishes Facebook user" do
+                u = User.new
+                u.facebook_id = "something"
+                u.should be_facebook_user
+                u.should_not be_normal_user
+              end
+            end
+
+            it "should be valid with just a facebook_id if user is a facebook user" do
+              u = User.new
+              u.facebook_id = "something"
+              u.should be_valid
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/clearance/test/functional/confirmations_controller_test.rb

@@ -0,0 +1,50 @@
+module Clearance
+  module Test
+    module Functional
+      module ConfirmationsControllerTest
+
+        def self.included(base)
+          base.class_eval do
+
+            context 'A GET to #confirm' do
+              context "with the User's given confirmation code" do
+                setup do
+                  @user = Factory :user
+                  @user.generate_confirmation_code
+                  get :confirm, :confirmation_code => @user.confirmation_code
+                  @user.reload
+                end
+
+                should 'find and confirm the User record with the given confimation code' do
+                  assert @user.confirmed?
+                end
+
+                should_return_from_session :user_id, "@user.id"
+
+                should_respond_with :redirect
+                should_redirect_to "@controller.send(:url_after_confirm)"
+                
+              end
+
+              context "without the User's given confirmation code" do
+                setup do
+                  user = Factory :user
+                  get :confirm, :confirmation_code => ''
+                end
+
+                should_respond_with :not_found
+
+                should 'render nothing' do
+                  assert @response.body.blank?
+                end
+              end
+              
+            end
+
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/clearance/test/functional/passwords_controller_test.rb

@@ -0,0 +1,224 @@
+module Clearance
+  module Test
+    module Functional
+      module PasswordsControllerTest
+
+        def self.included(base)
+          base.class_eval do
+
+            should_route :get, '/passwords/new', :action => 'new'
+            should_route :post, '/passwords', :action => 'create'
+            should_route :get, '/passwords/:id/edit', :action => 'edit', :id => 'reset_password_code'
+            should_route :put, '/passwords/:id', :action => 'update', :id => 'reset_password_code'
+
+            context 'with a user' do
+              setup { @user = Factory :user }
+
+              context 'A GET to #new' do
+                setup { get :new }
+
+                should_respond_with :success
+                should_render_template 'new'
+                
+                should "have a form for the user's email" do
+                  new_path = ERB::Util.h(passwords_path)
+
+                  assert_select 'form[action=?]', new_path do
+                    assert_select 'input[name=?]', 'email'
+                  end
+                end
+                
+              end
+
+              context 'A POST to #create' do
+                context "with an existing user's email address" do
+                  setup do
+                    ActionMailer::Base.deliveries.clear
+
+                    post :create, :email => @user.email
+                    @email = ActionMailer::Base.deliveries[0]
+                  end
+
+                  should 'send an email to the user to edit their password' do
+                    assert @email.subject =~ /forgot your password/i
+                  end
+                  
+                  should 'generate a reset_password_code' do
+                    @user.reload
+                    assert_not_nil @user.reset_password_code
+                  end
+
+                  should_redirect_to "@controller.send(:url_after_create)"
+                end
+
+                context 'with a non-existing email address' do
+                  setup do
+                    email = 'user1@example.com'
+                    assert ! User.exists?(['email = ?', email])
+                    ActionMailer::Base.deliveries.clear
+
+                    post :create, :email => email
+                  end
+
+                  should 'not send a password reminder email' do
+                    assert ActionMailer::Base.deliveries.empty?
+                  end
+
+                  should 'set a :error flash' do
+                    assert_not_nil flash.now[:error]
+                  end
+
+                  should_render_template "new"
+                end
+              end
+
+              context 'A GET to #edit' do
+                context "with an existing user's reset password code" do
+                  setup do
+                    @user.generate_reset_password_code
+                    get :edit, :id => @user.reset_password_code 
+                  end
+
+                  should 'find the user' do
+                    assert_equal @user, assigns(:user)
+                  end
+
+                  should_respond_with :success
+                  should_render_template "edit"
+
+                  should "have a form for the user's email, password, and password confirm" do
+                    update_path = ERB::Util.h(password_path(:id => @user.reset_password_code))
+
+                    assert_select 'form[action=?]', update_path do
+                      assert_select 'input[name=_method][value=?]', 'put'
+                      assert_select 'input[name=?]', 'password'
+                      assert_select 'input[name=?]', 'password_confirmation'
+                    end
+                  end
+                end
+
+                context "without an existing user's reset password code" do
+                  setup do
+                    get :edit, :id => 'some_random_x'
+                  end
+
+                  should_respond_with :not_found
+
+                  should 'render an empty response' do
+                    assert @response.body.blank?
+                  end
+                end
+              end
+
+              context 'A PUT to #update' do
+                setup do
+                  @new_password = 'new_password'
+                  @encrypted_new_password = Digest::SHA1.hexdigest("--#{@user.salt}--#{@new_password}--")
+                  assert_not_equal @encrypted_new_password, @user.crypted_password
+                  @user.generate_reset_password_code
+                end
+                
+                context "without an existing user's reset_password_code" do
+                  setup do
+                    put(:update,
+                        :id => 'x',
+                        :password => @new_password,
+                        :password_confirmation => @new_password)
+                    @user.reload
+                  end
+
+                  should "not find the user" do
+                    assert_nil assigns[:user]
+                  end
+
+                  should_return_from_session :user_id, "nil"
+
+                  should 'not remove the reset_password_code' do
+                    assert_not_nil @user.reset_password_code
+                  end
+                  
+                  should_respond_with :not_found
+
+                  should 'render an empty response' do
+                    assert @response.body.blank?
+                  end
+                end
+
+                context 'with an existing user with a matching password and password confirmation' do
+                  setup do
+                    put(:update,
+                        :id  => @user.reset_password_code,
+                        :password              => @new_password,
+                        :password_confirmation => @new_password)
+                    @user.reload
+                  end
+
+                  should "update the user's password" do
+                    assert_equal @encrypted_new_password, @user.crypted_password
+                  end
+
+                  should 'remove the reset_password_code' do
+                    assert_nil @user.reset_password_code
+                  end
+
+                  should_return_from_session :user_id, "@user.id"
+
+                  should_redirect_to "user_path(@user)"
+                end
+
+                context 'with blank password and a password confirmation' do
+                  setup do
+                    put(:update,
+                        :id => @user.reset_password_code,
+                        :password => '',
+                        :password_confirmation => @new_password)
+                    @user.reload
+                  end
+
+                  should "not update the user's password" do
+                    assert_not_equal @encrypted_new_password, @user.crypted_password
+                  end
+
+                  should_return_from_session :user_id, "nil"
+
+                  should 'set a :error flash' do
+                    assert_not_nil flash.now[:error]
+                  end
+
+                  should_render_template "edit"
+                end
+
+                context 'with password but blank password confirmation' do
+                  setup do
+                    put(:update,
+                        :id => @user.reset_password_code,
+                        :password => @new_password,
+                        :password_confirmation => '')
+                    @user.reload
+                  end
+
+                  should "not update the user's password" do
+                    assert_not_equal @encrypted_new_password, @user.crypted_password
+                  end
+
+                  should_return_from_session :user_id, "nil"
+
+                  should 'not remove the reset_password_code' do
+                    assert_not_nil @user.reset_password_code
+                  end
+
+                  should 'set a :error flash' do
+                    assert_not_nil flash.now[:error]
+                  end
+
+                  should_render_template "edit"
+                end
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/clearance/test/functional/sessions_controller_test.rb

@@ -0,0 +1,148 @@
+module Clearance
+  module Test
+    module Functional
+      module SessionsControllerTest
+    
+        def self.included(base)
+          base.class_eval do
+            should_filter_params :password
+
+            context "on GET to /sessions/new" do
+              setup { get :new }
+        
+              should_respond_with :success
+              should_render_template :new
+              should_not_set_the_flash
+              should_have_form :action => "session_path",
+                :fields => { "session[email]" => :text,
+                  "session[password]" => :password,
+                  "session[remember_me]" => :checkbox }
+            end
+
+            context "Given an unconfirmed user" do
+              setup do
+                @user = Factory(:user, :confirmed => false)
+              end
+
+              context "a POST to #create with good credentials" do
+                setup do
+                  ActionMailer::Base.deliveries.clear
+                  post :create, :session => {
+                                  :email => @user.email,
+                                  :password => @user.password
+                  }
+                end
+
+                should_deny_access(:flash => /confirm/i)
+
+                should "send the confirmation email" do
+                  assert_not_nil email = ActionMailer::Base.deliveries[0]
+                  assert_match /account confirmation/i, email.subject
+                end
+              end
+            end
+
+            context "Given a confirmed user" do
+              setup { @user = Factory(:user, :confirmed => true) }
+
+              context "a POST to #create with good credentials" do
+                setup do
+                  post :create, :session => { :email => @user.email, 
+                    :password => @user.password }
+                end
+
+                should_set_the_flash_to /success/i
+                should_redirect_to '@controller.send(:url_after_create)'
+                should_return_from_session :user_id, "@user.id"
+              end
+
+              context "a POST to #create with bad credentials" do
+                setup do
+                  post :create, :session => { :email => @user.email, 
+                    :password => "bad value" }
+                end
+
+                should_set_the_flash_to /bad/i
+                should_render_template :new
+                should_return_from_session :user_id, "nil"
+              end
+          
+              context "a POST to #create with good credentials and remember me" do
+                setup do
+                  post :create, :session => { :email => @user.email, 
+                    :password => @user.password, :remember_me => '1' }
+                end
+
+                should_set_the_flash_to /success/i
+                should_redirect_to "@controller.send(:url_after_create)"
+                should_return_from_session :user_id, "@user.id"
+                
+                should 'set the cookie' do
+                  assert ! cookies['auth_token'].empty?
+                end
+
+                should 'set the remember me token in users table' do
+                  assert_not_nil @user.reload.remember_token
+                  assert_not_nil @user.reload.remember_token_expires_at
+                end
+              end
+              
+              context "a POST to #create with bad credentials and remember me" do
+                setup do
+                  post :create, :session => { :email => @user.email, 
+                    :password => "bad value", :remember_me => '1' }
+                end
+
+                should_set_the_flash_to /bad/i
+                should_render_template :new
+                should_return_from_session :user_id, "nil"
+                
+                should 'not create the cookie' do
+                  assert_nil cookies['auth_token']
+                end
+
+                should 'not set the remember me token in users table' do
+                  assert_nil @user.reload.remember_token
+                  assert_nil @user.reload.remember_token_expires_at
+                end
+              end
+            end
+
+            public_context do
+              context "logging out again" do
+                setup { delete :destroy }
+                should_redirect_to '@controller.send(:url_after_destroy)'
+              end
+            end
+
+            logged_in_user_context do
+              context "a DELETE to #destroy without a cookie" do
+                setup { delete :destroy }
+
+                should_set_the_flash_to(/logged out/i)
+                should_redirect_to '@controller.send(:url_after_destroy)'
+              end
+
+              context 'a DELETE to #destroy with a cookie' do
+                setup do
+                  cookies['auth_token'] = CGI::Cookie.new 'token', 'value'
+                  delete :destroy
+                end
+
+                should 'delete the cookie' do
+                  assert cookies['auth_token'].empty?
+                end
+
+                should 'delete the remember me token in users table' do
+                  assert_nil @user.reload.remember_token
+                  assert_nil @user.reload.remember_token_expires_at
+                end
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/clearance/test/functional/users_controller_test.rb

@@ -0,0 +1,203 @@
+module Clearance
+  module Test
+    module Functional
+      module UsersControllerTest
+
+        def self.included(base)
+          base.class_eval do
+            public_context do
+
+              context "on GET to /users/new" do
+                setup { get :new }
+                should_respond_with :success
+                should_render_template :new
+                should_not_set_the_flash
+                should_have_form :action => "users_path",
+                  :method => :post,
+                  :fields => { :email => :text,
+                    :password => :password,
+                    :password_confirmation => :password }
+
+                context "with params" do
+                  setup do
+                    @email = 'a@example.com'
+                    get :new, :user => {:email => @email}
+                  end
+
+                  should_assign_to :user
+                  should "set the @user's params" do
+                    assert_equal @email, assigns(:user).email
+                  end
+                end
+              end
+
+              context "on POST to /users" do
+                setup do
+                  @email = Factory.next(:email)
+                  post :create, :user => {
+                    :email => @email,
+                    :password => 'skerit',
+                    :password_confirmation => 'skerit'
+                  }
+                end
+            
+                should_set_the_flash_to /confirm/i
+                should_redirect_to "@controller.send(:url_after_create)"
+                should_assign_to :user
+                should_change 'User.count', :by => 1
+                
+                should 'have a confirmation code' do
+                  assert_not_nil User.find_by_email(@email).confirmation_code
+                end
+              end
+
+            end
+
+            logged_in_user_context do
+              context "GET to new" do
+                setup { get :new }
+                should_render_template 'new'
+              end
+
+              context "POST to create" do
+                setup { post :create, :user => {} }
+                should_render_template 'new'
+              end
+
+              should_filter_params :password
+            end
+            
+            public_context do
+              context 'A GET to #edit_password when not logged in' do
+                setup do
+                  @user = Factory(:user)
+                  @user.confirm!
+                  get :edit_password, :id => @user.id
+                end
+                
+                should_respond_with :redirect
+
+                should_redirect_to "new_session_path"
+              end
+
+              context 'A PUT to #change_password when not logged in' do
+                setup do
+                  @user = Factory(:user)
+                  @user.confirm!
+                  @new_password = 'new_password'
+                  put(:change_password,
+                      :id  => @user.id,
+                      :user => { :old_password => 'password',
+                      :password => @new_password,
+                      :password_confirmation => @new_password })
+                end
+
+                should_respond_with :redirect
+
+                should_redirect_to "new_session_path"
+              end
+            end
+            
+            logged_in_user_context do
+              context 'A GET to #edit_password' do
+                setup do
+                  @user.confirm!
+                  get :edit_password, :id => @user.id
+                end
+
+                should 'find the user' do
+                  assert_equal @user, assigns(:user)
+                end
+
+                should_respond_with :success
+                should_render_template "edit_password"
+
+                should "have a form for the user's email, password, and password confirm" do
+                  update_path = ERB::Util.h(change_password_user_path(:id => @user))
+
+                  assert_select 'form[action=?]', update_path do
+                    assert_select 'input[name=_method][value=?]', 'put'
+                    assert_select 'input[name=?][type=password]', 'user[old_password]'
+                    assert_select 'input[name=?]', 'user[password]'
+                    assert_select 'input[name=?]', 'user[password_confirmation]'
+                  end
+                end
+              end
+
+              context 'A PUT to #change_password' do
+                setup do
+                  @user.confirm!
+                  @new_password = 'new_password'
+                  @encrypted_new_password = Digest::SHA1.hexdigest("--#{@user.salt}--#{@new_password}--")
+                  assert_not_equal @encrypted_new_password, @user.crypted_password
+                end
+
+                context 'with an existing user with a matching password and password confirmation' do
+                  setup do
+                    put(:change_password,
+                        :id  => @user.id,
+                        :user => { :old_password => 'password',
+                        :password => @new_password,
+                        :password_confirmation => @new_password })
+                    @user.reload
+                  end
+
+                  should "update the user's password" do
+                    assert_equal @encrypted_new_password, @user.crypted_password
+                  end
+
+                  should 'remove the reset_password_code' do
+                    assert_nil @user.reset_password_code
+                  end
+
+                  should_return_from_session :user_id, "@user.id"
+
+                  should_redirect_to "user_path(@user)"
+                end
+
+                context 'with a blank old_password' do
+                  setup do
+                    put(:change_password,
+                        :id => @user.id,
+                        :user => {:old_password => '',
+                        :password => @new_password,
+                        :password_confirmation => @new_password})
+                    @user.reload
+                  end
+
+                  should "not update the user's password" do
+                    assert_not_equal @encrypted_new_password, @user.crypted_password
+                  end
+
+                  should_return_from_session :user_id, "@user.id"
+
+                  should_render_template "edit_password"
+                end
+
+                context 'with password but blank password confirmation' do
+                  setup do
+                    put(:change_password,
+                        :id => @user.id,
+                        :user => {:old_password => 'password',
+                        :password => @new_password,
+                        :password_confirmation => ''})
+                    @user.reload
+                  end
+
+                  should "not update the user's password" do
+                    assert_not_equal @encrypted_new_password, @user.crypted_password
+                  end
+
+                  should_return_from_session :user_id, "@user.id"
+
+                  should_render_template "edit_password"
+                end
+              end
+            end
+            
+          end
+        end
+      end
+    end
+  end
+end