ggoodale-restful-authentication 1.1.1

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

@@ -0,0 +1,102 @@
+require File.dirname(__FILE__) + '<%= ('/..'*controller_class_nesting_depth) + '/../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 <%= controller_class_name %>Controller do
+  fixtures :<%= table_name %>
+  
+  before do
+    # FIXME -- <%= controller_file_name %> 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 <%= file_name %>'      do logout_killing_session!; current_<%= file_name %>.should be_nil end
+    it 'kills :<%= file_name %>_id session' do
+      session.stub!(:[]=)
+      session.should_receive(:[]=).with(:<%= file_name %>_id, nil).at_least(:once)
+      logout_killing_session!
+    end
+    it 'forgets me' do    
+      current_<%= file_name %>.remember_me
+      current_<%= file_name %>.remember_token.should_not be_nil; current_<%= file_name %>.remember_token_expires_at.should_not be_nil
+      <%= class_name %>.find(1).remember_token.should_not be_nil; <%= class_name %>.find(1).remember_token_expires_at.should_not be_nil
+      logout_killing_session!
+      <%= class_name %>.find(1).remember_token.should     be_nil; <%= class_name %>.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 <%= file_name %>'      do logout_keeping_session!; current_<%= file_name %>.should be_nil end
+    it 'kills :<%= file_name %>_id session' do
+      session.stub!(:[]=)
+      session.should_receive(:[]=).with(:<%= file_name %>_id, nil).at_least(:once)
+      logout_keeping_session!
+    end
+    it 'forgets me' do    
+      current_<%= file_name %>.remember_me
+      current_<%= file_name %>.remember_token.should_not be_nil; current_<%= file_name %>.remember_token_expires_at.should_not be_nil
+      <%= class_name %>.find(1).remember_token.should_not be_nil; <%= class_name %>.find(1).remember_token_expires_at.should_not be_nil
+      logout_keeping_session!
+      <%= class_name %>.find(1).remember_token.should     be_nil; <%= class_name %>.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
+      @<%= file_name %>[:remember_token]            = token; 
+      @<%= file_name %>[:remember_token_expires_at] = time
+      @<%= file_name %>.save!
+    end    
+    before do 
+      @<%= file_name %> = <%= class_name %>.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/generators/authenticated/templates/spec/controllers/sessions_controller_spec.rb

@@ -0,0 +1,139 @@
+require File.dirname(__FILE__) + '<%= ('/..'*controller_class_nesting_depth) + '/../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 <%= controller_class_name %>Controller do
+  fixtures        :<%= table_name %>
+  before do 
+    @<%= file_name %>  = mock_<%= file_name %>
+    @login_params = { :login => 'quentin', :password => 'test' }
+    <%= class_name %>.stub!(:authenticate).with(@login_params[:login], @login_params[:password]).and_return(@<%= file_name %>)
+  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!(:[]=)
+              @<%= file_name %>.stub!(:remember_me) 
+              @<%= file_name %>.stub!(:refresh_token) 
+              @<%= file_name %>.stub!(:forget_me)
+              @<%= file_name %>.stub!(:remember_token).and_return(token_value) 
+              @<%= file_name %>.stub!(:remember_token_expires_at).and_return(token_expiry)
+              @<%= file_name %>.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; response.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 @<%= file_name %>.should_not_receive(:remember_me);   do_create end
+              it 'does refresh token'        do @<%= file_name %>.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 @<%= file_name %>.should_receive(:remember_me);       do_create end 
+                it "does not refresh token"  do @<%= file_name %>.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 @<%= file_name %>.should_not_receive(:remember_me);   do_create end
+                it 'does not refresh token'  do @<%= file_name %>.should_not_receive(:refresh_token); do_create end 
+                it 'kills user token'        do @<%= file_name %>.should_receive(:forget_me);         do_create end 
+              end
+            end
+          end # inner describe
+        end
+      end
+    end
+  end
+  
+  describe "on failed login" do
+    before do
+      <%= class_name %>.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 have_text(/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 <%= controller_class_name %>Controller do
+  describe "route generation" do
+    it "should route the new <%= controller_controller_name %> action correctly" do
+      route_for(:controller => '<%= controller_controller_name %>', :action => 'new').should == "/login"
+    end
+    it "should route the create <%= controller_controller_name %> correctly" do
+      route_for(:controller => '<%= controller_controller_name %>', :action => 'create').should == "/<%= controller_routing_path %>"
+    end
+    it "should route the destroy <%= controller_controller_name %> action correctly" do
+      route_for(:controller => '<%= controller_controller_name %>', :action => 'destroy').should == "/logout"
+    end
+  end
+  
+  describe "route recognition" do
+    it "should generate params from GET /login correctly" do
+      params_from(:get, '/login').should == {:controller => '<%= controller_controller_name %>', :action => 'new'}
+    end
+    it "should generate params from POST /<%= controller_routing_path %> correctly" do
+      params_from(:post, '/<%= controller_routing_path %>').should == {:controller => '<%= controller_controller_name %>', :action => 'create'}
+    end
+    it "should generate params from DELETE /<%= controller_routing_path %> correctly" do
+      params_from(:delete, '/logout').should == {:controller => '<%= controller_controller_name %>', :action => 'destroy'}
+    end
+  end
+  
+  describe "named routing" do
+    before(:each) do
+      get :new
+    end
+    it "should route <%= controller_routing_name %>_path() correctly" do
+      <%= controller_routing_name %>_path().should == "/<%= controller_routing_path %>"
+    end
+    it "should route new_<%= controller_routing_name %>_path() correctly" do
+      new_<%= controller_routing_name %>_path().should == "/<%= controller_routing_path %>/new"
+    end
+  end
+  
+end

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

@@ -0,0 +1,198 @@
+require File.dirname(__FILE__) + '<%= ('/..'*model_controller_class_nesting_depth) + '/../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 <%= model_controller_class_name %>Controller do
+  fixtures :<%= table_name %>
+
+  it 'allows signup' do
+    lambda do
+      create_<%= file_name %>
+      response.should be_redirect
+    end.should change(<%= class_name %>, :count).by(1)
+  end
+
+  <% if options[:stateful] %>
+  it 'signs up user in pending state' do
+    create_<%= file_name %>
+    assigns(:<%= file_name %>).reload
+    assigns(:<%= file_name %>).should be_pending
+  end<% end %>
+
+<% if options[:include_activation] -%>
+  it 'signs up user with activation code' do
+    create_<%= file_name %>
+    assigns(:<%= file_name %>).reload
+    assigns(:<%= file_name %>).activation_code.should_not be_nil
+  end<% end -%>
+
+  it 'requires login on signup' do
+    lambda do
+      create_<%= file_name %>(:login => nil)
+      assigns[:<%= file_name %>].errors.on(:login).should_not be_nil
+      response.should be_success
+    end.should_not change(<%= class_name %>, :count)
+  end
+  
+  it 'requires password on signup' do
+    lambda do
+      create_<%= file_name %>(:password => nil)
+      assigns[:<%= file_name %>].errors.on(:password).should_not be_nil
+      response.should be_success
+    end.should_not change(<%= class_name %>, :count)
+  end
+  
+  it 'requires password confirmation on signup' do
+    lambda do
+      create_<%= file_name %>(:password_confirmation => nil)
+      assigns[:<%= file_name %>].errors.on(:password_confirmation).should_not be_nil
+      response.should be_success
+    end.should_not change(<%= class_name %>, :count)
+  end
+
+  it 'requires email on signup' do
+    lambda do
+      create_<%= file_name %>(:email => nil)
+      assigns[:<%= file_name %>].errors.on(:email).should_not be_nil
+      response.should be_success
+    end.should_not change(<%= class_name %>, :count)
+  end
+  
+  <% if options[:include_activation] %>
+  it 'activates user' do
+    <%= class_name %>.authenticate('aaron', 'monkey').should be_nil
+    get :activate, :activation_code => <%= table_name %>(:aaron).activation_code
+    response.should redirect_to('/login')
+    flash[:notice].should_not be_nil
+    flash[:error ].should     be_nil
+    <%= class_name %>.authenticate('aaron', 'monkey').should == <%= table_name %>(:aaron)
+  end
+  
+  it 'does not activate user without key' do
+    get :activate
+    flash[:notice].should     be_nil
+    flash[:error ].should_not be_nil
+  end
+  
+  it 'does not activate user with blank key' do
+    get :activate, :activation_code => ''
+    flash[:notice].should     be_nil
+    flash[:error ].should_not be_nil
+  end
+  
+  it 'does not activate user with bogus key' do
+    get :activate, :activation_code => 'i_haxxor_joo'
+    flash[:notice].should     be_nil
+    flash[:error ].should_not be_nil
+  end<% end %>
+  
+  def create_<%= file_name %>(options = {})
+    post :create, :<%= file_name %> => { :login => 'quire', :email => 'quire@example.com',
+      :password => 'quire69', :password_confirmation => 'quire69' }.merge(options)
+  end
+end
+
+describe <%= model_controller_class_name %>Controller do
+  describe "route generation" do
+    it "should route <%= model_controller_controller_name %>'s 'index' action correctly" do
+      route_for(:controller => '<%= model_controller_controller_name %>', :action => 'index').should == "/<%= model_controller_routing_path %>"
+    end
+    
+    it "should route <%= model_controller_controller_name %>'s 'new' action correctly" do
+      route_for(:controller => '<%= model_controller_controller_name %>', :action => 'new').should == "/signup"
+    end
+    
+    it "should route {:controller => '<%= model_controller_controller_name %>', :action => 'create'} correctly" do
+      route_for(:controller => '<%= model_controller_controller_name %>', :action => 'create').should == "/register"
+    end
+    
+    it "should route <%= model_controller_controller_name %>'s 'show' action correctly" do
+      route_for(:controller => '<%= model_controller_controller_name %>', :action => 'show', :id => '1').should == "/<%= model_controller_routing_path %>/1"
+    end
+    
+    it "should route <%= model_controller_controller_name %>'s 'edit' action correctly" do
+      route_for(:controller => '<%= model_controller_controller_name %>', :action => 'edit', :id => '1').should == "/<%= model_controller_routing_path %>/1/edit"
+    end
+    
+    it "should route <%= model_controller_controller_name %>'s 'update' action correctly" do
+      route_for(:controller => '<%= model_controller_controller_name %>', :action => 'update', :id => '1').should == "/<%= model_controller_routing_path %>/1"
+    end
+    
+    it "should route <%= model_controller_controller_name %>'s 'destroy' action correctly" do
+      route_for(:controller => '<%= model_controller_controller_name %>', :action => 'destroy', :id => '1').should == "/<%= model_controller_routing_path %>/1"
+    end
+  end
+  
+  describe "route recognition" do
+    it "should generate params for <%= model_controller_controller_name %>'s index action from GET /<%= model_controller_routing_path %>" do
+      params_from(:get, '/<%= model_controller_routing_path %>').should == {:controller => '<%= model_controller_controller_name %>', :action => 'index'}
+      params_from(:get, '/<%= model_controller_routing_path %>.xml').should == {:controller => '<%= model_controller_controller_name %>', :action => 'index', :format => 'xml'}
+      params_from(:get, '/<%= model_controller_routing_path %>.json').should == {:controller => '<%= model_controller_controller_name %>', :action => 'index', :format => 'json'}
+    end
+    
+    it "should generate params for <%= model_controller_controller_name %>'s new action from GET /<%= model_controller_routing_path %>" do
+      params_from(:get, '/<%= model_controller_routing_path %>/new').should == {:controller => '<%= model_controller_controller_name %>', :action => 'new'}
+      params_from(:get, '/<%= model_controller_routing_path %>/new.xml').should == {:controller => '<%= model_controller_controller_name %>', :action => 'new', :format => 'xml'}
+      params_from(:get, '/<%= model_controller_routing_path %>/new.json').should == {:controller => '<%= model_controller_controller_name %>', :action => 'new', :format => 'json'}
+    end
+    
+    it "should generate params for <%= model_controller_controller_name %>'s create action from POST /<%= model_controller_routing_path %>" do
+      params_from(:post, '/<%= model_controller_routing_path %>').should == {:controller => '<%= model_controller_controller_name %>', :action => 'create'}
+      params_from(:post, '/<%= model_controller_routing_path %>.xml').should == {:controller => '<%= model_controller_controller_name %>', :action => 'create', :format => 'xml'}
+      params_from(:post, '/<%= model_controller_routing_path %>.json').should == {:controller => '<%= model_controller_controller_name %>', :action => 'create', :format => 'json'}
+    end
+    
+    it "should generate params for <%= model_controller_controller_name %>'s show action from GET /<%= model_controller_routing_path %>/1" do
+      params_from(:get , '/<%= model_controller_routing_path %>/1').should == {:controller => '<%= model_controller_controller_name %>', :action => 'show', :id => '1'}
+      params_from(:get , '/<%= model_controller_routing_path %>/1.xml').should == {:controller => '<%= model_controller_controller_name %>', :action => 'show', :id => '1', :format => 'xml'}
+      params_from(:get , '/<%= model_controller_routing_path %>/1.json').should == {:controller => '<%= model_controller_controller_name %>', :action => 'show', :id => '1', :format => 'json'}
+    end
+    
+    it "should generate params for <%= model_controller_controller_name %>'s edit action from GET /<%= model_controller_routing_path %>/1/edit" do
+      params_from(:get , '/<%= model_controller_routing_path %>/1/edit').should == {:controller => '<%= model_controller_controller_name %>', :action => 'edit', :id => '1'}
+    end
+    
+    it "should generate params {:controller => '<%= model_controller_controller_name %>', :action => update', :id => '1'} from PUT /<%= model_controller_routing_path %>/1" do
+      params_from(:put , '/<%= model_controller_routing_path %>/1').should == {:controller => '<%= model_controller_controller_name %>', :action => 'update', :id => '1'}
+      params_from(:put , '/<%= model_controller_routing_path %>/1.xml').should == {:controller => '<%= model_controller_controller_name %>', :action => 'update', :id => '1', :format => 'xml'}
+      params_from(:put , '/<%= model_controller_routing_path %>/1.json').should == {:controller => '<%= model_controller_controller_name %>', :action => 'update', :id => '1', :format => 'json'}
+    end
+    
+    it "should generate params for <%= model_controller_controller_name %>'s destroy action from DELETE /<%= model_controller_routing_path %>/1" do
+      params_from(:delete, '/<%= model_controller_routing_path %>/1').should == {:controller => '<%= model_controller_controller_name %>', :action => 'destroy', :id => '1'}
+      params_from(:delete, '/<%= model_controller_routing_path %>/1.xml').should == {:controller => '<%= model_controller_controller_name %>', :action => 'destroy', :id => '1', :format => 'xml'}
+      params_from(:delete, '/<%= model_controller_routing_path %>/1.json').should == {:controller => '<%= model_controller_controller_name %>', :action => 'destroy', :id => '1', :format => 'json'}
+    end
+  end
+  
+  describe "named routing" do
+    before(:each) do
+      get :new
+    end
+    
+    it "should route <%= model_controller_routing_name %>_path() to /<%= model_controller_routing_path %>" do
+      <%= model_controller_routing_name %>_path().should == "/<%= model_controller_routing_path %>"
+      formatted_<%= model_controller_routing_name %>_path(:format => 'xml').should == "/<%= model_controller_routing_path %>.xml"
+      formatted_<%= model_controller_routing_name %>_path(:format => 'json').should == "/<%= model_controller_routing_path %>.json"
+    end
+    
+    it "should route new_<%= model_controller_routing_name.singularize %>_path() to /<%= model_controller_routing_path %>/new" do
+      new_<%= model_controller_routing_name.singularize %>_path().should == "/<%= model_controller_routing_path %>/new"
+      formatted_new_<%= model_controller_routing_name.singularize %>_path(:format => 'xml').should == "/<%= model_controller_routing_path %>/new.xml"
+      formatted_new_<%= model_controller_routing_name.singularize %>_path(:format => 'json').should == "/<%= model_controller_routing_path %>/new.json"
+    end
+    
+    it "should route <%= model_controller_routing_name.singularize %>_(:id => '1') to /<%= model_controller_routing_path %>/1" do
+      <%= model_controller_routing_name.singularize %>_path(:id => '1').should == "/<%= model_controller_routing_path %>/1"
+      formatted_<%= model_controller_routing_name.singularize %>_path(:id => '1', :format => 'xml').should == "/<%= model_controller_routing_path %>/1.xml"
+      formatted_<%= model_controller_routing_name.singularize %>_path(:id => '1', :format => 'json').should == "/<%= model_controller_routing_path %>/1.json"
+    end
+    
+    it "should route edit_<%= model_controller_routing_name.singularize %>_path(:id => '1') to /<%= model_controller_routing_path %>/1/edit" do
+      edit_<%= model_controller_routing_name.singularize %>_path(:id => '1').should == "/<%= model_controller_routing_path %>/1/edit"
+    end
+  end
+  
+end

data/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 %>