spec/models/user_spec.rb

   1 require File.join( File.dirname(__FILE__), "..", "spec_helper" )
   2 require File.join( File.dirname(__FILE__), "..", "user_spec_helper")
   3 require File.join( File.dirname(__FILE__), "..", "authenticated_system_spec_helper")
   4
   5 describe User do
   6   include UserSpecHelper
   7
   8   before(:each) do
   9     User.clear_database_table
  10     UserMailer.stub!(:activation_notification).and_return(true)
  11   end
  12
  13   it "should have a login field" do
  14     user = User.new
  15     user.should respond_to(:login)
  16     user.valid?
  17     user.errors.on(:login).should_not be_nil
  18   end
  19
  20   it "should fail login if there are less than 3 chars" do
  21     user = User.new
  22     user.login = "AB"
  23     user.valid?
  24     user.errors.on(:login).should_not be_nil
  25   end
  26
  27   it "should not fail login with between 3 and 40 chars" do
  28     user = User.new
  29     [3,40].each do |num|
  30       user.login = "a" * num
  31       user.valid?
  32       user.errors.on(:login).should be_nil
  33     end
  34   end
  35
  36   it "should fail login with over 90 chars" do
  37     user = User.new
  38     user.login = "A" * 41
  39     user.valid?
  40     user.errors.on(:login).should_not be_nil
  41   end
  42
  43   it "should make a valid user" do
  44     user = User.new(valid_user_hash)
  45     user.save
  46     user.errors.should be_empty
  47
  48   end
  49
  50   it "should make sure login is unique" do
  51     user = User.new( valid_user_hash.with(:login => "Daniel") )
  52     user2 = User.new( valid_user_hash.with(:login => "Daniel"))
  53     user.save.should be_true
  54     user.login = "Daniel"
  55     # see http://wm.lighthouseapp.com/projects/4819/tickets/272-invalid-resources-still-save
  56     #user2.save.should be_false
  57     user2.errors.on(:login).should_not be_nil
  58   end
  59
  60   it "should make sure login is unique regardless of case" do
  61     User.first(:login => "Daniel").should be_nil
  62     user = User.new( valid_user_hash.with(:login => "Daniel") )
  63     user2 = User.new( valid_user_hash.with(:login => "daniel"))
  64     user.save.should be_true
  65     user.login = "Daniel"
  66     # see http://wm.lighthouseapp.com/projects/4819/tickets/272-invalid-resources-still-save
  67     #user2.save.should be_false
  68     user2.errors.on(:login).should_not be_nil
  69   end
  70
  71   it "should downcase logins" do
  72     user = User.new( valid_user_hash.with(:login => "DaNieL"))
  73     user.login.should == "daniel"
  74   end
  75
  76   it "should authenticate a user using a class method" do
  77     user = User.new(valid_user_hash)
  78     user.save
  79     user.activate
  80     User.authenticate(valid_user_hash[:login], valid_user_hash[:password]).should_not be_nil
  81   end
  82
  83   it "should not authenticate a user using the wrong password" do
  84     user = User.new(valid_user_hash)
  85     user.save
  86
  87     user.activate
  88     User.authenticate(valid_user_hash[:login], "not_the_password").should be_nil
  89   end
  90
  91   it "should not authenticate a user using the wrong login" do
  92     user = User.create(valid_user_hash)
  93
  94     user.activate
  95     User.authenticate("not_the_login", valid_user_hash[:password]).should be_nil
  96   end
  97
  98   it "should not authenticate a user that does not exist" do
  99     User.authenticate("i_dont_exist", "password").should be_nil
 100   end
 101
 102
 103   it "should send a please activate email" do
 104     user = User.new(valid_user_hash)
 105     UserMailer.should_receive(:dispatch_and_deliver) do |action, mail_args, mailer_params|
 106       action.should == :signup_notification
 107       [:from, :to, :subject].each{ |f| mail_args.keys.should include(f)}
 108       mail_args[:to].should == user.email
 109       mailer_params[:user].should == user
 110     end
 111     user.save
 112   end
 113
 114   it "should not send a please activate email when updating" do
 115     user = User.new(valid_user_hash)
 116     user.save
 117     UserMailer.should_not_receive(:signup_notification)
 118     user.login = "not in the valid hash for login"
 119     user.save
 120   end
 121
 122 end
 123
 124 describe User, "the password fields for User" do
 125   include UserSpecHelper
 126
 127   before(:each) do
 128     User.clear_database_table
 129     @user = User.new( valid_user_hash )
 130     UserMailer.stub!(:activation_notification).and_return(true)
 131   end
 132
 133   it "should respond to password" do
 134     @user.should respond_to(:password)
 135   end
 136
 137   it "should respond to password_confirmation" do
 138     @user.should respond_to(:password_confirmation)
 139   end
 140
 141   #it "should have a protected password_required method" do
 142   #  @user.protected_methods.should include("password_required?")
 143   #end
 144
 145   it "should respond to crypted_password" do
 146     @user.should respond_to(:crypted_password)
 147   end
 148
 149   it "should require password if password is required" do
 150     user = User.new( valid_user_hash.without(:password))
 151     user.stub!(:password_required?).and_return(true)
 152     user.valid?
 153     user.errors.on(:password).should_not be_nil
 154     user.errors.on(:password).should_not be_empty
 155   end
 156
 157   it "should set the salt" do
 158     user = User.new(valid_user_hash)
 159     user.salt.should be_nil
 160     user.send(:encrypt_password)
 161     user.salt.should_not be_nil
 162   end
 163
 164   it "should require the password on create" do
 165     user = User.new(valid_user_hash.without(:password))
 166     user.save
 167     user.errors.on(:password).should_not be_nil
 168     user.errors.on(:password).should_not be_empty
 169   end
 170
 171   it "should require password_confirmation if the password_required?" do
 172     user = User.new(valid_user_hash.without(:password_confirmation))
 173     user.save
 174     (user.errors.on(:password) || user.errors.on(:password_confirmation)).should_not be_nil
 175   end
 176
 177   it "should fail when password is outside 4 and 40 chars" do
 178     [3,41].each do |num|
 179       user = User.new(valid_user_hash.with(:password => ("a" * num)))
 180       user.valid?
 181       user.errors.on(:password).should_not be_nil
 182     end
 183   end
 184
 185   it "should pass when password is within 4 and 40 chars" do
 186     [4,30,40].each do |num|
 187       user = User.new(valid_user_hash.with(:password => ("a" * num), :password_confirmation => ("a" * num)))
 188       user.valid?
 189       user.errors.on(:password).should be_nil
 190     end
 191   end
 192
 193   it "should authenticate against a password" do
 194     user = User.new(valid_user_hash)
 195     user.save
 196     user.should be_authenticated(valid_user_hash[:password])
 197   end
 198
 199   it "should not require a password when saving an existing user" do
 200     user = User.create(valid_user_hash)
 201     user = User.first(:login => valid_user_hash[:login])
 202     user.password.should be_nil
 203     user.password_confirmation.should be_nil
 204     user.login = "some_different_login_to_allow_saving"
 205     (user.save).should be_true
 206   end
 207
 208 end
 209
 210 describe User, "activation" do
 211   include UserSpecHelper
 212
 213
 214   before(:each) do
 215     User.clear_database_table
 216     @user = User.new(valid_user_hash)
 217   end
 218
 219   it "should have an activation_code as an attribute" do
 220     @user.attributes.keys.any?{|a| a.to_s == "activation_code"}.should_not be_nil
 221   end
 222
 223   it "should create an activation code on create" do
 224     @user.activation_code.should be_nil
 225     @user.save
 226     @user.activation_code.should_not be_nil
 227   end
 228
 229   it "should not be active when created" do
 230     @user.should_not be_activated
 231     @user.save
 232     @user.should_not be_activated
 233   end
 234
 235   it "should respond to activate" do
 236     @user.should respond_to(:activate)
 237   end
 238
 239   it "should activate a user when activate is called" do
 240     @user.should_not be_activated
 241     @user.save
 242     @user.activate
 243     @user.should be_activated
 244     ## FIXME
 245     #User.first(:login => valid_user_hash[:login]).should be_activated
 246   end
 247
 248   it "should should show recently activated when the instance is activated" do
 249     @user.should_not be_recently_activated
 250     @user.activate
 251     @user.should be_recently_activated
 252   end
 253
 254   it "should not show recently activated when the instance is fresh" do
 255     @user.activate
 256     @user = nil
 257     ## FIXME
 258     #User.first(:login => valid_user_hash[:login]).should_not be_recently_activated
 259   end
 260
 261   it "should send out a welcome email to confirm that the account is activated" do
 262     @user.save
 263     UserMailer.should_receive(:dispatch_and_deliver) do |action, mail_args, mailer_params|
 264       action.should == :activation_notification
 265       mail_args.keys.should include(:from)
 266       mail_args.keys.should include(:to)
 267       mail_args.keys.should include(:subject)
 268       mail_args[:to].should == @user.email
 269       mailer_params[:user].should == @user
 270     end
 271     @user.activate
 272   end
 273
 274 end
 275
 276 describe User, "remember_me" do
 277   include UserSpecHelper
 278
 279   predicate_matchers[:remember_token] = :remember_token?
 280
 281   before do
 282     User.clear_database_table
 283     @user = User.new(valid_user_hash)
 284   end
 285
 286   it "should have a remember_token_expires_at attribute" do
 287     @user.attributes.keys.any?{|a| a.to_s == "remember_token_expires_at"}.should_not be_nil
 288   end
 289
 290   it "should respond to remember_token?" do
 291     @user.should respond_to(:remember_token?)
 292   end
 293
 294   it "should return true if remember_token_expires_at is set and is in the future" do
 295     @user.remember_token_expires_at = DateTime.now + 3600
 296     @user.should remember_token
 297   end
 298
 299   it "should set remember_token_expires_at to a specific date" do
 300     time = DateTime.new(2009, 12, 25)
 301     @user.remember_me_until(time)
 302     @user.remember_token_expires_at.should == time
 303   end
 304
 305   it "should set the remember_me token when remembering" do
 306     time = Time.mktime(2009,12,25)
 307     @user.remember_me_until(time)
 308     @user.remember_token.should_not be_nil
 309     @user.save.should
 310     User.first(:login => valid_user_hash[:login]).remember_token.should_not be_nil
 311   end
 312
 313   it "should remember me for" do
 314     t = DateTime.now
 315     DateTime.stub!(:now).and_return(t)
 316     today = DateTime.now
 317     remember_until = today + (2* Merb::Const::WEEK)
 318     @user.remember_me_for( Merb::Const::WEEK * 2)
 319     @user.remember_token_expires_at.should == (remember_until)
 320   end
 321
 322   it "should remember_me for two weeks" do
 323     t = DateTime.now
 324     DateTime.stub!(:now).and_return(t)
 325     @user.remember_me
 326     @user.remember_token_expires_at.should == (DateTime.now + (2 * Merb::Const::WEEK ))
 327   end
 328
 329   it "should forget me" do
 330     @user.remember_me
 331     @user.save
 332     @user.forget_me
 333     @user.remember_token.should be_nil
 334     @user.remember_token_expires_at.should be_nil
 335   end
 336
 337   it "should persist the forget me to the database" do
 338     @user.remember_me
 339     @user.save
 340
 341     @user = User.first(:login => valid_user_hash[:login])
 342     @user.remember_token.should_not be_nil
 343
 344     @user.forget_me
 345
 346     @user = User.first(:login => valid_user_hash[:login])
 347     @user.remember_token.should be_nil
 348     @user.remember_token_expires_at.should be_nil
 349   end
 350
 351 end