gravis-clearance 0.3.7

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

@@ -0,0 +1,67 @@
+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
+                  post :create, :user => Factory.build(:user).attributes.merge(
+                                            {: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
+              end
+
+            end
+
+            logged_in_user_context do
+              context "GET to new" do
+                setup { get :new }
+                should_redirect_to 'root_url'
+              end
+
+              context "POST to create" do
+                setup { post :create, :user => {} }
+                should_redirect_to 'root_url'
+              end
+
+              should_filter_params :password
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/clearance/test/test_helper.rb

@@ -0,0 +1,94 @@
+module Clearance 
+  module Test
+    module TestHelper
+    
+      def self.included(base)
+        base.class_eval do
+          include InstanceMethods
+          extend ClassMethods
+        end
+      end
+
+      module InstanceMethods
+        def login_as(user = nil)
+          user ||= Factory(:user)
+          @request.session[:user_id] = user.id
+          return user
+        end
+
+        def logout 
+          @request.session[:user_id] = nil
+        end
+      end
+    
+      module ClassMethods
+        def should_deny_access_on(command, opts = {})
+
+          context "on #{command}" do
+            setup { eval command }
+            should_deny_access(opts)
+          end
+        end
+
+        def should_deny_access(opts = {})
+          opts[:redirect] ||= "new_session_path"
+          should_redirect_to opts[:redirect]
+          if opts[:flash]
+            should_set_the_flash_to opts[:flash]
+          else
+            should_not_set_the_flash
+          end
+        end
+      
+        # should_have_form :action => 'admin_users_path',
+        #   :method => :get, 
+        #   :fields => { 'email' => :text }
+        # TODO: http_method should be pulled out
+        def should_have_form(opts)
+          model = self.name.gsub(/ControllerTest$/, '').singularize.downcase
+          model = model[model.rindex('::')+2..model.size] if model.include?('::')
+          http_method, hidden_http_method = form_http_method opts[:method]
+          should "have a #{model} form" do
+            assert_select "form[action=?][method=#{http_method}]", eval(opts[:action]) do
+              if hidden_http_method
+                assert_select "input[type=hidden][name=_method][value=#{hidden_http_method}]"
+              end
+              opts[:fields].each do |attribute, type|
+                attribute = attribute.is_a?(Symbol) ? "#{model}[#{attribute.to_s}]" : attribute
+                assert_select "input[type=#{type.to_s}][name=?]", attribute
+              end
+              assert_select "input[type=submit]"
+            end
+          end
+        end
+      
+        def form_http_method(http_method)
+          http_method = http_method.nil? ? 'post' : http_method.to_s
+          if http_method == "post" || http_method == "get"
+            return http_method, nil
+          else
+            return "post", http_method
+          end
+        end
+      
+        def logged_in_user_context(&blk)
+          context "A logged in user" do
+            setup do
+              @user = Factory :user
+              login_as @user
+            end
+            merge_block(&blk)
+          end
+        end
+      
+        def public_context(&blk)
+          context "The public" do
+            setup { logout }
+            merge_block(&blk)
+          end
+        end
+      end
+ 
+    end 
+  end
+end

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

@@ -0,0 +1,63 @@
+module Clearance
+  module Test
+    module Unit
+      module ClearanceMailerTest
+  
+        def self.included(base)
+          base.class_eval do
+            context "A change password email" do
+              setup do
+                @user = Factory :user
+                @email = ClearanceMailer.create_change_password @user
+              end
+
+              should "set its from address to DO_NOT_REPLY" do
+                assert_equal DO_NOT_REPLY, @email.from[0]
+              end
+
+              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}}
+                assert_match regexp, @email.body
+              end
+
+              should "be sent to the user" do
+                assert_equal [@user.email], @email.to
+              end
+
+              should "have a subject of '[PROJECT_NAME] Change your password'" do
+                assert_equal @email.subject, "[#{PROJECT_NAME.humanize}] Change your password"
+              end
+            end
+            
+            context "A confirmation email" do
+              setup do
+                @user = Factory :user
+                @email = ClearanceMailer.create_confirmation @user
+              end
+
+              should 'set its recipient to the given user' do
+                assert_equal @user.email, @email.to[0]
+              end
+
+              should 'set its subject' do
+                assert_equal "[#{PROJECT_NAME.humanize}] Account confirmation", @email.subject
+              end
+
+              should 'set its from address to DO_NOT_REPLY' do
+                assert_equal DO_NOT_REPLY, @email.from[0]
+              end
+
+              should "contain a link to confirm the user's account" do
+                host = ActionMailer::Base.default_url_options[:host]
+                regexp = %r{http://#{host}/users/#{@user.id}/confirmation/new\?salt=#{@user.salt}}
+                assert_match regexp, @email.body
+              end
+            end
+          end
+        end
+
+      end
+    end  
+  end
+end

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

@@ -0,0 +1,222 @@
+module Clearance
+  module Test
+    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'
+
+            should "require password validation on create" do
+              user = Factory.build(:user, :password => 'blah', :password_confirmation => 'boogidy')
+              assert !user.save
+              assert_match(/confirmation/i, user.errors.on(:password))
+            end
+
+            should "create a crypted_password on save" do
+              assert_not_nil Factory(:user, :crypted_password => nil).crypted_password
+            end
+
+            context 'updating a password' do
+              setup do
+                @user = Factory(: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
+              end
+
+              should 'update a crypted_password' do
+                @user.reload
+                assert @user.crypted_password != @crypt
+              end
+            end
+        
+            context 'A user' do
+              setup do
+                @salt = 'salt'
+                User.any_instance.stubs(:initialize_salt)
+                @user = Factory :user, :salt => @salt
+                @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
+          
+              context 'authenticating a user' do
+                context 'with good credentials' do
+                  setup do
+                    @result = User.authenticate @user.email, @password
+                  end
+
+                  should 'return true' do
+                    assert @result
+                  end
+                end
+
+                context 'with bad credentials' do
+                  setup do
+                    @result = User.authenticate @user.email, 'horribly_wrong_password'
+                  end
+
+                  should 'return false' do
+                    assert !@result
+                  end
+                end
+                
+                context 'with an upcase email' do
+                  setup do
+                    @result = User.authenticate @user.email.upcase, @password
+                  end
+
+                  should 'return true' do
+                    assert @result
+                  end
+                end
+                
+              end
+          
+              context 'authenticated?' do
+                context 'with good credentials' do
+                  setup do
+                    @result = @user.authenticated? @password
+                  end
+
+                  should 'return true' do
+                    assert @result
+                  end
+                end
+
+                context 'with bad credentials' do
+                  setup do
+                    @result = @user.authenticated? 'horribly_wrong_password'
+                  end
+
+                  should 'return false' do
+                    assert !@result
+                  end
+                end
+              end
+
+              context 'encrypt' do
+                setup do
+                  @crypted  = @user.encrypt(@password)
+                  @expected = Digest::SHA1.hexdigest("--#{@salt}--#{@password}--")
+                end
+
+                should 'create a Hash using SHA1 encryption' do
+                  assert_equal @expected, @crypted
+                  assert_not_equal @password, @crypted
+                end
+              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 do
+                    @user.forget_me!
+                  end
+
+                  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
+              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
+              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
+              end
+
+              context "When sent authenticate with an invalid email and password" do
+                setup do
+                  @found_user = User.authenticate "not", "valid" 
+                end
+
+                should "find nothing" do
+                  assert_nil @found_user
+                end
+              end
+            end
+
+            context "A user" do
+              setup do
+                @user = Factory :user
+              end
+
+              context 'when sent #confirm!' do
+                setup do
+                  assert ! @user.confirmed?
+                  assert @user.confirm!
+                  @user.reload
+                end
+
+                should 'mark the User record as confirmed' do
+                  assert @user.confirmed?
+                end
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/clearance/version.rb

@@ -0,0 +1,7 @@
+  module Clearance
+    module Version
+      MAJOR = 0
+      MINOR = 3
+      PATCH = 6
+    end
+  end