gsterndale-warrant 0.2.0 → 0.3.0

data/test/rails_root/vendor/gems/thoughtbot-clearance-0.4.0/lib/clearance/app/models/clearance_mailer.rb

@@ -1,29 +0,0 @@
-module Clearance
-  module App
-    module Models
-      module ClearanceMailer
-    
-        def self.included(mailer)
-          mailer.class_eval do
-        
-            def change_password(user)
-              from       DO_NOT_REPLY
-              recipients user.email
-              subject    "Change your password"
-              body       :user => user
-            end
-
-            def confirmation(user)
-              from       DO_NOT_REPLY
-              recipients user.email
-              subject   "Account confirmation"
-              body      :user => user
-            end
-        
-          end
-        end
-        
-      end
-    end
-  end
-end

data/test/rails_root/vendor/gems/thoughtbot-clearance-0.4.0/lib/clearance/app/models/user.rb

@@ -1,85 +0,0 @@
-require 'digest/sha2'
-
-module Clearance
-  module App
-    module Models
-      module User
-    
-        def self.included(model)
-          model.class_eval do
-        
-            attr_accessible :email, :password, :password_confirmation
-            attr_accessor :password, :password_confirmation
-
-            validates_presence_of     :email
-            validates_presence_of     :password, :if => :password_required?
-            validates_confirmation_of :password, :if => :password_required?
-            validates_uniqueness_of   :email, :case_sensitive => false
-            validates_format_of       :email, :with => %r{.+@.+\..+}
-
-            before_save :initialize_salt, :encrypt_password, :downcase_email
-        
-            def self.authenticate(email, password)
-              user = find(:first, :conditions => ['LOWER(email) = ?', email.to_s.downcase])
-              user && user.authenticated?(password) ? user : nil
-            end
-
-            def authenticated?(password)
-              encrypted_password == encrypt(password)
-            end
-
-            def encrypt(string)
-              Digest::SHA512.hexdigest("--#{salt}--#{string}--")
-            end
-
-            def remember?
-              remember_token_expires_at && Time.now.utc < remember_token_expires_at
-            end
-
-            def remember_me!
-              remember_me_until 2.weeks.from_now.utc
-            end
-
-            def remember_me_until(time)
-              self.update_attribute :remember_token_expires_at, time
-              self.update_attribute :remember_token, 
-                encrypt("--#{remember_token_expires_at}--#{password}--")
-            end
-
-            def forget_me!
-              self.update_attribute :remember_token_expires_at, nil
-              self.update_attribute :remember_token, nil
-            end
-
-            def confirm_email!
-              self.update_attribute :email_confirmed, true
-            end
-        
-            protected
-
-            def initialize_salt
-              if new_record?
-                self.salt = encrypt("--#{Time.now.utc.to_s}--#{password}--")
-              end
-            end
-
-            def encrypt_password
-              return if password.blank?
-              self.encrypted_password = encrypt(password)
-            end
-
-            def password_required?
-              encrypted_password.blank? || !password.blank?
-            end
-            
-            def downcase_email
-              self.email = email.to_s.downcase
-            end
-        
-          end
-        end
-  
-      end
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-module Clearance
-  module Test
-    module Functional
-      module ConfirmationsControllerTest
-
-        def self.included(controller_test)
-          controller_test.class_eval do
-            
-            should_filter_params :salt
-            
-            context "Given a user whose email has not been confirmed" do
-              setup { @user = Factory(:registered_user) }
-              
-              context "on GET to #new with correct id and salt" do
-                setup do
-                  get :new, :user_id => @user.to_param, :salt => @user.salt
-                end
-
-                should_set_the_flash_to /confirmed email/i
-                should_set_the_flash_to /signed in/i
-                should_be_signed_in_and_email_confirmed_as { @user }
-                should_redirect_to_url_after_create
-              end
-              
-              context "on GET to #new with incorrect salt" do
-                setup do
-                  salt = ""
-                  assert_not_equal salt, @user.salt
-
-                  get :new, :user_id => @user.to_param, :salt => salt
-                end
-
-                should_respond_with :not_found
-                should_render_nothing
-              end
-            end
-          
-          end
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,175 +0,0 @@
-module Clearance
-  module Test
-    module Functional
-      module PasswordsControllerTest
-
-        def self.included(controller_test)
-          controller_test.class_eval do
-
-            should_route :get, '/users/1/password/edit', 
-              :action  => 'edit', :user_id => '1'
-
-            context 'with a user' do
-              setup { @user = Factory(:registered_user) }
-
-              context 'A GET to #new' do
-                setup { get :new, :user_id => @user.to_param }
-
-                should_respond_with :success
-                should_render_template "new"
-              end
-
-              context "A POST to #create" do
-                context "with an existing user's email address" do
-                  setup do
-                    ActionMailer::Base.deliveries.clear
-
-                    post :create, :password => { :email => @user.email }
-                  end
-                  
-                  should "send the change your password email" do
-                    assert_sent_email do |email|
-                      email.subject =~ /change your password/i
-                    end
-                  end
-                  
-                  should "set a :notice flash with the user email address" do
-                    assert_match /#{@user.email}/, flash[:notice]
-                  end
-
-                  should_redirect_to_url_after_create
-                end
-
-                context "with a non-existent email address" do
-                  setup do
-                    email = "user1@example.com"
-                    assert ! User.exists?(['email = ?', email])
-                    ActionMailer::Base.deliveries.clear
-
-                    post :create, :password => { :email => email }
-                  end
-
-                  should "not send a password reminder email" do
-                    assert ActionMailer::Base.deliveries.empty?
-                  end
-
-                  should "set a :notice flash" do
-                    assert_not_nil flash.now[:notice]
-                  end
-
-                  should_render_template "new"
-                end
-              end
-
-              context "A GET to #edit" do
-                context "with an existing user's id and password" do
-                  setup do
-                    get :edit, 
-                      :user_id  => @user.to_param, 
-                      :password => @user.encrypted_password, 
-                      :email    => @user.email
-                  end
-
-                  should "find the user with the given id and password" 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(user_password_path(@user,
-                          :password => @user.encrypted_password,
-                          :email    => @user.email))
-
-                    assert_select 'form[action=?]', update_path do
-                      assert_select 'input[name=_method][value=?]', 'put'
-                      assert_select 'input[name=?]', 'user[password]'
-                      assert_select 'input[name=?]', 'user[password_confirmation]'
-                    end
-                  end
-                end
-
-                context "with an existing user's id but not password" do
-                  setup do
-                    get :edit, :user_id => @user.to_param, :password => ""
-                  end
-
-                  should_respond_with :not_found
-                  should_render_nothing
-                end
-              end
-
-              context "A PUT to #update" do
-                context "with an existing user's id but not password" do
-                  setup do
-                    put :update, :user_id => @user.to_param, :password => ""
-                  end
-
-                  should "not update the user's password" do
-                    assert_not_equal @encrypted_new_password, @user.encrypted_password
-                  end
-
-                  should_not_be_signed_in
-                  should_respond_with :not_found
-                  should_render_nothing
-                end
-
-                context "with a matching password and password confirmation" do
-                  setup do
-                    new_password = "new_password"
-                    @encrypted_new_password = @user.encrypt(new_password)
-                    assert_not_equal @encrypted_new_password, @user.encrypted_password
-
-                    put(:update,
-                        :user_id  => @user,
-                        :email    => @user.email,
-                        :password => @user.encrypted_password,
-                        :user => {
-                          :password              => new_password,
-                          :password_confirmation => new_password
-                        })
-                    @user.reload
-                  end
-
-                  should "update the user's password" do
-                    assert_equal @encrypted_new_password, @user.encrypted_password
-                  end
-
-                  should_be_signed_in_as { @user }
-                  should_redirect_to_url_after_update
-                end
-
-                context "with password but blank password confirmation" do
-                  setup do
-                    new_password = "new_password"
-                    @encrypted_new_password = @user.encrypt(new_password)
-
-                    put(:update,
-                        :user_id => @user.to_param,
-                        :password => @user.encrypted_password,
-                        :user => {
-                          :password => new_password,
-                          :password_confirmation => ''
-                        })
-                    @user.reload
-                  end
-
-                  should "not update the user's password" do
-                    assert_not_equal @encrypted_new_password, @user.encrypted_password
-                  end
-
-                  should_not_be_signed_in
-                  should_respond_with :not_found
-                  should_render_nothing
-                end
-              end
-            end
-          
-          end
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,194 +0,0 @@
-module Clearance
-  module Test
-    module Functional
-      module SessionsControllerTest
-    
-        def self.included(controller_test)
-          controller_test.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 'display a "sign in" form' do
-                assert_select "form[action=#{session_path}][method=post]", 
-                  true, "There must be a form to sign in" do
-                    assert_select "input[type=text][name=?]", 
-                      "session[email]", true, "There must be an email field"
-                    assert_select "input[type=password][name=?]", 
-                      "session[password]", true, "There must be a password field"
-                    assert_select "input[type=checkbox][name=?]", 
-                      "session[remember_me]", true, "There must be a 'remember me' check box"
-                    assert_select "input[type=submit]", true, 
-                      "There must be a submit button"
-                end                
-              end
-            end
-
-            context "Given a registered user" do
-              setup { @user = Factory(:registered_user) }
-
-              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)
-              end
-            end
-
-            context "Given an email confirmed user" do
-              setup { @user = Factory(:email_confirmed_user) }
-
-              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_url_after_create
-                should_be_signed_in_as { @user }
-              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_not_be_signed_in
-              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_url_after_create
-                should_be_signed_in_as { @user }
-                
-                should 'set the cookie' do
-                  assert ! cookies['remember_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['remember_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
-              
-              context "a POST to #create with good credentials and A URL to return back" do
-                context "in the session" do
-                  setup do
-                    @request.session[:return_to] = '/url_in_the_session'
-                    post :create, :session => { 
-                                    :email    => @user.email, 
-                                    :password => @user.password }                    
-                  end
-                  
-                  should_redirect_to "'/url_in_the_session'"
-                end
-                
-                context "in the request" do
-                  setup do
-                    post :create, :session => { 
-                                    :email => @user.email, 
-                                    :password => @user.password },
-                                   :return_to => '/url_in_the_request'                    
-                  end
-                  
-                  should_redirect_to "'/url_in_the_request'"
-                end   
-                             
-                context "in the request and in the session" do
-                  setup do
-                    @request.session[:return_to] = '/url_in_the_session'
-                    post :create, :session => { 
-                                    :email    => @user.email, 
-                                    :password => @user.password },
-                                  :return_to => '/url_in_the_request'                    
-                  end
-                  
-                  should_redirect_to "'/url_in_the_session'"
-                end
-              end              
-            end
-
-            public_context do
-              context "logging out again" do
-                setup { delete :destroy }
-                should_redirect_to_url_after_destroy
-              end
-            end
-
-            signed_in_user_context do
-              context "a DELETE to #destroy without a cookie" do
-                setup { delete :destroy }
-
-                should_set_the_flash_to(/signed out/i)
-                should_redirect_to_url_after_destroy
-              end
-
-              context 'a DELETE to #destroy with a cookie' do
-                setup do
-                  cookies['remember_token'] = CGI::Cookie.new 'token', 'value'
-                  delete :destroy
-                end
-
-                should 'delete the cookie' do
-                  assert cookies['remember_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