Changeset 269

Show
Ignore:
Timestamp:
03/07/08 17:37:10 (6 months ago)
Author:
gdagley
Message:

remove user activation
speed up tests

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • incubator/jumpstart/app/controllers/users_controller.rb

    r214 r269  
    2121  end 
    2222 
    23   def activate 
    24     return unless params[:activation_code] 
    25     user = User.find_by_activation_code(params[:activation_code]) 
    26     if user 
    27       user.activate 
    28       self.current_user = user 
    29       flash[:notice] = "Signup complete!" 
    30       redirect_to root_path 
    31     else 
    32       flash[:warning] = "We could not find an account with that code." 
    33     end 
    34   end 
    35  
    3623  def forgot_password 
    3724    return if request.get? 

  • incubator/jumpstart/app/models/user_mailer.rb

    r214 r269  
    11class UserMailer < ActionMailer::Base 
    22  default_url_options[:host] = AppConfiguration.full_domain 
    3    
    4   def signup_notification(user) 
    5     setup_email(user) 
    6     @subject    += 'Please activate your new account' 
    7    
    8     @body[:url]  = "http://YOURSITE/activate/#{user.activation_code}" 
    9    
    10   end 
    11    
    12   def activation(user) 
    13     setup_email(user) 
    14     @subject    += 'Your account has been activated' 
    15   end 
    163   
    174  def reset_password(user) 

  • incubator/jumpstart/app/models/user_observer.rb

    r214 r269  
    11class UserObserver < ActiveRecord::Observer 
    2   def after_create(user) 
    3     UserMailer.deliver_signup_notification(user) 
    4   end 
    5  
    62  def after_save(user) 
    7     UserMailer.deliver_activation(user) if user.recently_activated? 
    83    UserMailer.deliver_reset_password(user) if user.recently_reset_password? 
    9      
    104  end 
    115end 

  • incubator/jumpstart/lib/authentable_entity.rb

    r268 r269  
    2525      end 
    2626 
    27       before_create :make_activation_code 
    2827      before_save   :encrypt_password 
    29        
    3028       
    3129      # Prevents users from submitting crafted forms that bypasses activation. 
    …… 
    4139    # Returns the user or nil. 
    4240    def authenticate(email, cleartext) 
    43       u = find(:first, :conditions => ['email = ? AND activated_at IS NOT NULL', email]) 
     41      u = find_by_email(email) 
    4442      u && u.authenticated?(cleartext) ? u : nil 
    4543    end 
    …… 
    8684  end 
    8785   
    88   # Activates the user in the database. 
    89   def activate 
    90     @activated = true 
    91     self.activated_at = Time.now.utc 
    92     self.activation_code = nil 
    93     save(false) 
    94   end 
    95  
    96   def active? 
    97     # the existence of an activation code means they have not activated yet 
    98     activation_code.nil? 
    99   end 
    100  
    101   # Returns true if the user has just been activated. 
    102   def recently_activated? 
    103     @activated 
    104   end 
    105  
    10686  protected 
    10787    def encrypt_password 
    …… 
    11494    end 
    11595     
    116     def make_activation_code 
    117       self.activation_code = generate_token 
    118     end 
    119      
    12096    def generate_token 
    12197      Digest::SHA1.hexdigest( Time.now.to_s.split(//).sort_by {rand}.join ) 

  • incubator/jumpstart/test/functional/sessions_controller_test.rb

    r214 r269  
    22 
    33describe "Logging in (POST /session)", ActionController::TestCase  do 
     4  tests SessionsController 
    45 
    5   describe "unactivated user", ActionController::TestCase do 
    6     tests SessionsController 
     6  it 'should create session' do 
     7    user = stub(:id => 1) 
     8    User.stubs(:authenticate).returns(user) 
     9     
     10    post :create, :email => 'email', :password => 'password' 
     11    session[:user_id].should.be user.id 
     12  end 
    713 
    8     before do 
    9       @user = create_user 
    10     end 
     14  it 'should fail login with incorrect credentials and does not redirect' do 
     15    User.stubs(:authenticate).returns(nil) 
     16 
     17    post :create, :email => 'email', :password => 'bad password' 
     18    session[:user_id].should.be.nil 
     19  end 
     20 
     21  it 'should remember me when asked' do 
     22    user = stub(:id => 1, :remember_me => true, :remember_token => 'foo', :remember_token_expires_at => 2.weeks.from_now) 
     23    User.stubs(:authenticate).returns(user) 
    1124     
    12     it "should not create session" do 
    13       post :create, :email => @user.email, :password => @user.password 
    14       session[:user_id].should.be.nil 
    15     end 
     25    post :create, :email => 'email', :password => 'password', :remember_me => '1' 
     26    response.cookies["auth_token"].should.not.be.nil 
     27  end 
     28 
     29  it 'should not remember me unless asked' do 
     30    user = stub(:id => 1) 
     31    User.stubs(:authenticate).returns(user) 
     32 
     33    post :create, :email => 'email', :password => 'password', :remember_me => '0' 
     34    response.cookies["auth_token"].should.be.nil 
     35  end 
     36 
     37  it 'should login with remember me cookie' do 
     38    user = stub(:id => 1, :remember_token? => true, :remember_me => true, :remember_token => 'foo', :remember_token_expires_at => 2.weeks.from_now) 
     39    User.expects(:find_by_remember_token).returns(user) 
    1640   
     41    request.cookies["auth_token"] = auth_token('foo') 
     42    get :new 
     43    controller.send(:logged_in?).should.be true 
    1744  end 
    18    
    19   describe "activated user", ActionController::TestCase do 
    20     tests SessionsController 
    2145 
    22     before do 
    23       @user = create_user 
    24       @user.activate 
    25     end 
    26    
    27     it 'should create session' do 
    28       post :create, :email => @user.email, :password => @user.password 
    29       session[:user_id].should.not.be.nil 
    30     end 
    31    
    32     it 'should fail login with incorrect credentials and does not redirect' do 
    33       post :create, :email => @user.email, :password => 'bad password' 
    34       session[:user_id].should.be.nil 
    35       status.should.be :success 
    36     end 
     46  it 'should not login with expired remember me cookie' do 
     47    user = stub(:id => 1, :remember_token? => false) 
     48    User.expects(:find_by_remember_token).returns(user) 
    3749 
    38     it 'should remember me when asked' do 
    39       post :create, :email => @user.email, :password => @user.password, :remember_me => "1" 
    40       response.cookies["auth_token"].should.not.be.nil 
    41     end 
    42    
    43     it 'should not remember me unless asked' do 
    44       post :create, :email => @user.email, :password => @user.password, :remember_me => "0" 
    45       response.cookies["auth_token"].should.be.nil 
    46     end 
     50    request.cookies["auth_token"] = auth_token('foo') 
     51    get :new 
     52    controller.send(:logged_in?).should.not.be true 
     53  end 
    4754 
    48     it 'should login with remember me cookie' do 
    49       @user.remember_me 
    50       request.cookies["auth_token"] = cookie_for(@user) 
    51       get :new 
    52       controller.send(:logged_in?).should == true 
    53     end 
    54    
    55     it 'should not login with expired remember me cookie' do 
    56       @user.remember_me 
    57       @user.update_attribute :remember_token_expires_at, 5.minutes.ago 
    58       request.cookies["auth_token"] = cookie_for(@user) 
    59       get :new 
    60       controller.send(:logged_in?).should.not == true 
    61     end 
    62    
    63     it 'should not login with invalid remember me' do 
    64       @user.remember_me 
    65       request.cookies["auth_token"] = auth_token('invalid_auth_token') 
    66       get :new 
    67       controller.send(:logged_in?).should.not == true 
    68     end 
     55  it 'should not login with invalid remember me' do 
     56    User.expects(:find_by_remember_token).returns(nil) 
    6957 
    70     def auth_token(token) 
    71       CGI::Cookie.new('name' => 'auth_token', 'value' => token) 
    72     end 
    73      
    74     def cookie_for(user) 
    75       auth_token user.remember_token 
    76     end 
     58    request.cookies["auth_token"] = auth_token('invalid_auth_token') 
     59    get :new 
     60    controller.send(:logged_in?).should.be false 
     61  end 
     62 
     63  def auth_token(token) 
     64    CGI::Cookie.new('name' => 'auth_token', 'value' => token) 
    7765  end 
    7866end 
    …… 
    8169  tests SessionsController 
    8270 
    83   before do 
    84     @user = create_user 
    85     login_as @user 
    86   end 
    87    
    8871  it 'remove user from session' do 
     72    user = stub(:id => 1, :forget_me => true) 
     73    User.stubs(:find).returns(user) 
     74    request.session[:user_id] = user.id 
     75     
    8976    get :destroy 
    9077    session[:user_id].should.be.nil 
    91     status.should.be :redirect 
    9278  end 
    9379 
    9480  it 'should delete remember me token' do 
     81    user = stub(:id => 1, :remember_token? => true, :remember_me => true, :forget_me => true, :remember_token => 'foo', :remember_token_expires_at => 2.weeks.from_now) 
     82    User.expects(:find_by_remember_token).returns(user)   
     83    request.cookies["auth_token"] = auth_token('foo') 
     84 
    9585    get :destroy 
    9686    response.cookies["auth_token"].should == [] 
    9787  end 
     88   
     89  def auth_token(token) 
     90    CGI::Cookie.new('name' => 'auth_token', 'value' => token) 
     91  end 
    9892end 

  • incubator/jumpstart/test/functional/users_controller_test.rb

    r231 r269  
    2929end 
    3030 
    31 describe "Entering activation code (GET /activate)", ActionController::TestCase  do 
    32   tests UsersController 
    33    
    34   it "should use the 'activate' template" do 
    35     get :activate 
    36     template.should.be('activate') 
    37   end 
    38 end 
    39  
    40 describe "Activating a user from link (GET /activate?activation_code=:activation_code)", ActionController::TestCase  do 
    41   tests UsersController 
    42    
    43   before do 
    44     @user = create_user 
    45   end 
    46    
    47   it "should require a known activation code" do 
    48     get :activate, :activation_code => 'unknown code' 
    49     template.should.be('activate') 
    50   end 
    51    
    52   it "should activate the user" do 
    53     get :activate, :activation_code => @user.activation_code 
    54     @user.reload.should.be.active 
    55   end 
    56    
    57   it "should redirect back to the site root" do 
    58     get :activate, :activation_code => @user.activation_code 
    59     should.redirect_to root_path 
    60   end 
    61 end 
    62  
    63 describe "Activating a user (POST /activate)", ActionController::TestCase  do 
    64   tests UsersController 
    65    
    66   before do 
    67     @user = create_user 
    68   end 
    69    
    70   it "should require a known activation code" do 
    71     post :activate, :activation_code => 'unknown code' 
    72     template.should.be('activate') 
    73   end 
    74    
    75   it "should activate the user" do 
    76     post :activate, :activation_code => @user.activation_code 
    77     @user.reload.should.be.active 
    78   end 
    79    
    80   it "should redirect back to the site root" do 
    81     post :activate, :activation_code => @user.activation_code 
    82     should.redirect_to root_path 
    83   end 
    84 end 
    85     
    8631describe "Forgetting a password (GET /forgot_password)", ActionController::TestCase  do 
    8732  tests UsersController 

  • incubator/jumpstart/test/unit/user_mailer_test.rb

    r214 r269  
    33describe "UserMailer", ActionMailer::TestCase do 
    44   
    5   describe "Signup notification email" do 
    6     include ActionController::UrlWriter 
    7  
    8     before do 
    9       @user = create_user 
    10       @emails = ActionMailer::Base.deliveries  
    11       @emails.clear 
    12       UserMailer.deliver_signup_notification(@user) 
    13     end 
    14      
    15     it "should be sent to user's email" do 
    16       @emails[0].to[0].should == @user.email 
    17     end     
    18      
    19     it "should be sent from 'accounts@YOURSITE.com'" do 
    20       @emails[0].from[0].should == 'accounts@YOURSITE.com' 
    21     end     
    22  
    23     it "should have a subject indicating activation needed" do 
    24       @emails[0].subject.should.include 'Please activate your new account' 
    25     end     
    26  
    27     it "should have user's email in the message" do 
    28       @emails[0].body.should.include @user.email 
    29     end     
    30  
    31     it "should have user's password in the message" do 
    32       @emails[0].body.should.include @user.password 
    33     end 
    34  
    35     it "should have user's activation code in the message" do 
    36       @emails[0].body.should.include @user.activation_code 
    37     end 
    38          
    39     # it "should include the link to activation" do 
    40     #   @emails[0].body.should.include activation_url 
    41     # end 
    42   end 
    43  
    44   describe "Activation email" do 
    45     include ActionController::UrlWriter 
    46  
    47     before do 
    48       @emails = ActionMailer::Base.deliveries  
    49       @emails.clear 
    50       @user = new_user 
    51       UserMailer.deliver_activation(@user) 
    52     end 
    53      
    54     it "should be sent to user's email" do 
    55       @emails[0].to[0].should == @user.email 
    56     end     
    57      
    58     it "should be sent from 'accounts@YOURSITE.com'" do 
    59       @emails[0].from[0].should == 'accounts@YOURSITE.com' 
    60     end     
    61  
    62     it "should have a subject indicating account activation" do 
    63       @emails[0].subject.should.include 'Your account has been activated' 
    64     end     
    65  
    66     it "should have user's login in the message" do 
    67       @emails[0].body.should.include @user.login 
    68     end     
    69  
    70     # it "should include the link to site" do 
    71     #   @emails[0].body.should.include root_url 
    72     # end 
    73   end 
    74  
    755  describe "Reset password email" do 
    766    include ActionController::UrlWriter 
    777 
    788    before do 
    79       @emails = ActionMailer::Base.deliveries  
    80       @emails.clear 
    81       @user = new_user 
    82       UserMailer.deliver_reset_password(@user) 
     9      @user = User.new(:email => 'email', :password => 'password') 
     10      @email = UserMailer.create_reset_password(@user) 
    8311    end 
    8412     
    8513    it "should be sent to user's email" do 
    86       @emails[0].to[0].should == @user.email 
     14      @email.to[0].should == @user.email 
    8715    end     
    8816     
    8917    it "should be sent from 'accounts@YOURSITE.com'" do 
    90       @emails[0].from[0].should == 'accounts@YOURSITE.com' 
     18      @email.from[0].should == 'accounts@YOURSITE.com' 
    9119    end     
    9220 
    9321    it "should have a subject indicating password reset" do 
    94       @emails[0].subject.should.include 'Your password has been reset' 
     22      @email.subject.should.include 'Your password has been reset' 
    9523    end     
    9624 
    9725    it "should have user's email in the message" do 
    98       @emails[0].body.should.include @user.email 
     26      @email.body.should.include @user.email 
    9927    end     
    10028 
    10129    it "should have user's password in the message" do 
    102       @emails[0].body.should.include @user.password 
     30      @email.body.should.include @user.password 
    10331    end 
    10432     
    10533    # it "should include the link to login" do 
    106     #   @emails[0].body.should.include login_url 
     34    #   @email.body.should.include login_url 
    10735    # end 
    10836  end 

  • incubator/jumpstart/test/unit/user_observer_test.rb

    r214 r269  
    22 
    33describe "UserObserver", ActiveSupport::TestCase do 
    4   describe "user creation" do 
    5     before do 
    6       @observer = UserObserver.instance 
    7       @user = new_user 
    8       UserMailer.stubs(:deliver_signup_notification) 
    9     end 
    10    
    11     it "should send activation email when the user is created" do 
    12       UserMailer.expects(:deliver_signup_notification).times(1) 
    13       @observer.after_create(@user) 
    14     end 
    15   end 
    16  
    174  describe "resetting passwword" do 
    185    before do 

  • incubator/jumpstart/test/unit/user_test.rb

    r268 r269  
    3838  end 
    3939   
    40   describe "creation" do 
    41     it "should use token for activation code" do 
    42       User.any_instance.stubs(:generate_token).returns("abcdefg") 
    43       User.new.send(:make_activation_code).should == "abcdefg" 
    44     end 
    45      
    46     it "should generate activation code after create" do 
    47       user = create_user 
    48       user.activation_code.should.not.be.nil 
    49     end 
    50      
    51     it "should identify the user as not active when they have an activation code" do 
    52       user = User.new 
    53       user.activation_code = "foo" 
    54       user.should.not.be.active 
    55     end 
    56      
    57     it "should identify the user as active when they dont have an activation code" do 
    58       User.new(:activation_code => nil).should.be.active 
    59     end 
    60      
    61   end 
    62    
    6340  describe "authentication" do 
    64     before do 
     41    it "should authenticate activated user with email and password" do 
    6542      @user = create_user 
    66     end 
    67      
    68     it "should not authenticate unactivated users" do 
    69       User.authenticate(@user.email, @user.password).should.nil 
    70     end 
    71  
    72     it "should authenticate activated user with email and password" do 
    73       @user.activate 
    7443      User.authenticate(@user.email, @user.password).should == @user 
    7544    end 
    …… 
    7948    before do 
    8049      @user = create_user 
    81       @user.activate 
    8250    end 
    8351 
    …… 
    9664      User.authenticate(new_email, @user.password).should == @user 
    9765    end 
    98   end 
    99    
    100   describe "activation" do 
    101  
    102     it "should remove the activation code" do 
    103       user = User.new(:activation_code => "foo") 
    104       user.stubs(:save).returns(true) 
    105       user.activate 
    106       user.activation_code.should.be.nil 
    107     end 
    108      
    109     it "should set the activated at timestamp" do 
    110       user = User.new(:activation_code => "foo") 
    111       user.stubs(:save).returns(true) 
    112       user.activate 
    113       user.activated_at.should.not.be.nil 
    114     end 
    115  
    116     it "should identify the user as recently activated" do 
    117       user = User.new(:activation_code => "foo") 
    118       user.stubs(:save).returns(true) 
    119       user.activate 
    120       user.should.be.recently_activated 
    121     end 
    122  
    123     it "should identify the user as active" do 
    124       user = User.new(:activation_code => "foo") 
    125       user.stubs(:save).returns(true) 
    126       user.activate 
    127       user.should.be.active 
    128     end 
    129      
    13066  end 
    13167