rails3-restful-authentication 3.0.1

data/lib/generators/authenticated/templates/spec/controllers/users_controller_spec.rb

@@ -0,0 +1,131 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+  
+# Be sure to include AuthenticatedTestHelper in spec/spec_helper.rb instead
+# Then, you can remove it from this and the units test.
+include AuthenticatedTestHelper
+
+describe UsersController do
+  fixtures :users
+
+  it 'allows signup' do
+    lambda do
+      create_user
+      response.should be_redirect
+    end.should change(User, :count).by(1)
+  end
+
+  
+
+
+  it 'requires login on signup' do
+    lambda do
+      create_user(:login => nil)
+      assigns[:user].errors.get(:login).should_not be_nil
+      response.should be_success
+    end.should_not change(User, :count)
+  end
+  
+  it 'requires password on signup' do
+    lambda do
+      create_user(:password => nil)
+      assigns[:user].errors.get(:password).should_not be_nil
+      response.should be_success
+    end.should_not change(User, :count)
+  end
+  
+  it 'requires password confirmation on signup' do
+    lambda do
+      create_user(:password_confirmation => nil)
+      assigns[:user].errors.get(:password_confirmation).should_not be_nil
+      response.should be_success
+    end.should_not change(User, :count)
+  end
+
+  it 'requires email on signup' do
+    lambda do
+      create_user(:email => nil)
+      assigns[:user].errors.get(:email).should_not be_nil
+      response.should be_success
+    end.should_not change(User, :count)
+  end
+  
+  
+  
+  def create_user(options = {})
+    post :create, :user => { :login => 'quire', :email => 'quire@example.com',
+      :password => 'quire69', :password_confirmation => 'quire69' }.merge(options)
+  end
+end
+
+describe UsersController do
+  describe "route recognition and generation" do
+    it "should generate params for users's index action from GET /users" do
+      {:get => '/users'}.should route_to(:controller => 'users', :action => 'index')
+      {:get => '/users.xml'}.should route_to(:controller => 'users', :action => 'index', :format => 'xml')
+      {:get => '/users.json'}.should route_to(:controller => 'users', :action => 'index', :format => 'json')
+    end
+    
+    it "should generate params for users's new action from GET /users" do
+      {:get => '/users/new'}.should route_to(:controller => 'users', :action => 'new')
+      {:get => '/users/new.xml'}.should route_to(:controller => 'users', :action => 'new', :format => 'xml')
+      {:get => '/users/new.json'}.should route_to(:controller => 'users', :action => 'new', :format => 'json')
+    end
+    
+    it "should generate params for users's create action from POST /users" do
+      {:post => '/users'}.should route_to(:controller => 'users', :action => 'create')
+      {:post => '/users.xml'}.should route_to(:controller => 'users', :action => 'create', :format => 'xml')
+      {:post => '/users.json'}.should route_to(:controller => 'users', :action => 'create', :format => 'json')
+    end
+    
+    it "should generate params for users's show action from GET /users/1" do
+      {:get => '/users/1'}.should route_to(:controller => 'users', :action => 'show', :id => '1')
+      {:get => '/users/1.xml'}.should route_to(:controller => 'users', :action => 'show', :id => '1', :format => 'xml')
+      {:get => '/users/1.json'}.should route_to(:controller => 'users', :action => 'show', :id => '1', :format => 'json')
+    end
+    
+    it "should generate params for users's edit action from GET /users/1/edit" do
+      {:get => '/users/1/edit'}.should route_to(:controller => 'users', :action => 'edit', :id => '1')
+    end
+    
+    it "should generate params {:controller => 'users', :action => update', :id => '1'} from PUT /users/1" do
+      {:put => '/users/1'}.should route_to(:controller => 'users', :action => 'update', :id => '1')
+      {:put => '/users/1.xml'}.should route_to(:controller => 'users', :action => 'update', :id => '1', :format => 'xml')
+      {:put => '/users/1.json'}.should route_to(:controller => 'users', :action => 'update', :id => '1', :format => 'json')
+    end
+    
+    it "should generate params for users's destroy action from DELETE /users/1" do
+      {:delete => '/users/1'}.should route_to(:controller => 'users', :action => 'destroy', :id => '1')
+      {:delete => '/users/1.xml'}.should route_to(:controller => 'users', :action => 'destroy', :id => '1', :format => 'xml')
+      {:delete => '/users/1.json'}.should route_to(:controller => 'users', :action => 'destroy', :id => '1', :format => 'json')
+    end
+  end
+  
+  describe "named routing" do
+    before(:each) do
+      get :new
+    end
+    
+    it "should route users_path() to /users" do
+      users_path().should == "/users"
+      controller.users_path(:format => 'xml').should == "/users.xml"
+      controller.users_path(:format => 'json').should == "/users.json"
+    end
+    
+    it "should route new_user_path() to /users/new" do
+      new_user_path().should == "/users/new"
+      controller.new_user_path(:format => 'xml').should == "/users/new.xml"
+      controller.new_user_path(:format => 'json').should == "/users/new.json"
+    end
+    
+    it "should route user_(:id => '1') to /users/1" do
+      user_path(:id => '1').should == "/users/1"
+      controller.user_path(:id => '1', :format => 'xml').should == "/users/1.xml"
+      controller.user_path(:id => '1', :format => 'json').should == "/users/1.json"
+    end
+    
+    it "should route edit_user_path(:id => '1') to /users/1/edit" do
+      controller.edit_user_path(:id => '1').should == "/users/1/edit"
+    end
+  end
+  
+end

data/lib/generators/authenticated/templates/spec/fixtures/users.yml

@@ -0,0 +1,60 @@
+<%
+  ## this code must match that in templates/model.rb
+  require 'digest/sha1'
+  def make_fake_token
+    @fake_token_counter ||= 0
+    @fake_token_counter +=  1
+    Digest::SHA1.hexdigest(@fake_token_counter.to_s)
+  end
+  salts   = (1..2).map{ make_fake_token }
+  passwds = salts.map{ |salt| password_digest('monkey', salt) }
+-%>
+
+quentin:
+  id:                        1
+  login:                     quentin
+  email:                     quentin@example.com
+  salt:                      <%= salts[0]   %> # SHA1('0')
+  crypted_password:          <%= passwds[0] %> # 'monkey'
+  created_at:                <%%= 5.days.ago.to_s :db  %>
+  remember_token_expires_at: <%%= 1.days.from_now.to_s %>
+  remember_token:            <%= make_fake_token %>
+<% if options[:include_activation] -%>
+  activation_code:           
+  activated_at:              <%%= 5.days.ago.to_s :db %>
+<% end -%>
+<% if options[:stateful] -%>
+  state:                     active
+<% end -%>
+      
+aaron:
+  id:                        2
+  login:                     aaron
+  email:                     aaron@example.com
+  salt:                      <%= salts[1]   %> # SHA1('1')
+  crypted_password:          <%= passwds[1] %> # 'monkey'
+  created_at:                <%%= 1.days.ago.to_s :db %>
+  remember_token_expires_at: 
+  remember_token:            
+<% if options[:include_activation] -%>
+  activation_code:           <%= make_fake_token %>
+  activated_at:              
+<% end -%>
+<% if options[:stateful] %>
+  state:                     pending
+<% end -%>
+
+
+old_password_holder:
+  id:                        3
+  login:                     old_password_holder
+  email:                     salty_dog@example.com
+  salt:                      7e3041ebc2fc05a40c60028e2c4901a81035d3cd
+  crypted_password:          00742970dc9e6319f8019fd54864d3ea740f04b1 # test
+  created_at:                <%%= 1.days.ago.to_s :db %>
+<% if options[:include_activation] %>
+  activation_code:           
+  activated_at:              <%%= 5.days.ago.to_s :db %>
+<% end %>
+<% if options[:stateful] %>
+  state:                     active<% end %>

data/lib/generators/authenticated/templates/spec/helpers/users_helper_spec.rb

@@ -0,0 +1,141 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+include ApplicationHelper
+include UsersHelper
+include AuthenticatedTestHelper
+
+describe UsersHelper do
+  before do
+    @user = mock_user
+  end
+  
+  describe "if_authorized" do 
+    it "yields if authorized" do
+      helper.should_receive(:authorized?).with('a','r').and_return(true)
+      helper.if_authorized?('a','r'){|action,resource| [action,resource,'hi'] }.should == ['a','r','hi']
+    end
+    it "does nothing if not authorized" do
+      helper.should_receive(:authorized?).with('a','r').and_return(false)
+      helper.if_authorized?('a','r'){ 'hi' }.should be_nil
+    end
+  end
+  
+  describe "link_to_user" do
+    it "should give an error on a nil user" do
+      lambda { helper.link_to_user(nil) }.should raise_error('Invalid user')
+    end
+    it "should link to the given user" do
+      helper.should_receive(:user_path).at_least(:once).and_return('/users/1')
+      helper.link_to_user(@user).should have_tag("a[href='/users/1']")
+    end
+    it "should use given link text if :content_text is specified" do
+      helper.link_to_user(@user, :content_text => 'Hello there!').should have_tag("a", :text => 'Hello there!')
+    end
+    it "should use the login as link text with no :content_method specified" do
+      helper.link_to_user(@user).should have_tag("a", :text => 'user_name')
+    end
+    it "should use the name as link text with :content_method => :name" do
+      helper.link_to_user(@user, :content_method => :name).should have_tag("a", :text => 'U. Surname')
+    end
+    it "should use the login as title with no :title_method specified" do
+      helper.link_to_user(@user).should have_tag("a[title='user_name']")
+    end
+    it "should use the name as link title with :content_method => :name" do
+      helper.link_to_user(@user, :title_method => :name).should have_tag("a[title='U. Surname']")
+    end
+    it "should have nickname as a class by default" do
+      helper.link_to_user(@user).should have_tag("a.nickname")
+    end
+    it "should take other classes and no longer have the nickname class" do
+      result = helper.link_to_user(@user, :class => 'foo bar')
+      result.should have_tag("a.foo")
+      result.should have_tag("a.bar")
+    end
+  end
+
+  describe "link_to_login_with_IP" do
+    it "should link to the login_path" do
+      helper.link_to_login_with_IP().should have_tag("a[href='/login']")
+    end
+    it "should use given link text if :content_text is specified" do
+      helper.link_to_login_with_IP('Hello there!').should have_tag("a", :text => 'Hello there!')
+    end
+    it "should use the login as link text with no :content_method specified" do
+      helper.link_to_login_with_IP().should have_tag("a", :text => '0.0.0.0')
+    end
+    it "should use the ip address as title" do
+      helper.link_to_login_with_IP().should have_tag("a[title='0.0.0.0']")
+    end
+    it "should by default be like school in summer and have no class" do
+      helper.link_to_login_with_IP().should_not have_tag("a.nickname")
+    end
+    it "should have some class if you tell it to" do
+      result = helper.link_to_login_with_IP(nil, :class => 'foo bar')
+      result.should have_tag("a.foo")
+      result.should have_tag("a.bar")
+    end
+    it "should have some class if you tell it to" do
+      result = helper.link_to_login_with_IP(nil, :tag => 'abbr')
+      result.should have_tag("abbr[title='0.0.0.0']")
+    end
+  end
+
+  describe "link_to_current_user, When logged in" do
+    before do
+      helper.current_user = @user
+    end
+    it "should link to the given user" do
+      helper.should_receive(:user_path).at_least(:once).and_return('/users/1')
+      helper.link_to_current_user().should have_tag("a[href='/users/1']")
+    end
+    it "should use given link text if :content_text is specified" do
+      helper.link_to_current_user(:content_text => 'Hello there!').should have_tag("a", :text => 'Hello there!')
+    end
+    it "should use the login as link text with no :content_method specified" do
+      helper.link_to_current_user().should have_tag("a", :text => 'user_name')
+    end
+    it "should use the name as link text with :content_method => :name" do
+      helper.link_to_current_user(:content_method => :name).should have_tag("a", :text => 'U. Surname')
+    end
+    it "should use the login as title with no :title_method specified" do
+      helper.link_to_current_user().should have_tag("a[title='user_name']")
+    end
+    it "should use the name as link title with :content_method => :name" do
+      helper.link_to_current_user(:title_method => :name).should have_tag("a[title='U. Surname']")
+    end
+    it "should have nickname as a class" do
+      helper.link_to_current_user().should have_tag("a.nickname")
+    end
+    it "should take other classes and no longer have the nickname class" do
+      result = helper.link_to_current_user(:class => 'foo bar')
+      result.should have_tag("a.foo")
+      result.should have_tag("a.bar")
+    end
+  end
+
+  describe "link_to_current_user, When logged out" do
+    before do
+      helper.current_user = nil
+    end
+    it "should link to the login_path" do
+      helper.link_to_current_user().should have_tag("a[href='/login']")
+    end
+    it "should use given link text if :content_text is specified" do
+      helper.link_to_current_user(:content_text => 'Hello there!').should have_tag("a", :text => 'Hello there!')
+    end
+    it "should use 'not signed in' as link text with no :content_method specified" do
+      helper.link_to_current_user().should have_tag("a", :text => 'not signed in')
+    end
+    it "should use the ip address as title" do
+      helper.link_to_current_user().should have_tag("a[title='0.0.0.0']")
+    end
+    it "should by default be like school in summer and have no class" do
+      helper.link_to_current_user().should_not have_tag("a.nickname")
+    end
+    it "should have some class if you tell it to" do
+      result = helper.link_to_current_user(:class => 'foo bar')
+      result.should have_tag("a.foo")
+      result.should have_tag("a.bar")
+    end
+  end
+
+end

data/lib/generators/authenticated/templates/spec/models/user_spec.rb

@@ -0,0 +1,227 @@
+# -*- coding: utf-8 -*-
+require File.dirname(__FILE__) + '/../spec_helper'
+
+# Be sure to include AuthenticatedTestHelper in spec/spec_helper.rb instead.
+# Then, you can remove it from this and the functional test.
+include AuthenticatedTestHelper
+
+describe User do
+  fixtures :users
+
+  describe 'being created' do
+    before do
+      @user = nil
+      @creating_user = lambda do
+        @user = create_user
+        violated "#{@user.errors.full_messages.to_sentence}" if @user.new_record?
+      end
+    end
+
+    it 'increments User#count' do
+      @creating_user.should change(User, :count).by(1)
+    end
+  end
+
+  #
+  # Validations
+  #
+
+  it 'requires login' do
+    lambda do
+      u = create_user(:login => nil)
+      u.errors.get(:login).should_not be_nil
+    end.should_not change(User, :count)
+  end
+
+  describe 'allows legitimate logins:' do
+    ['123', '1234567890_234567890_234567890_234567890',
+     'hello.-_there@funnychar.com'].each do |login_str|
+      it "'#{login_str}'" do
+        lambda do
+          u = create_user(:login => login_str)
+          u.errors.get(:login).should     be_nil
+        end.should change(User, :count).by(1)
+      end
+    end
+  end
+  describe 'disallows illegitimate logins:' do
+    ['12', '1234567890_234567890_234567890_234567890_', "tab\t", "newline\n",
+     "Iñtërnâtiônàlizætiøn hasn't happened to ruby 1.8 yet",
+     'semicolon;', 'quote"', 'tick\'', 'backtick`', 'percent%', 'plus+', 'space '].each do |login_str|
+      it "'#{login_str}'" do
+        lambda do
+          u = create_user(:login => login_str)
+          u.errors.get(:login).should_not be_nil
+        end.should_not change(User, :count)
+      end
+    end
+  end
+
+  it 'requires password' do
+    lambda do
+      u = create_user(:password => nil)
+      u.errors.get(:password).should_not be_nil
+    end.should_not change(User, :count)
+  end
+
+  it 'requires password confirmation' do
+    lambda do
+      u = create_user(:password_confirmation => nil)
+      u.errors.get(:password_confirmation).should_not be_nil
+    end.should_not change(User, :count)
+  end
+
+  it 'requires email' do
+    lambda do
+      u = create_user(:email => nil)
+      u.errors.get(:email).should_not be_nil
+    end.should_not change(User, :count)
+  end
+
+  describe 'allows legitimate emails:' do
+    ['foo@bar.com', 'foo@newskool-tld.museum', 'foo@twoletter-tld.de', 'foo@nonexistant-tld.qq',
+     'r@a.wk', '1234567890-234567890-234567890-234567890-234567890-234567890-234567890-234567890-234567890@gmail.com',
+     'hello.-_there@funnychar.com', 'uucp%addr@gmail.com', 'hello+routing-str@gmail.com',
+     'domain@can.haz.many.sub.doma.in', 'student.name@university.edu'
+    ].each do |email_str|
+      it "'#{email_str}'" do
+        lambda do
+          u = create_user(:email => email_str)
+          u.errors.get(:email).should     be_nil
+        end.should change(User, :count).by(1)
+      end
+    end
+  end
+  describe 'disallows illegitimate emails' do
+    ['!!@nobadchars.com', 'foo@no-rep-dots..com', 'foo@badtld.xxx', 'foo@toolongtld.abcdefg',
+     'Iñtërnâtiônàlizætiøn@hasnt.happened.to.email', 'need.domain.and.tld@de', "tab\t", "newline\n",
+     'r@.wk', '1234567890-234567890-234567890-234567890-234567890-234567890-234567890-234567890-234567890@gmail2.com',
+     # these are technically allowed but not seen in practice:
+     'uucp!addr@gmail.com', 'semicolon;@gmail.com', 'quote"@gmail.com', 'tick\'@gmail.com', 'backtick`@gmail.com', 'space @gmail.com', 'bracket<@gmail.com', 'bracket>@gmail.com'
+    ].each do |email_str|
+      it "'#{email_str}'" do
+        lambda do
+          u = create_user(:email => email_str)
+          u.errors.get(:email).should_not be_nil
+        end.should_not change(User, :count)
+      end
+    end
+  end
+
+  describe 'allows legitimate names:' do
+    ['Andre The Giant (7\'4", 520 lb.) -- has a posse',
+     '', '1234567890_234567890_234567890_234567890_234567890_234567890_234567890_234567890_234567890_234567890',
+    ].each do |name_str|
+      it "'#{name_str}'" do
+        lambda do
+          u = create_user(:name => name_str)
+          u.errors.get(:name).should     be_nil
+        end.should change(User, :count).by(1)
+      end
+    end
+  end
+  describe "disallows illegitimate names" do
+    ["tab\t", "newline\n",
+     '1234567890_234567890_234567890_234567890_234567890_234567890_234567890_234567890_234567890_234567890_',
+     ].each do |name_str|
+      it "'#{name_str}'" do
+        lambda do
+          u = create_user(:name => name_str) 
+          u.errors.get(:name).should_not be_nil
+        end.should_not change(User, :count)
+      end
+    end
+  end
+
+  it 'resets password' do
+    users(:quentin).update_attributes(:password => 'new password', :password_confirmation => 'new password')
+    User.authenticate('quentin', 'new password').should == users(:quentin)
+  end
+
+  it 'does not rehash password' do
+    users(:quentin).update_attributes(:login => 'quentin2')
+    User.authenticate('quentin2', 'monkey').should == users(:quentin)
+  end
+
+  #
+  # Authentication
+  #
+
+  it 'authenticates user' do
+    User.authenticate('quentin', 'monkey').should == users(:quentin)
+  end
+
+  it "doesn't authenticate user with bad password" do
+    User.authenticate('quentin', 'invalid_password').should be_nil
+  end
+
+ if REST_AUTH_SITE_KEY.blank?
+   # old-school passwords
+   it "authenticates a user against a hard-coded old-style password" do
+     User.authenticate('old_password_holder', 'test').should == users(:old_password_holder)
+   end
+ else
+   it "doesn't authenticate a user against a hard-coded old-style password" do
+     User.authenticate('old_password_holder', 'test').should be_nil
+   end
+
+   # New installs should bump this up and set REST_AUTH_DIGEST_STRETCHES to give a 10ms encrypt time or so
+   desired_encryption_expensiveness_ms = 0.1
+   it "takes longer than #{desired_encryption_expensiveness_ms}ms to encrypt a password" do
+     test_reps = 100
+     start_time = Time.now; test_reps.times{ User.authenticate('quentin', 'monkey'+rand.to_s) }; end_time   = Time.now
+     auth_time_ms = 1000 * (end_time - start_time)/test_reps
+     auth_time_ms.should > desired_encryption_expensiveness_ms
+   end
+ end
+
+  #
+  # Authentication
+  #
+
+  it 'sets remember token' do
+    users(:quentin).remember_me
+    users(:quentin).remember_token.should_not be_nil
+    users(:quentin).remember_token_expires_at.should_not be_nil
+  end
+
+  it 'unsets remember token' do
+    users(:quentin).remember_me
+    users(:quentin).remember_token.should_not be_nil
+    users(:quentin).forget_me
+    users(:quentin).remember_token.should be_nil
+  end
+
+  it 'remembers me for one week' do
+    before = 1.week.from_now.utc
+    users(:quentin).remember_me_for 1.week
+    after = 1.week.from_now.utc
+    users(:quentin).remember_token.should_not be_nil
+    users(:quentin).remember_token_expires_at.should_not be_nil
+    users(:quentin).remember_token_expires_at.between?(before, after).should be_true
+  end
+
+  it 'remembers me until one week' do
+    time = 1.week.from_now.utc
+    users(:quentin).remember_me_until time
+    users(:quentin).remember_token.should_not be_nil
+    users(:quentin).remember_token_expires_at.should_not be_nil
+    users(:quentin).remember_token_expires_at.should == time
+  end
+
+  it 'remembers me default two weeks' do
+    before = 2.weeks.from_now.utc
+    users(:quentin).remember_me
+    after = 2.weeks.from_now.utc
+    users(:quentin).remember_token.should_not be_nil
+    users(:quentin).remember_token_expires_at.should_not be_nil
+    users(:quentin).remember_token_expires_at.between?(before, after).should be_true
+  end
+
+protected
+  def create_user(options = {})
+    record = User.new({ :login => 'quire', :email => 'quire@example.com', :password => 'quire69', :password_confirmation => 'quire69' }.merge(options))
+    record.save
+    record
+  end
+end