thoughtbot-clearance 0.3.8 → 0.3.9

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

@@ -3,15 +3,19 @@ module Clearance
     module Functional
       module UsersControllerTest
 
-        def self.included(base)
-          base.class_eval do
+        def self.included(controller_test)
+          controller_test.class_eval do
+            
+            should_filter_params :password
+            
             public_context do
-
-              context "on GET to /users/new" do
+              context "When getting new User view" do
                 setup { get :new }
+                
                 should_respond_with :success
                 should_render_template :new
                 should_not_set_the_flash
+                
                 should "display a form to register" do
                  assert_select "form[action=#{users_path}][method=post]", 
                   true, "There must be a form to register" do
@@ -25,48 +29,54 @@ module Clearance
                       "There must be a submit button"
                  end
                 end
-                
-                context "with params" do
-                  setup do
-                    @email = 'a@example.com'
-                    get :new, :user => {:email => @email}
-                  end
+              end
+              
+              context "Given email parameter when getting new User view" 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
+                should "set assigned user's email" do
+                  assert_equal @email, assigns(:user).email
                 end
               end
 
-              context "on POST to /users" do
+              context "Given valid attributes when creating a new user" do
                 setup do
-                  post :create, :user => Factory.build(:clearance_user).attributes.merge(
-                                            {:password => 'skerit',
-                                              :password_confirmation => 'skerit'})
+                  user_attributes = Factory.attributes_for(:registered_user)
+                  post :create, :user => user_attributes
                 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_create_user_successfully
+              end
+              
+              context "Given valid email confirmation attributes when creating a new user" do
+                setup do
+                  user_attributes = Factory.attributes_for(:email_confirmed_user)
+                  post :create, :user => user_attributes
+                end
+            
+                should_create_user_successfully
+                
+                should "not confirm email" do
+                  assert ! assigns(:user).email_confirmed
+                end
               end
-
             end
 
-            logged_in_user_context do
+            signed_in_user_context do
               context "GET to new" do
                 setup { get :new }
-                should_redirect_to 'root_url'
+                should_redirect_to "root_url"
               end
 
               context "POST to create" do
                 setup { post :create, :user => {} }
-                should_redirect_to 'root_url'
+                should_redirect_to "root_url"
               end
-
-              should_filter_params :password
             end
+          
           end
         end
       end

data/lib/clearance/test/test_helper.rb

@@ -5,14 +5,19 @@ module Clearance
       def self.included(test_helper)
         test_helper.class_eval do
           
-          def login_as(user = nil)
-            user ||= Factory(:clearance_user)
+          def sign_in_as(user = nil)
+            unless user
+              user = Factory(:registered_user)
+              user.confirm_email!
+            end
             @request.session[:user_id] = user.id
+            @request.session[:salt]    = user.salt
             return user
           end
 
           def logout 
             @request.session[:user_id] = nil
+            @request.session[:salt]    = nil
           end
           
         end

data/lib/clearance/test/unit/clearance_mailer_test.rb

@@ -3,11 +3,12 @@ module Clearance
     module Unit
       module ClearanceMailerTest
   
-        def self.included(base)
-          base.class_eval do
+        def self.included(mailer_test)
+          mailer_test.class_eval do
+            
             context "A change password email" do
               setup do
-                @user = Factory :clearance_user
+                @user  = Factory(:registered_user)
                 @email = ClearanceMailer.create_change_password @user
               end
 
@@ -17,7 +18,7 @@ module Clearance
 
               should "contain a link to edit the user's password" do
                 host = ActionMailer::Base.default_url_options[:host]
-                regexp = %r{http://#{host}/users/#{@user.id}/password/edit\?email=#{@user.email.gsub("@", "%40")}&password=#{@user.crypted_password}}
+                regexp = %r{http://#{host}/users/#{@user.id}/password/edit\?email=#{@user.email.gsub("@", "%40")}&password=#{@user.encrypted_password}}
                 assert_match regexp, @email.body
               end
 
@@ -32,7 +33,7 @@ module Clearance
             
             context "A confirmation email" do
               setup do
-                @user = Factory :clearance_user
+                @user  = Factory(:registered_user)
                 @email = ClearanceMailer.create_confirmation @user
               end
 
@@ -54,6 +55,7 @@ module Clearance
                 assert_match regexp, @email.body
               end
             end
+          
           end
         end
 

data/lib/clearance/test/unit/user_test.rb

@@ -3,188 +3,157 @@ module Clearance
     module Unit
       module UserTest
     
-        def self.included(base)
-          base.class_eval do
-            should_require_attributes   :email, :password
-            should_allow_values_for     :email, 'foo@example.com'
-            should_not_allow_values_for :email, 'foo'
-            should_not_allow_values_for :email, 'example.com'
+        def self.included(unit_test)
+          unit_test.class_eval do
+            
+            # registering
+            
+            context "When registering" do
+              should_require_attributes        :email
+              should_allow_values_for          :email, "foo@example.com"
+              should_not_allow_values_for      :email, "foo"
+              should_not_allow_values_for      :email, "example.com"
+              
+              should_validate_confirmation_of  :password, 
+                :factory => :registered_user
+              
+              should "initialize salt" do
+                assert_not_nil Factory(:registered_user).salt
+              end
+              
+              context "encrypt password" do
+                setup do
+                  @salt = "salt"
+                  User.any_instance.stubs(:initialize_salt)
 
-            should "require password validation on create" do
-              user = Factory.build(:clearance_user, :password => 'blah', :password_confirmation => 'boogidy')
-              assert !user.save
-              assert_match(/confirmation/i, user.errors.on(:password))
-            end
+                  @user     = Factory(:registered_user, :salt => @salt)
+                  @password = @user.password
 
-            should "create a crypted_password on save" do
-              assert_not_nil Factory(:clearance_user, :crypted_password => nil).crypted_password
-            end
+                  @user.encrypt(@password)
+                  @expected = Digest::SHA512.hexdigest("--#{@salt}--#{@password}--")
+                end
 
-            context 'updating a password' do
+                should "create an encrypted password using SHA512 encryption" do
+                  assert_equal     @expected, @user.encrypted_password
+                  assert_not_equal @password, @user.encrypted_password
+                end
+              end
+              
+              should "store email in lower case" do
+                user = Factory(:registered_user, :email => "John.Doe@example.com")
+                assert_equal "john.doe@example.com", user.email
+              end
+            end
+            
+            context "When multiple users have registerd" do
+              setup { @user = Factory(:registered_user) }
+              
+              should_require_unique_attributes :email
+            end
+            
+            # confirming email
+            
+            context "A registered user without email confirmation" do
               setup do
-                @user = Factory(:clearance_user)
-                assert_not_nil @user.crypted_password
-                @crypt = @user.crypted_password
-                assert_not_nil @user.salt
-                @salt = @user.salt
-                @user.password = 'a_new_password'
-                @user.password_confirmation = 'a_new_password'
-                assert @user.save
+                @user = Factory(:registered_user)
+                assert ! @user.email_confirmed?
               end
 
-              should 'update a crypted_password' do
-                @user.reload
-                assert @user.crypted_password != @crypt
+              context "after #confirm_email!" do
+                setup do
+                  assert @user.confirm_email!
+                  @user.reload
+                end
+
+                should "have confirmed their email" do
+                  assert @user.email_confirmed?
+                end
               end
             end
+            
+            # authenticating
         
-            context 'A user' do
+            context "A user" do
               setup do
-                @salt = 'salt'
-                User.any_instance.stubs(:initialize_salt)
-                
-                @user     = Factory(:clearance_user, :salt => @salt)
+                @user     = Factory(:registered_user)
                 @password = @user.password
               end
-          
-              should "require password validation on update" do
-                @user.update_attributes :password => "blah", 
-                  :password_confirmation => "boogidy"
-                assert !@user.save
-                assert_match(/confirmation/i, @user.errors.on(:password))
-              end
-          
-              should_require_unique_attributes :email
-              
-              should 'store email in lower case' do
-                @user.update_attributes(:email => 'John.Doe@example.com')
-                assert_equal 'john.doe@example.com', @user.email
-              end
               
               should "authenticate with good credentials" do
                 assert User.authenticate(@user.email, @password)
+                assert @user.authenticated?(@password)
               end
               
               should "authenticate with good credentials, email in uppercase" do
                 assert User.authenticate(@user.email.upcase, @password)
+                assert @user.authenticated?(@password)
               end
               
               should "not authenticate with bad credentials" do
                 assert ! User.authenticate(@user.email, 'horribly_wrong_password')
-              end
-              
-              should "be authenticated with a good password" do
-                assert @user.authenticated?(@password)
-              end
-              
-              should "not be authenticated with a bad password" do
                 assert ! @user.authenticated?('horribly_wrong_password')
               end
+            end
 
-              context 'encrypt' do
-                setup do
-                  @crypted  = @user.encrypt(@password)
-                  @expected = Digest::SHA512.hexdigest("--#{@salt}--#{@password}--")
-                end
-
-                should 'create a Hash using SHA512 encryption' do
-                  assert_equal @expected, @crypted
-                  assert_not_equal @password, @crypted
-                end
+            # remember me
+            
+            context "When registering with remember_me!" do
+              setup do
+                @user = Factory(:registered_user)
+                assert_nil @user.remember_token
+                assert_nil @user.remember_token_expires_at
+                @user.remember_me!
               end
 
-              context 'remember_me!' do
-                setup do
-                  assert_nil @user.remember_token
-                  assert_nil @user.remember_token_expires_at
-                  @user.remember_me!
-                end
-
-                should 'set the remember token and expiration date' do
-                  assert_not_nil @user.remember_token
-                  assert_not_nil @user.remember_token_expires_at
-                end
-
-                should 'remember_token?' do
-                  assert @user.remember_token?
-                end
-
-                context 'forget_me!' do
-                  setup { @user.forget_me! }
-
-                  should 'unset the remember token and expiration date' do
-                    assert_nil @user.remember_token
-                    assert_nil @user.remember_token_expires_at
-                  end
-
-                  should 'not remember_token?' do
-                    assert ! @user.remember_token?
-                  end
-                end
+              should "set the remember token and expiration date" do
+                assert_not_nil @user.remember_token
+                assert_not_nil @user.remember_token_expires_at
               end
-
-              context 'remember_token?' do
-                context 'when token expires in the future' do
-                  setup do
-                    @user.update_attribute :remember_token_expires_at, 
-                      2.weeks.from_now.utc
-                  end
-
-                  should 'be true' do
-                    assert @user.remember_token?
-                  end
-                end
-
-                context 'when token expired' do
-                  setup do
-                    @user.update_attribute :remember_token_expires_at, 
-                      2.weeks.ago.utc
-                  end
-
-                  should 'be false' do
-                    assert ! @user.remember_token?
-                  end
-                end
+              
+              should "remember user when token expires in the future" do
+                @user.update_attribute :remember_token_expires_at, 
+                  2.weeks.from_now.utc
+                assert @user.remember?
               end
 
-              context "User.authenticate with a valid email and password" do
-                setup do
-                  @found_user = User.authenticate(@user.email, @user.password)
-                end
-
-                should "find that user" do
-                  assert_equal @user, @found_user
-                end
+              should "not remember user when token has already expired" do
+                @user.update_attribute :remember_token_expires_at, 
+                  2.weeks.ago.utc
+                assert ! @user.remember?
               end
+              
+              # logging out
+              
+              context "forget_me!" do
+                setup { @user.forget_me! }
 
-              context "When sent authenticate with an invalid email and password" do
-                setup do
-                  @found_user = User.authenticate("not", "valid")
+                should "unset the remember token and expiration date" do
+                  assert_nil @user.remember_token
+                  assert_nil @user.remember_token_expires_at
                 end
 
-                should "find nothing" do
-                  assert_nil @found_user
+                should "not remember user" do
+                  assert ! @user.remember?
                 end
               end
             end
+            
+            # updating password
+            
+            context "An email confirmed user" do
+              setup { @user = Factory(:email_confirmed_user) }
 
-            context "A user" do
-              setup do
-                @user = Factory(:clearance_user)
-              end
-
-              context 'when sent #confirm!' do
+              context "who changes and confirms password" do
                 setup do
-                  assert ! @user.confirmed?
-                  assert @user.confirm!
-                  @user.reload
+                  @user.password              = "new_password"
+                  @user.password_confirmation = "new_password"
+                  @user.save
                 end
 
-                should 'mark the User record as confirmed' do
-                  assert @user.confirmed?
-                end
+                should_change "@user.encrypted_password"
               end
             end
+          
           end
         end