merbful_authentication 0.1.0

data/merb_generators/authentication/templates/login.html.erb

@@ -0,0 +1,14 @@
+<%% form_tag :action => url(:login) do -%>
+<p><label for="login">Login</label><br/>
+<%%= text_field :name => "login" %></p>
+
+<p><label for="password">Password</label><br/>
+<%%= password_field :name => "password" %></p>
+
+<!-- Uncomment this if you want this functionality
+<p><label for="remember_me">Remember me:</label>
+<%%= checkbox_field :name => 'remember_me' %></p>
+-->
+
+<p><%%= submit_button 'Log in' %></p>
+<%% end -%>

data/merb_generators/authentication/templates/mail_controller.rb

@@ -0,0 +1,13 @@
+class <%= class_name %>Mailer < Merb::MailController
+  
+  def signup_notification
+    @<%= singular_name %> = params[:<%= singular_name %>]
+    render_mail
+  end
+  
+  def activation_notification
+    @<%= singular_name %> = params[:<%= singular_name %>]
+    render_mail
+  end
+  
+end

data/merb_generators/authentication/templates/model_controller.rb

@@ -0,0 +1,33 @@
+class <%= model_controller_class_name %> < Application
+  provides :xml
+  include AuthenticatedSystem::Controller
+  
+  skip_before :login_required
+  
+  def new(<%= singular_name %> = {})
+    only_provides :html
+    @<%= singular_name %> = <%= class_name %>.new(<%= singular_name %>)
+    render @<%= singular_name %>
+  end
+  
+  def create(<%= singular_name %>)
+    cookies.delete :auth_token
+    
+    @<%= singular_name %> = <%= class_name %>.new(<%= singular_name %>)
+    if @<%= singular_name %>.save
+      redirect_back_or_default('/')
+    else
+      render :action => :new
+    end
+  end
+  
+<% if include_activation -%>
+  def activate(activation_code)
+    self.current_<%= singular_name %> = <%= class_name %>.find_activated_authenticated_model(activation_code)
+    if logged_in? && !current_<%= singular_name %>.active?
+      current_<%= singular_name %>.activate
+    end
+    redirect_back_or_default('/')
+  end
+<% end -%>
+end

data/merb_generators/authentication/templates/new_model.html.erb

@@ -0,0 +1,18 @@
+<%%= error_messages_for @user %>
+<%% form_for @user, :action => url(:users) do %>
+  <p>
+    <%%= text_control :login, :label => "Login" %>
+  </p>
+  <p>
+    <%%= text_control :email, :label => "Email" %>
+  </p>
+  <p>
+    <%%= password_control :password, :label => "Password" %>
+  </p>
+  <p>
+    <%%= password_control :password_confirmation, :label => "Password Confirmation" %>
+  </p>
+  <p>
+    <%%= submit_button "Sign up" %>
+  </p>
+<%% end %>

data/merb_generators/authentication/templates/session_controller.rb

@@ -0,0 +1,33 @@
+require 'lib/authenticated_system_controller'
+class <%= controller_class_name %> < Application
+
+  # Be sure to include AuthenticationSystem in Application Controller instead
+  include AuthenticatedSystem::Controller
+  
+  skip_before :login_required
+  
+  def new
+    render
+  end
+
+  def create(login = "", password = "")
+    self.current_<%= singular_name %> = <%= class_name %>.authenticate(login, password)
+    if logged_in?
+      if params[:remember_me] == "1"
+        self.current_<%= singular_name %>.remember_me
+        cookies[:auth_token] = { :value => self.current_<%= singular_name %>.remember_token , :expires => self.current_<%= singular_name %>.remember_token_expires_at }
+      end
+      redirect_back_or_default('/')
+    else
+      render :action => "new"
+    end
+  end
+
+  def destroy
+    self.current_<%= singular_name %>.forget_me if logged_in?
+    cookies.delete :auth_token
+    reset_session
+    redirect_back_or_default('/')
+  end
+  
+end

data/merb_generators/authentication/templates/signup.html.erb

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

data/merb_generators/authentication/templates/signup.text.erb

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

data/rspec_generators/merbful_authentication_tests/merbful_authentication_tests_generator.rb

@@ -0,0 +1,83 @@
+class MerbfulAuthenticationTestsGenerator < RubiGen::Base
+  
+  attr_reader   :name,  
+                :class_name, 
+                :class_path, 
+                :file_name, 
+                :class_nesting, 
+                :class_nesting_depth, 
+                :plural_name, 
+                :singular_name,
+                :controller_name,
+                :controller_class_path,
+                :controller_file_path,
+                :controller_class_nesting,
+                :controller_class_nesting_depth,
+                :controller_class_name,
+                :controller_singular_name,
+                :controller_plural_name,
+                :model_controller_name,
+                :model_controller_class_path,
+                :model_controller_file_path,
+                :model_controller_class_nesting,
+                :model_controller_class_nesting_depth,
+                :model_controller_class_name,
+                :model_controller_singular_name,
+                :model_controller_plural_name,
+                :include_activation
+  
+  def initialize(runtime_args, runtime_options = {})
+    super
+    usage if args.empty?
+    @name = args.shift
+    extract_options
+    runtime_options.each{ |k,v| self.instance_variable_set("@#{k}", v) }    
+  end
+
+  def manifest
+    record do |m|
+      # Ensure appropriate folder(s) exists
+      m.directory "spec"
+      m.directory "spec/models"
+      m.directory "spec/controllers"
+      m.directory "spec/mailers"
+      # Create stubs
+      m.template "model_spec_helper.rb", File.join("spec",  "#{file_name}_spec_helper.rb")
+      m.template "authenticated_system_spec_helper.rb", File.join("spec", "authenticated_system_spec_helper.rb")
+      m.template "session_controller_spec.rb", File.join("spec/controllers", "#{controller_file_path}_spec.rb")
+      m.template "model_controller_spec.rb", File.join("spec/controllers", "#{model_controller_file_path}_spec.rb")
+      m.template "model_spec.rb", File.join('spec/models', "#{file_name}_spec.rb")     
+      
+      if include_activation
+        m.template "user_mailer_spec.rb", File.join("spec/mailers", "#{singular_name}_mailer_spec.rb")
+      end
+    end
+  end
+
+  protected
+    def banner
+      <<-EOS
+Creates a ...
+
+USAGE: #{$0} #{spec.name} name"
+EOS
+    end
+
+    def add_options!(opts)
+      # opts.separator ''
+      # opts.separator 'Options:'
+      # For each option below, place the default
+      # at the top of the file next to "default_options"
+      # opts.on("-a", "--author=\"Your Name\"", String,
+      #         "Some comment about this option",
+      #         "Default: none") { |options[:author]| }
+      # opts.on("-v", "--version", "Show the #{File.basename($0)} version number and quit.")
+    end
+    
+    def extract_options
+      # for each option, extract it into a local variable (and create an "attr_reader :author" at the top)
+      # Templates can access these value via the attr_reader-generated methods, but not the
+      # raw instance variable value.
+      # @author = options[:author]
+    end
+end

data/rspec_generators/merbful_authentication_tests/templates/authenticated_system_spec_helper.rb

@@ -0,0 +1,22 @@
+class Merb::Controller
+  require "merb/session/memory_session"
+  Merb::MemorySessionContainer.setup
+  include ::Merb::SessionMixin
+  self.session_secret_key = "foo to the bar to the baz"
+end
+
+class Merb::Mailer
+  self.delivery_method = :test_send
+end
+
+class Hash
+  
+  def with( opts )
+    self.merge(opts)
+  end
+  
+  def without(*args)
+    self.dup.delete_if{ |k,v| args.include?(k)}
+  end
+  
+end

data/rspec_generators/merbful_authentication_tests/templates/model_controller_spec.rb

@@ -0,0 +1,78 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')
+require File.join( File.dirname(__FILE__), "..", "<%= singular_name %>_spec_helper")
+require File.join( File.dirname(__FILE__), "..", "authenticated_system_spec_helper")
+
+describe <%= model_controller_class_name %> do
+  
+  include <%= class_name %>SpecHelper
+  
+  before(:each) do
+    <%= class_name %>.clear_database_table
+  end
+  
+  it 'allows signup' do
+     lambda do
+       create_<%= singular_name %>
+       controller.should redirect      
+     end.should change(<%= class_name %>, :count).by(1)
+   end
+
+   it 'requires login on signup' do
+     lambda do
+       create_<%= singular_name %>(:login => nil)
+       controller.assigns(:<%= singular_name %>).errors.on(:login).should_not be_nil
+       controller.should be_successful
+     end.should_not change(<%= class_name %>, :count)
+   end
+    
+   it 'requires password on signup' do
+     lambda do
+       create_<%= singular_name %>(:password => nil)
+       controller.assigns(:<%= singular_name %>).errors.on(:password).should_not be_nil
+       controller.should be_successful
+     end.should_not change(<%= class_name %>, :count)
+   end
+     
+   it 'requires password confirmation on signup' do
+     lambda do
+       create_<%= singular_name %>(:password_confirmation => nil)
+       controller.assigns(:<%= singular_name %>).errors.on(:password_confirmation).should_not be_nil
+       controller.should be_successful
+     end.should_not change(<%= class_name %>, :count)
+   end
+   
+   it 'requires email on signup' do
+     lambda do
+       create_<%= singular_name %>(:email => nil)
+       controller.assigns(:<%= singular_name %>).errors.on(:email).should_not be_nil
+       controller.should be_successful
+     end.should_not change(<%= class_name %>, :count)
+   end
+   
+<% if include_activation -%>
+   it "should have a route for <%= singular_name %> activation" do
+     with_route("/<%= model_controller_plural_name %>/activate/1234") do |params|
+       params[:controller].should == "<%= model_controller_class_name %>"
+       params[:action].should == "activate" 
+       params[:activation_code].should == "1234"    
+     end
+   end
+
+   it 'activates <%= singular_name %>' do
+     create_<%= singular_name %>(:login => "aaron", :password => "test", :password_confirmation => "test")
+     @<%= singular_name %> = controller.assigns(:<%= singular_name %>)
+     <%= class_name %>.authenticate('aaron', 'test').should be_nil
+     get "/<%= model_controller_plural_name %>/activate/1234" 
+     controller.should redirect_to("/")
+   end
+
+   it 'does not activate <%= singular_name %> without key' do
+       get "/<%= model_controller_plural_name %>/activate"
+       controller.should be_missing
+   end
+<% end -%>
+     
+   def create_<%= singular_name %>(options = {})
+     post "/<%= model_controller_plural_name %>", :<%= singular_name %> => valid_<%= singular_name %>_hash.merge(options)
+   end
+end

data/rspec_generators/merbful_authentication_tests/templates/model_spec.rb

@@ -0,0 +1,357 @@
+require File.join( File.dirname(__FILE__), "..", "spec_helper" )
+require File.join( File.dirname(__FILE__), "..", "<%= singular_name %>_spec_helper")
+require File.join( File.dirname(__FILE__), "..", "authenticated_system_spec_helper")
+
+describe <%= class_name %> do
+  include <%= class_name %>SpecHelper
+  
+  before(:each) do
+    <%= class_name %>.clear_database_table
+<% if include_activation -%>
+    <%= class_name %>Mailer.stub!(:activation_notification).and_return(true)
+<% end -%>
+  end
+
+  it "should have a login field" do
+    <%= singular_name %> = <%= class_name %>.new
+    <%= singular_name %>.should respond_to(:login)
+    <%= singular_name %>.valid?
+    <%= singular_name %>.errors.on(:login).should_not be_nil
+  end
+  
+  it "should fail login if there are less than 3 chars" do
+    <%= singular_name %> = <%= class_name %>.new
+    <%= singular_name %>.login = "AB"
+    <%= singular_name %>.valid?
+    <%= singular_name %>.errors.on(:login).should_not be_nil
+  end
+  
+  it "should not fail login with between 3 and 40 chars" do
+    <%= singular_name %> = <%= class_name %>.new
+    [3,40].each do |num|
+      <%= singular_name %>.login = "a" * num
+      <%= singular_name %>.valid?
+      <%= singular_name %>.errors.on(:login).should be_nil
+    end
+  end
+  
+  it "should fail login with over 90 chars" do
+    <%= singular_name %> = <%= class_name %>.new
+    <%= singular_name %>.login = "A" * 41
+    <%= singular_name %>.valid?
+    <%= singular_name %>.errors.on(:login).should_not be_nil    
+  end
+  
+  it "should make a valid <%= singular_name %>" do
+    <%= singular_name %> = <%= class_name %>.new(valid_<%= singular_name %>_hash)
+    <%= singular_name %>.save
+    <%= singular_name %>.errors.should be_empty
+    
+  end
+  
+  it "should make sure login is unique" do
+    <%= singular_name %> = <%= class_name %>.new( valid_<%= singular_name %>_hash.with(:login => "Daniel") )
+    <%= singular_name %>2 = <%= class_name %>.new( valid_<%= singular_name %>_hash.with(:login => "Daniel"))
+    <%= singular_name %>.save.should be_true
+    <%= singular_name %>.login = "Daniel"
+    <%= singular_name %>2.save.should be_false
+    <%= singular_name %>2.errors.on(:login).should_not be_nil
+  end
+  
+  it "should make sure login is unique regardless of case" do
+    <%= class_name %>.find_with_conditions(:login => "Daniel").should be_nil
+    <%= singular_name %> = <%= class_name %>.new( valid_<%= singular_name %>_hash.with(:login => "Daniel") )
+    <%= singular_name %>2 = <%= class_name %>.new( valid_<%= singular_name %>_hash.with(:login => "daniel"))
+    <%= singular_name %>.save.should be_true
+    <%= singular_name %>.login = "Daniel"
+    <%= singular_name %>2.save.should be_false
+    <%= singular_name %>2.errors.on(:login).should_not be_nil
+  end
+  
+  it "should downcase logins" do
+    <%= singular_name %> = <%= class_name %>.new( valid_<%= singular_name %>_hash.with(:login => "DaNieL"))
+    <%= singular_name %>.login.should == "daniel"    
+  end  
+  
+  it "should authenticate a <%= singular_name %> using a class method" do
+    <%= singular_name %> = <%= class_name %>.new(valid_<%= singular_name %>_hash)
+    <%= singular_name %>.save
+<% if include_activation -%>
+    <%= singular_name %>.activate
+<% end -%>
+    <%= class_name %>.authenticate(valid_<%= singular_name %>_hash[:login], valid_<%= singular_name %>_hash[:password]).should_not be_nil
+  end
+  
+  it "should not authenticate a <%= singular_name %> using the wrong password" do
+    <%= singular_name %> = <%= class_name %>.new(valid_<%= singular_name %>_hash)  
+    <%= singular_name %>.save
+<% if include_activation -%>  
+    <%= singular_name %>.activate
+<% end -%>
+    <%= class_name %>.authenticate(valid_<%= singular_name %>_hash[:login], "not_the_password").should be_nil
+  end
+  
+  it "should not authenticate a <%= singular_name %> using the wrong login" do
+    <%= singular_name %> = <%= class_name %>.create(valid_<%= singular_name %>_hash)  
+<% if include_activation -%>  
+    <%= singular_name %>.activate
+<% end -%>
+    <%= class_name %>.authenticate("not_the_login", valid_<%= singular_name %>_hash[:password]).should be_nil
+  end
+  
+  it "should not authenticate a <%= singular_name %> that does not exist" do
+    <%= class_name %>.authenticate("i_dont_exist", "password").should be_nil
+  end
+  
+<% if include_activation -%> 
+  it "should send a please activate email" do
+    <%= singular_name %> = <%= class_name %>.new(valid_<%= singular_name %>_hash)
+    <%= class_name %>Mailer.should_receive(:dispatch_and_deliver) do |action, mail_args, mailer_params|
+      action.should == :signup_notification
+      [:from, :to, :subject].each{ |f| mail_args.keys.should include(f)}
+      mail_args[:to].should == <%= singular_name %>.email
+      mailer_params[:<%= singular_name %>].should == <%= singular_name %>
+    end
+    <%= singular_name %>.save
+  end
+  
+  it "should not send a please activate email when updating" do
+    <%= singular_name %> = <%= class_name %>.new(valid_<%= singular_name %>_hash)
+    <%= singular_name %>.save
+    <%= class_name %>Mailer.should_not_receive(:signup_notification)
+    <%= singular_name %>.login = "not in the valid hash for login"
+    <%= singular_name %>.save    
+  end
+<% end -%>  
+end
+
+describe <%= class_name %>, "the password fields for <%= class_name %>" do
+  include <%= class_name %>SpecHelper
+  
+  before(:each) do
+    <%= class_name %>.clear_database_table
+    @<%= singular_name %> = <%= class_name %>.new( valid_<%= singular_name %>_hash )
+<% if include_activation -%>
+    <%= class_name %>Mailer.stub!(:activation_notification).and_return(true)
+<% end -%>
+  end
+  
+  it "should respond to password" do
+    @<%= singular_name %>.should respond_to(:password)    
+  end
+  
+  it "should respond to password_confirmation" do
+    @<%= singular_name %>.should respond_to(:password_confirmation)
+  end
+  
+  it "should have a protected password_required method" do
+    @<%= singular_name %>.protected_methods.should include("password_required?")
+  end
+  
+  it "should respond to crypted_password" do
+    @<%= singular_name %>.should respond_to(:crypted_password)    
+  end
+  
+  it "should require password if password is required" do
+    <%= singular_name %> = <%= class_name %>.new( valid_<%= singular_name %>_hash.without(:password))
+    <%= singular_name %>.stub!(:password_required?).and_return(true)
+    <%= singular_name %>.valid?
+    <%= singular_name %>.errors.on(:password).should_not be_nil
+    <%= singular_name %>.errors.on(:password).should_not be_empty
+  end
+  
+  it "should set the salt" do
+    <%= singular_name %> = <%= class_name %>.new(valid_<%= singular_name %>_hash)
+    <%= singular_name %>.salt.should be_nil
+    <%= singular_name %>.send(:encrypt_password)
+    <%= singular_name %>.salt.should_not be_nil    
+  end
+  
+  it "should require the password on create" do
+    <%= singular_name %> = <%= class_name %>.new(valid_<%= singular_name %>_hash.without(:password))
+    <%= singular_name %>.save
+    <%= singular_name %>.errors.on(:password).should_not be_nil
+    <%= singular_name %>.errors.on(:password).should_not be_empty
+  end  
+  
+  it "should require password_confirmation if the password_required?" do
+    <%= singular_name %> = <%= class_name %>.new(valid_<%= singular_name %>_hash.without(:password_confirmation))
+    <%= singular_name %>.save
+    (<%= singular_name %>.errors.on(:password) || <%= singular_name %>.errors.on(:password_confirmation)).should_not be_nil
+  end
+  
+  it "should fail when password is outside 4 and 40 chars" do
+    [3,41].each do |num|
+      <%= singular_name %> = <%= class_name %>.new(valid_<%= singular_name %>_hash.with(:password => ("a" * num)))
+      <%= singular_name %>.valid?
+      <%= singular_name %>.errors.on(:password).should_not be_nil
+    end
+  end
+  
+  it "should pass when password is within 4 and 40 chars" do
+    [4,30,40].each do |num|
+      <%= singular_name %> = <%= class_name %>.new(valid_<%= singular_name %>_hash.with(:password => ("a" * num), :password_confirmation => ("a" * num)))
+      <%= singular_name %>.valid?
+      <%= singular_name %>.errors.on(:password).should be_nil
+    end    
+  end
+  
+  it "should autenticate against a password" do
+    <%= singular_name %> = <%= class_name %>.new(valid_<%= singular_name %>_hash)
+    <%= singular_name %>.save    
+    <%= singular_name %>.should be_authenticated(valid_<%= singular_name %>_hash[:password])
+  end
+  
+  it "should not require a password when saving an existing <%= singular_name %>" do
+    <%= singular_name %> = <%= class_name %>.create(valid_<%= singular_name %>_hash)
+    <%= singular_name %> = <%= class_name %>.find_with_conditions(:login => valid_<%= singular_name %>_hash[:login])
+    <%= singular_name %>.password.should be_nil
+    <%= singular_name %>.password_confirmation.should be_nil
+    <%= singular_name %>.login = "some_different_login_to_allow_saving"
+    (<%= singular_name %>.save).should be_true
+  end
+  
+end
+
+<% if include_activation -%>
+describe <%= class_name %>, "activation" do
+  include <%= class_name %>SpecHelper
+  
+  
+  before(:each) do
+    <%= class_name %>.clear_database_table
+    @<%= singular_name %> = <%= class_name %>.new(valid_<%= singular_name %>_hash)
+  end
+  
+  it "should have an activation_code as an attribute" do
+    @<%= singular_name %>.attributes.keys.any?{|a| a.to_s == "activation_code"}.should_not be_nil
+  end
+  
+  it "should create an activation code on create" do
+    @<%= singular_name %>.activation_code.should be_nil    
+    @<%= singular_name %>.save
+    @<%= singular_name %>.activation_code.should_not be_nil
+  end
+  
+  it "should not be active when created" do
+    @<%= singular_name %>.should_not be_activated
+    @<%= singular_name %>.save
+    @<%= singular_name %>.should_not be_activated    
+  end
+  
+  it "should respond to activate" do
+    @<%= singular_name %>.should respond_to(:activate)    
+  end
+  
+  it "should activate a <%= singular_name %> when activate is called" do
+    @<%= singular_name %>.should_not be_activated
+    @<%= singular_name %>.save
+    @<%= singular_name %>.activate
+    @<%= singular_name %>.should be_activated
+    <%= class_name %>.find_with_conditions(:login => valid_<%= singular_name %>_hash[:login]).should be_activated
+  end
+  
+  it "should should show recently activated when the instance is activated" do
+    @<%= singular_name %>.should_not be_recently_activated
+    @<%= singular_name %>.activate
+    @<%= singular_name %>.should be_recently_activated
+  end
+  
+  it "should not show recently activated when the instance is fresh" do
+    @<%= singular_name %>.activate
+    @<%= singular_name %> = nil
+    <%= class_name %>.find_with_conditions(:login => valid_<%= singular_name %>_hash[:login]).should_not be_recently_activated
+  end
+  
+  it "should send out a welcome email to confirm that the account is activated" do
+    @<%= singular_name %>.save
+    <%= class_name %>Mailer.should_receive(:dispatch_and_deliver) do |action, mail_args, mailer_params|
+      action.should == :activation_notification
+      mail_args.keys.should include(:from)
+      mail_args.keys.should include(:to)
+      mail_args.keys.should include(:subject)
+      mail_args[:to].should == @<%= singular_name %>.email
+      mailer_params[:<%= singular_name %>].should == @<%= singular_name %>
+    end
+    @<%= singular_name %>.activate
+  end
+  
+end
+<% end -%>
+
+describe <%= class_name %>, "remember_me" do
+  include <%= class_name %>SpecHelper
+  
+  predicate_matchers[:remember_token] = :remember_token?
+  
+  before do
+    <%= class_name %>.clear_database_table
+    @<%= singular_name %> = <%= class_name %>.new(valid_<%= singular_name %>_hash)
+  end
+  
+  it "should have a remember_token_expires_at attribute" do
+    @<%= singular_name %>.attributes.keys.any?{|a| a.to_s == "remember_token_expires_at"}.should_not be_nil
+  end  
+  
+  it "should respond to remember_token?" do
+    @<%= singular_name %>.should respond_to(:remember_token?)
+  end
+  
+  it "should return true if remember_token_expires_at is set and is in the future" do
+    @<%= singular_name %>.remember_token_expires_at = DateTime.now + 3600
+    @<%= singular_name %>.should remember_token    
+  end
+  
+  it "should set remember_token_expires_at to a specific date" do
+    time = Time.mktime(2009,12,25)
+    @<%= singular_name %>.remember_me_until(time)
+    @<%= singular_name %>.remember_token_expires_at.should == time    
+  end
+  
+  it "should set the remember_me token when remembering" do
+    time = Time.mktime(2009,12,25)
+    @<%= singular_name %>.remember_me_until(time)
+    @<%= singular_name %>.remember_token.should_not be_nil
+    @<%= singular_name %>.save
+    <%= class_name %>.find_with_conditions(:login => valid_<%= singular_name %>_hash[:login]).remember_token.should_not be_nil
+  end
+  
+  it "should remember me for" do
+    t = Time.now
+    Time.stub!(:now).and_return(t)
+    today = Time.now
+    remember_until = today + (2* Merb::Const::WEEK)
+    @<%= singular_name %>.remember_me_for( Merb::Const::WEEK * 2)
+    @<%= singular_name %>.remember_token_expires_at.should == (remember_until)
+  end
+  
+  it "should remember_me for two weeks" do
+    t = Time.now
+    Time.stub!(:now).and_return(t)
+    @<%= singular_name %>.remember_me
+    @<%= singular_name %>.remember_token_expires_at.should == (Time.now + (2 * Merb::Const::WEEK ))
+  end
+  
+  it "should forget me" do
+    @<%= singular_name %>.remember_me
+    @<%= singular_name %>.save
+    @<%= singular_name %>.forget_me
+    @<%= singular_name %>.remember_token.should be_nil
+    @<%= singular_name %>.remember_token_expires_at.should be_nil    
+  end
+  
+  it "should persist the forget me to the database" do
+    @<%= singular_name %>.remember_me
+    @<%= singular_name %>.save
+    
+    @<%= singular_name %> = <%= class_name %>.find_with_conditions(:login => valid_<%= singular_name %>_hash[:login])
+    @<%= singular_name %>.remember_token.should_not be_nil
+    
+    @<%= singular_name %>.forget_me
+
+    @<%= singular_name %> = <%= class_name %>.find_with_conditions(:login => valid_<%= singular_name %>_hash[:login])
+    @<%= singular_name %>.remember_token.should be_nil
+    @<%= singular_name %>.remember_token_expires_at.should be_nil
+  end
+  
+end