gsterndale-warrant 0.2.0 → 0.3.0

data/test/rails_root/vendor/gems/thoughtbot-clearance-0.4.0/lib/clearance/test/functional/users_controller_test.rb

@@ -1,85 +0,0 @@
-module Clearance
-  module Test
-    module Functional
-      module UsersControllerTest
-
-        def self.included(controller_test)
-          controller_test.class_eval do
-            
-            should_filter_params :password
-            
-            public_context 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
-                    assert_select "input[type=text][name=?]", 
-                      "user[email]", true, "There must be an email field"
-                    assert_select "input[type=password][name=?]", 
-                      "user[password]", true, "There must be a password field"
-                    assert_select "input[type=password][name=?]", 
-                      "user[password_confirmation]", true, "There must be a password confirmation field"                      
-                    assert_select "input[type=submit]", true, 
-                      "There must be a submit button"
-                 end
-                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 "set assigned user's email" do
-                  assert_equal @email, assigns(:user).email
-                end
-              end
-
-              context "Given valid attributes when creating a new user" do
-                setup do
-                  user_attributes = Factory.attributes_for(:registered_user)
-                  post :create, :user => user_attributes
-                end
-            
-                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
-
-            signed_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
-            end
-          
-          end
-        end
-      end
-    end
-  end
-end

data/test/rails_root/vendor/gems/thoughtbot-clearance-0.4.0/lib/clearance/test/test_helper.rb

@@ -1,28 +0,0 @@
-module Clearance 
-  module Test
-    module TestHelper
-    
-      def self.included(test_helper)
-        test_helper.class_eval do
-          
-          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 sign_out 
-            @request.session[:user_id] = nil
-            @request.session[:salt]    = nil
-          end
-          
-        end
-      end
- 
-    end 
-  end
-end

data/test/rails_root/vendor/gems/thoughtbot-clearance-0.4.0/lib/clearance/test/unit/clearance_mailer_test.rb

@@ -1,65 +0,0 @@
-module Clearance
-  module Test
-    module Unit
-      module ClearanceMailerTest
-  
-        def self.included(mailer_test)
-          mailer_test.class_eval do
-            
-            context "A change password email" do
-              setup do
-                @user  = Factory(:registered_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.encrypted_password}}
-                assert_match regexp, @email.body
-              end
-
-              should "be sent to the user" do
-                assert_equal [@user.email], @email.to
-              end
-
-              should "set its subject" do
-                assert_match /Change your password/, @email.subject
-              end
-            end
-            
-            context "A confirmation email" do
-              setup do
-                @user  = Factory(:registered_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_match /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/test/rails_root/vendor/gems/thoughtbot-clearance-0.4.0/lib/clearance/test/unit/user_test.rb

@@ -1,163 +0,0 @@
-module Clearance
-  module Test
-    module Unit
-      module UserTest
-    
-        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)
-
-                  @user     = Factory(:registered_user, :salt => @salt)
-                  @password = @user.password
-
-                  @user.encrypt(@password)
-                  @expected = Digest::SHA512.hexdigest("--#{@salt}--#{@password}--")
-                end
-
-                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(:registered_user)
-                assert ! @user.email_confirmed?
-              end
-
-              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
-              setup do
-                @user     = Factory(:registered_user)
-                @password = @user.password
-              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')
-                assert ! @user.authenticated?('horribly_wrong_password')
-              end
-            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
-
-              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 user when token expires in the future" do
-                @user.update_attribute :remember_token_expires_at, 
-                  2.weeks.from_now.utc
-                assert @user.remember?
-              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! }
-
-                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 user" do
-                  assert ! @user.remember?
-                end
-              end
-            end
-            
-            # updating password
-            
-            context "An email confirmed user" do
-              setup { @user = Factory(:email_confirmed_user) }
-
-              context "who changes and confirms password" do
-                setup do
-                  @user.password              = "new_password"
-                  @user.password_confirmation = "new_password"
-                  @user.save
-                end
-
-                should_change "@user.encrypted_password"
-              end
-            end
-          
-          end
-        end
-
-      end
-    end
-  end
-end

data/test/rails_root/vendor/gems/thoughtbot-clearance-0.4.0/rails/init.rb

@@ -1 +0,0 @@
-require 'clearance'

data/test/rails_root/vendor/gems/thoughtbot-clearance-0.4.0/shoulda_macros/clearance.rb

@@ -1,173 +0,0 @@
-module Clearance 
-  module Shoulda
-
-    # STATE OF AUTHENTICATION
-
-    def should_be_signed_in_as(&block)
-      should "be signed in as #{block.bind(self).call}" do
-        user = block.bind(self).call
-        assert_not_nil user, 
-          "please pass a User. try: should_be_signed_in_as { @user }"
-        assert_equal user.id,   session[:user_id], 
-          "session[:user_id] is not set to User's id"
-        assert_equal user.salt, session[:salt], 
-          "session[:salt] is not set to User's salt"
-      end
-    end
-
-    def should_be_signed_in_and_email_confirmed_as(&block)
-      should_be_signed_in_as &block
-      
-      should "have confirmed email" do
-        user = block.bind(self).call
-        
-        assert_not_nil user
-        assert_equal user, assigns(:user)
-        assert assigns(:user).email_confirmed?
-      end
-    end
-    
-    def should_not_be_signed_in
-      should "not be signed in" do
-        assert_nil session[:user_id]
-        assert_nil session[:salt]
-      end
-    end
-
-    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 = {})
-      if opts[:flash]
-        should_set_the_flash_to opts[:flash]
-      else
-        should_not_set_the_flash
-      end
-      
-      should "respond with 401 Unauthorized and render sign_in template" do
-        assert_response :unauthorized, 
-          "access was expected to be denied (401 unauthorized)"
-        assert_template "sessions/new",
-          "template was expected to be sign in (sessions/new)"
-      end
-    end
-    
-    # CONTEXTS
-
-    def signed_in_user_context(&blk)
-      context "A signed in user" do
-        setup do
-          @user = Factory(:registered_user)
-          @user.confirm_email!
-          sign_in_as @user
-        end
-        merge_block(&blk)
-      end
-    end
-
-    def public_context(&blk)
-      context "The public" do
-        setup { sign_out }
-        merge_block(&blk)
-      end
-    end
-    
-    # CREATING USERS
-    
-    def should_create_user_successfully
-      should_assign_to :user
-      should_change 'User.count', :by => 1
-      
-      should "send the confirmation email" do
-        assert_sent_email do |email|
-          email.subject =~ /account confirmation/i
-        end
-      end
-      
-      should_set_the_flash_to /confirm/i
-      should_redirect_to_url_after_create
-    end
-    
-    # RENDERING
-    
-    def should_render_nothing
-      should "render nothing" do
-        assert @response.body.blank?
-      end
-    end
-    
-    # REDIRECTS
-    
-    def should_redirect_to_url_after_create
-      should_redirect_to "@controller.send(:url_after_create)"
-    end
-    
-    def should_redirect_to_url_after_update
-      should_redirect_to "@controller.send(:url_after_update)"
-    end
-    
-    def should_redirect_to_url_after_destroy
-      should_redirect_to "@controller.send(:url_after_destroy)"
-    end
-    
-    # VALIDATIONS
-    
-    def should_validate_confirmation_of(attribute, opts = {})
-      raise ArgumentError if opts[:factory].nil?
-      
-      context "on save" do  
-        should_validate_confirmation_is_not_blank opts[:factory], attribute
-        should_validate_confirmation_is_not_bad   opts[:factory], attribute
-      end
-    end
-    
-    def should_validate_confirmation_is_not_blank(factory, attribute, opts = {})
-      should "validate #{attribute}_confirmation is not blank" do
-        model = Factory.build(factory, blank_confirmation_options(attribute))
-        model.save
-        assert_confirmation_error(model, attribute, 
-          "#{attribute}_confirmation cannot be blank")
-      end
-    end
-    
-    def should_validate_confirmation_is_not_bad(factory, attribute, opts = {})
-      should "validate #{attribute}_confirmation is different than #{attribute}" do
-        model = Factory.build(factory, bad_confirmation_options(attribute))
-        model.save
-        assert_confirmation_error(model, attribute, 
-          "#{attribute}_confirmation cannot be different than #{attribute}")
-      end
-    end
-    
-  end
-end
-
-module Clearance
-  module Shoulda
-    module Helpers
-      def blank_confirmation_options(attribute)
-        opts = { attribute => attribute.to_s }
-        opts.merge("#{attribute}_confirmation".to_sym => "")
-      end
-      
-      def bad_confirmation_options(attribute)
-        opts = { attribute => attribute.to_s }
-        opts.merge("#{attribute}_confirmation".to_sym => "not_#{attribute}")
-      end
-      
-      def assert_confirmation_error(model, attribute, message = "confirmation error")
-        assert model.errors.on(attribute).include?("doesn't match confirmation"), 
-          message
-      end
-    end
-  end
-end
-
-class Test::Unit::TestCase
-  include Clearance::Shoulda::Helpers
-end
-Test::Unit::TestCase.extend(Clearance::Shoulda)