rails3-restful-authentication 3.0.1

data/lib/generators/authenticated/templates/model_helper_spec.rb

@@ -0,0 +1,158 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+include ApplicationHelper
+include <%= model_controller_class_name %>Helper
+
+describe "<%= model_controller_class_name %>Helper.link_to_<%= file_name %>" do
+  before do
+    @<%= file_name %> = <%= class_name %>.new({
+        :name  => '<%= class_name %> Name',
+        :login => '<%= file_name %>_name',
+      })
+    @<%= file_name %>.id = 1 # set non-attr_accessible specifically
+  end
+
+  it "should give an error on a nil <%= file_name %>" do
+    lambda { link_to_<%= file_name %>(nil) }.should raise_error('Invalid <%= file_name %>')
+  end
+
+  it "should link to the given <%= file_name %>" do
+    link_to_<%= file_name %>(@<%= file_name %>).should have_tag("a[href='/<%= table_name %>/1']")
+  end
+
+  it "should use given link text if :content_text is specified" do
+    link_to_<%= file_name %>(@<%= file_name %>, :content_text => 'Hello there!').should have_tag("a", 'Hello there!')
+  end
+
+  it "should use the login as link text with no :content_method specified" do
+    link_to_<%= file_name %>(@<%= file_name %>).should have_tag("a", '<%= file_name %>_name')
+  end
+
+  it "should use the name as link text with :content_method => :name" do
+    link_to_<%= file_name %>(@<%= file_name %>, :content_method => :name).should have_tag("a", '<%= class_name %> Name')
+  end
+
+  it "should use the login as title with no :title_method specified" do
+    link_to_<%= file_name %>(@<%= file_name %>).should have_tag("a[title='<%= file_name %>_name']")
+  end
+
+  it "should use the name as link title with :content_method => :name" do
+    link_to_<%= file_name %>(@<%= file_name %>, :title_method => :name).should have_tag("a[title='<%= class_name %> Name']")
+  end
+
+  it "should have nickname as a class by default" do
+    link_to_<%= file_name %>(@<%= file_name %>).should have_tag("a.nickname")
+  end
+
+  it "should take other classes and no longer have the nickname class" do
+    result = link_to_<%= file_name %>(@<%= file_name %>, :class => 'foo bar')
+    result.should have_tag("a.foo")
+    result.should have_tag("a.bar")
+  end
+end
+
+describe "<%= model_controller_class_name %>Helper.link_to_signin_with_IP" do
+  before do
+  end
+
+  it "should link to the signin_path" do
+    link_to_signin_with_IP().should have_tag("a[href='/signin']")
+  end
+
+  it "should use given link text if :content_text is specified" do
+    link_to_signin_with_IP(:content_text => 'Hello there!').should have_tag("a", 'Hello there!')
+  end
+
+  it "should use the login as link text with no :content_method specified" do
+    link_to_signin_with_IP().should have_tag("a", '0.0.0.0')
+  end
+
+  it "should use the ip address as title" do
+    link_to_signin_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
+    link_to_signin_with_IP().should_not have_tag("a.nickname")
+  end
+  
+  it "should have some class if you tell it to" do
+    result = link_to_signin_with_IP(:class => 'foo bar')
+    result.should have_tag("a.foo")
+    result.should have_tag("a.bar")
+  end
+end
+
+describe "<%= model_controller_class_name %>Helper.link_to_current_<%= file_name %>, When logged in" do
+  fixtures :<%= table_name %>
+  include AuthenticatedTestHelper
+  before do
+    login_as(:quentin)
+  end
+
+  it "should link to the given <%= file_name %>" do
+    link_to_current_<%= file_name %>().should have_tag("a[href='/<%= table_name %>/1']")
+  end
+
+  it "should use given link text if :content_text is specified" do
+    link_to_current_user(:content_text => 'Hello there!').should have_tag("a", 'Hello there!')
+  end
+
+  it "should use the login as link text with no :content_method specified" do
+    link_to_current_user().should have_tag("a", 'quentin')
+  end
+
+  it "should use the name as link text with :content_method => :name" do
+    link_to_current_user(:content_method => :name).should have_tag("a", 'Quentin')
+  end
+
+  it "should use the login as title with no :title_method specified" do
+    link_to_current_user().should have_tag("a[title='quentin']")
+  end
+
+  it "should use the name as link title with :content_method => :name" do
+    link_to_current_user(:title_method => :name).should have_tag("a[title='Quentin']")
+  end
+
+  it "should have nickname as a class" do
+    link_to_current_user().should have_tag("a.nickname")
+  end
+
+  it "should take other classes and no longer have the nickname class" do
+    result = link_to_current_user(:class => 'foo bar')
+    result.should have_tag("a.foo")
+    result.should have_tag("a.bar")
+  end
+end
+
+
+
+describe "<%= model_controller_class_name %>Helper.link_to_current_user, When logged out" do
+  include AuthenticatedTestHelper
+  before do
+  end
+
+  it "should link to the signin_path" do
+    link_to_current_user().should have_tag("a[href='/signin']")
+  end
+
+  it "should use given link text if :content_text is specified" do
+    link_to_current_user(:content_text => 'Hello there!').should have_tag("a", 'Hello there!')
+  end
+
+  it "should use the IP address as link text with no :content_method specified" do
+    link_to_current_user().should have_tag("a", '0.0.0.0')
+  end
+
+  it "should use the ip address as title" do
+    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
+    link_to_current_user().should_not have_tag("a.nickname")
+  end
+
+  it "should have some class if you tell it to" do
+    result = link_to_current_user(:class => 'foo bar')
+    result.should have_tag("a.foo")
+    result.should have_tag("a.bar")
+  end
+end

data/lib/generators/authenticated/templates/observer.rb

@@ -0,0 +1,11 @@
+class <%= class_name %>Observer < ActiveRecord::Observer
+
+  def after_create(<%= file_name %>)
+    <%= class_name %>Mailer.signup_notification(<%= file_name %>).deliver
+  end
+
+  def after_save(<%= file_name %>)
+    <% if options[:include_activation] %><%= class_name %>Mailer.activation(<%= file_name %>).deliver if <%= file_name %>.recently_activated?<% end %>
+  end
+
+end

data/lib/generators/authenticated/templates/signup.html.erb

@@ -0,0 +1,19 @@
+<h1>Sign up as a new user</h1>
+<%% @<%= file_name %>.password = @<%= file_name %>.password_confirmation = nil %>
+
+<%%= error_messages_for :<%= file_name %> %>
+<%%= form_for :<%= file_name %>, :url => <%= model_controller_routing_name %>_path do |f| -%>
+<p><%%= label_tag 'login' %><br/>
+<%%= f.text_field :login %></p>
+
+<p><%%= label_tag 'email' %><br/>
+<%%= f.text_field :email %></p>
+
+<p><%%= label_tag 'password' %><br/>
+<%%= f.password_field :password %></p>
+
+<p><%%= label_tag 'password_confirmation', 'Confirm Password' %><br/>
+<%%= f.password_field :password_confirmation %></p>
+
+<p><%%= submit_tag 'Sign up' %></p>
+<%% end -%>

data/lib/generators/authenticated/templates/signup_notification.erb

@@ -0,0 +1,8 @@
+Your account has been created.
+
+  Username: <%%=h @<%= file_name %>.login %>
+  Password: <%%=h @<%= file_name %>.password %>
+
+Visit this url to activate your account:
+
+<%%=h @url %>

data/lib/generators/authenticated/templates/site_keys.rb

@@ -0,0 +1,38 @@
+
+# A Site key gives additional protection against a dictionary attack if your
+# DB is ever compromised.  With no site key, we store
+#   DB_password = hash(user_password, DB_user_salt)
+# If your database were to be compromised you'd be vulnerable to a dictionary
+# attack on all your stupid users' passwords.  With a site key, we store
+#   DB_password = hash(user_password, DB_user_salt, Code_site_key)
+# That means an attacker needs access to both your site's code *and* its
+# database to mount an "offline dictionary attack.":http://www.dwheeler.com/secure-programs/Secure-Programs-HOWTO/web-authentication.html
+# 
+# It's probably of minor importance, but recommended by best practices: 'defense
+# in depth'.  Needless to say, if you upload this to github or the youtubes or
+# otherwise place it in public view you'll kinda defeat the point.  Your users'
+# passwords are still secure, and the world won't end, but defense_in_depth -= 1.
+# 
+# Please note: if you change this, all the passwords will be invalidated, so DO
+# keep it someplace secure.  Use the random value given or type in the lyrics to
+# your favorite Jay-Z song or something; any moderately long, unpredictable text.
+REST_AUTH_SITE_KEY         = '<%= $rest_auth_site_key_from_generator %>'
+  
+# Repeated applications of the hash make brute force (even with a compromised
+# database and site key) harder, and scale with Moore's law.
+#
+#   bq. "To squeeze the most security out of a limited-entropy password or
+#   passphrase, we can use two techniques [salting and stretching]... that are
+#   so simple and obvious that they should be used in every password system.
+#   There is really no excuse not to use them." http://tinyurl.com/37lb73
+#   Practical Security (Ferguson & Scheier) p350
+# 
+# A modest 10 foldings (the default here) adds 3ms.  This makes brute forcing 10
+# times harder, while reducing an app that otherwise serves 100 reqs/s to 78 signin
+# reqs/s, an app that does 10reqs/s to 9.7 reqs/s
+# 
+# More:
+# * http://www.owasp.org/index.php/Hashing_Java
+# * "An Illustrated Guide to Cryptographic Hashes":http://www.unixwiz.net/techtips/iguide-crypto-hashes.html
+
+REST_AUTH_DIGEST_STRETCHES = <%= $rest_auth_digest_stretches_from_generator %>

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

@@ -0,0 +1,101 @@
+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
+
+#
+# A test controller with and without access controls
+#
+class AccessControlTestController < ApplicationController
+  before_filter :login_required, :only => :login_is_required
+  def login_is_required
+    respond_to do |format|
+      @foo = { 'success' => params[:format]||'no fmt given'}
+      format.html do render :text => "success"             end
+      format.xml  do render :xml  => @foo, :status => :ok  end
+      format.json do render :json => @foo, :status => :ok  end
+    end
+  end
+  def login_not_required
+    respond_to do |format|
+      @foo = { 'success' => params[:format]||'no fmt given'}
+      format.html do render :text => "success"             end
+      format.xml  do render :xml  => @foo, :status => :ok  end
+      format.json do render :json => @foo, :status => :ok  end
+    end
+  end
+end
+
+#
+# Access Control
+#
+
+ACCESS_CONTROL_FORMATS = [
+  ['html',     "success"],
+  ['xml',  "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<hash>\n  <success>xml</success>\n</hash>\n"],
+  ['json', "{\"success\":\"json\"}"],]
+ACCESS_CONTROL_AM_I_LOGGED_IN = [
+  [:i_am_logged_in,     :quentin],
+  [:i_am_not_logged_in, nil],]
+ACCESS_CONTROL_IS_LOGIN_REQD = [
+  :login_not_required,
+  :login_is_required,]
+
+describe AccessControlTestController do
+  fixtures        :users
+  before do
+    # is there a better way to do this?
+    begin
+      _routes = Rails.application.class.routes
+      _routes.disable_clear_and_finalize = true
+      _routes.clear!
+      Rails.application.class.routes_reloader.paths.each{ |path| load(path) }
+      _routes.draw do
+        match 'login_is_required'  => 'access_control_test#login_is_required'
+        match 'login_not_required' => 'access_control_test#login_not_required'
+    end  
+      ActiveSupport.on_load(:action_controller) { _routes.finalize! }
+    ensure
+      _routes.disable_clear_and_finalize = false
+    end
+  end
+
+  ACCESS_CONTROL_FORMATS.each do |format, success_text|
+    ACCESS_CONTROL_AM_I_LOGGED_IN.each do |logged_in_status, user_login|
+      ACCESS_CONTROL_IS_LOGIN_REQD.each do |login_reqd_status|
+        describe "requesting #{format.blank? ? 'html' : format}; #{logged_in_status.to_s.humanize} and #{login_reqd_status.to_s.humanize}" do
+          before do
+            controller.send(:logout_keeping_session!)
+            @user = format.blank? ? login_as(user_login) : authorize_as(user_login)
+            get login_reqd_status.to_s, :format => format
+          end
+
+          if ((login_reqd_status == :login_not_required) ||
+              (login_reqd_status == :login_is_required && logged_in_status == :i_am_logged_in))
+            it "succeeds" do 
+              response.body.should == success_text
+              response.code.to_s.should == '200'
+            end
+
+          elsif (login_reqd_status == :login_is_required && logged_in_status == :i_am_not_logged_in)
+            if ['html', ''].include? format
+              it "redirects me to the log in page" do
+                response.should redirect_to('/session/new')
+              end
+            else
+              it "returns 'Access denied' and a 406 (Access Denied) status code" do
+                response.should contain("HTTP Basic: Access denied.")
+                response.code.to_s.should == '401'
+              end
+            end
+
+          else
+            warn "Oops no case for #{format} and #{logged_in_status.to_s.humanize} and #{login_reqd_status.to_s.humanize}"
+          end
+        end # describe
+
+      end
+    end
+  end # cases
+
+end

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

@@ -0,0 +1,102 @@
+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
+include AuthenticatedSystem
+def action_name() end
+
+describe SessionsController do
+  fixtures :users
+  
+  before do
+    # FIXME -- sessions controller not testing xml logins 
+    stub!(:authenticate_with_http_basic).and_return nil
+  end    
+  describe "logout_killing_session!" do
+    before do
+      login_as :quentin
+      stub!(:reset_session)
+    end
+    it 'resets the session'         do should_receive(:reset_session);         logout_killing_session! end
+    it 'kills my auth_token cookie' do should_receive(:kill_remember_cookie!); logout_killing_session! end
+    it 'nils the current user'      do logout_killing_session!; current_user.should be_nil end
+    it 'kills :user_id session' do
+      session.stub!(:[]=)
+      session.should_receive(:[]=).with(:user_id, nil).at_least(:once)
+      logout_killing_session!
+    end
+    it 'forgets me' do    
+      current_user.remember_me
+      current_user.remember_token.should_not be_nil; current_user.remember_token_expires_at.should_not be_nil
+      User.find(1).remember_token.should_not be_nil; User.find(1).remember_token_expires_at.should_not be_nil
+      logout_killing_session!
+      User.find(1).remember_token.should     be_nil; User.find(1).remember_token_expires_at.should     be_nil
+    end
+  end
+
+  describe "logout_keeping_session!" do
+    before do
+      login_as :quentin
+      stub!(:reset_session)
+    end
+    it 'does not reset the session' do should_not_receive(:reset_session);   logout_keeping_session! end
+    it 'kills my auth_token cookie' do should_receive(:kill_remember_cookie!); logout_keeping_session! end
+    it 'nils the current user'      do logout_keeping_session!; current_user.should be_nil end
+    it 'kills :user_id session' do
+      session.stub!(:[]=)
+      session.should_receive(:[]=).with(:user_id, nil).at_least(:once)
+      logout_keeping_session!
+    end
+    it 'forgets me' do    
+      current_user.remember_me
+      current_user.remember_token.should_not be_nil; current_user.remember_token_expires_at.should_not be_nil
+      User.find(1).remember_token.should_not be_nil; User.find(1).remember_token_expires_at.should_not be_nil
+      logout_keeping_session!
+      User.find(1).remember_token.should     be_nil; User.find(1).remember_token_expires_at.should     be_nil
+    end
+  end
+  
+  describe 'When logged out' do 
+    it "should not be authorized?" do
+      authorized?().should be_false
+    end    
+  end
+
+  #
+  # Cookie Login
+  #
+  describe "Logging in by cookie" do
+    def set_remember_token token, time
+      @user[:remember_token]            = token; 
+      @user[:remember_token_expires_at] = time
+      @user.save!
+    end    
+    before do 
+      @user = User.find(:first); 
+      set_remember_token 'hello!', 5.minutes.from_now
+    end    
+    it 'logs in with cookie' do
+      stub!(:cookies).and_return({ :auth_token => 'hello!' })
+      logged_in?.should be_true
+    end
+    
+    it 'fails cookie login with bad cookie' do
+      should_receive(:cookies).at_least(:once).and_return({ :auth_token => 'i_haxxor_joo' })
+      logged_in?.should_not be_true
+    end
+    
+    it 'fails cookie login with no cookie' do
+      set_remember_token nil, nil
+      should_receive(:cookies).at_least(:once).and_return({ })
+      logged_in?.should_not be_true
+    end
+    
+    it 'fails expired cookie login' do
+      set_remember_token 'hello!', 5.minutes.ago
+      stub!(:cookies).and_return({ :auth_token => 'hello!' })
+      logged_in?.should_not be_true
+    end
+  end
+  
+end

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

@@ -0,0 +1,127 @@
+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 SessionsController do
+  fixtures        :users
+  before do 
+    @user  = mock_user
+    @login_params = { :login => 'quentin', :password => 'test' }
+    User.stub!(:authenticate).with(@login_params[:login], @login_params[:password]).and_return(@user)
+  end
+  def do_create
+    post :create, @login_params
+  end
+  describe "on successful login," do
+    [ [:nil,       nil,            nil],
+      [:expired,   'valid_token',  15.minutes.ago],
+      [:different, 'i_haxxor_joo', 15.minutes.from_now], 
+      [:valid,     'valid_token',  15.minutes.from_now]
+        ].each do |has_request_token, token_value, token_expiry|
+      [ true, false ].each do |want_remember_me|
+        describe "my request cookie token is #{has_request_token.to_s}," do
+          describe "and ask #{want_remember_me ? 'to' : 'not to'} be remembered" do 
+            before do
+              @ccookies = mock('cookies')
+              controller.stub!(:cookies).and_return(@ccookies)
+              @ccookies.stub!(:[]).with(:auth_token).and_return(token_value)
+              @ccookies.stub!(:delete).with(:auth_token)
+              @ccookies.stub!(:[]=)
+              @user.stub!(:remember_me) 
+              @user.stub!(:refresh_token) 
+              @user.stub!(:forget_me)
+              @user.stub!(:remember_token).and_return(token_value) 
+              @user.stub!(:remember_token_expires_at).and_return(token_expiry)
+              @user.stub!(:remember_token?).and_return(has_request_token == :valid)
+              if want_remember_me
+                @login_params[:remember_me] = '1'
+              else 
+                @login_params[:remember_me] = '0'
+              end
+            end
+            it "kills existing login"        do controller.should_receive(:logout_keeping_session!); do_create; end    
+            it "authorizes me"               do do_create; controller.send(:authorized?).should be_true;   end    
+            it "logs me in"                  do do_create; controller.send(:logged_in?).should  be_true  end    
+            it "greets me nicely"            do do_create; flash[:notice].should =~ /success/i   end
+            it "sets/resets/expires cookie"  do controller.should_receive(:handle_remember_cookie!).with(want_remember_me); do_create end
+            it "sends a cookie"              do controller.should_receive(:send_remember_cookie!);  do_create end
+            it 'redirects to the home page'  do do_create; response.should redirect_to('/')   end
+            it "does not reset my session"   do controller.should_not_receive(:reset_session).and_return nil; do_create end # change if you uncomment the reset_session path
+            if (has_request_token == :valid)
+              it 'does not make new token'   do @user.should_not_receive(:remember_me);   do_create end
+              it 'does refresh token'        do @user.should_receive(:refresh_token);     do_create end 
+              it "sets an auth cookie"       do do_create;  end
+            else
+              if want_remember_me
+                it 'makes a new token'       do @user.should_receive(:remember_me);       do_create end 
+                it "does not refresh token"  do @user.should_not_receive(:refresh_token); do_create end
+                it "sets an auth cookie"       do do_create;  end
+              else 
+                it 'does not make new token' do @user.should_not_receive(:remember_me);   do_create end
+                it 'does not refresh token'  do @user.should_not_receive(:refresh_token); do_create end 
+                it 'kills user token'        do @user.should_receive(:forget_me);         do_create end 
+              end
+            end
+          end # inner describe
+        end
+      end
+    end
+  end
+  
+  describe "on failed login" do
+    before do
+      User.should_receive(:authenticate).with(anything(), anything()).and_return(nil)
+      login_as :quentin
+    end
+    it 'logs out keeping session'   do controller.should_receive(:logout_keeping_session!); do_create end
+    it 'flashes an error'           do do_create; flash[:error].should =~ /Couldn't log you in as 'quentin'/ end
+    it 'renders the log in page'    do do_create; response.should render_template('new')  end
+    it "doesn't log me in"          do do_create; controller.send(:logged_in?).should == false end
+    it "doesn't send password back" do 
+      @login_params[:password] = 'FROBNOZZ'
+      do_create
+      response.should_not contain(/FROBNOZZ/i)
+    end
+  end
+
+  describe "on signout" do
+    def do_destroy
+      get :destroy
+    end
+    before do 
+      login_as :quentin
+    end
+    it 'logs me out'                   do controller.should_receive(:logout_killing_session!); do_destroy end
+    it 'redirects me to the home page' do do_destroy; response.should be_redirect     end
+  end
+  
+end
+
+describe SessionsController do
+  describe "route recognition and generation" do
+    it "should generate params from GET /login correctly" do
+      {:get => '/login'}.should route_to(:controller => 'sessions', :action => 'new')
+    end
+    it "should generate params from POST /session correctly" do
+      {:post => '/session'}.should route_to(:controller => 'sessions', :action => 'create')
+    end
+    it "should generate params from DELETE /session correctly" do
+      {:delete => '/logout'}.should route_to(:controller => 'sessions', :action => 'destroy')
+    end
+  end
+  
+  describe "named routing" do
+    before(:each) do
+      get :new
+    end
+    it "should route session_path() correctly" do
+      session_path().should == "/session"
+    end
+    it "should route new_session_path() correctly" do
+      new_session_path().should == "/session/new"
+    end
+  end
+  
+end