Use Admin in old rememberable tests.

test/mapping_test.rb

@@ -37,7 +37,7 @@ class MappingTest < ActiveSupport::TestCase
 
   test 'has strategies depending on the model declaration' do
     assert_equal [:rememberable, :token_authenticatable, :database_authenticatable], Devise.mappings[:user].strategies
-    assert_equal [:database_authenticatable], Devise.mappings[:admin].strategies
+    assert_equal [:rememberable, :database_authenticatable], Devise.mappings[:admin].strategies
   end
 
   test 'find scope for a given object' do
@@ -90,6 +90,6 @@ class MappingTest < ActiveSupport::TestCase
     assert mapping.recoverable?
     assert mapping.lockable?
     assert_not mapping.confirmable?
-    assert_not mapping.rememberable?
+    assert_not mapping.oauthable?
   end
 end

test/models/rememberable_test.rb

@@ -2,217 +2,217 @@ require 'test_helper'
 
 class RememberableTest < ActiveSupport::TestCase
   test 'should respond to remember_me attribute' do
-    user = new_user
-    assert user.respond_to?(:remember_me)
+    assert Admin.new.respond_to?(:remember_me)
+    assert Admin.new.respond_to?(:remember_me=)
   end
 
   test 'remember_me should generate a new token and save the record without validating' do
-    user = create_user
-    user.expects(:valid?).never
-    token = user.remember_token
-    user.remember_me!
-    assert_not_equal token, user.remember_token
-    assert_not user.changed?
+    admin = create_admin
+    admin.expects(:valid?).never
+    token = admin.remember_token
+    admin.remember_me!
+    assert_not_equal token, admin.remember_token
+    assert_not admin.changed?
   end
 
   test 'forget_me should clear remember token and save the record without validating' do
-    user = create_user
-    user.remember_me!
-    assert_not user.remember_token.nil?
-    user.expects(:valid?).never
-    user.forget_me!
-    assert user.remember_token.nil?
-    assert_not user.changed?
+    admin = create_admin
+    admin.remember_me!
+    assert_not admin.remember_token.nil?
+    admin.expects(:valid?).never
+    admin.forget_me!
+    assert admin.remember_token.nil?
+    assert_not admin.changed?
   end
 
   test 'forget_me should clear remember_created_at' do
-    user = create_user
-    user.remember_me!
-    assert_not user.remember_created_at.nil?
-    user.forget_me!
-    assert user.remember_created_at.nil?
+    admin = create_admin
+    admin.remember_me!
+    assert_not admin.remember_created_at.nil?
+    admin.forget_me!
+    assert admin.remember_created_at.nil?
   end
 
   test 'forget should do nothing if no remember token exists' do
-    user = create_user
-    user.expects(:save).never
-    user.forget_me!
+    admin = create_admin
+    admin.expects(:save).never
+    admin.forget_me!
   end
 
   test 'serialize into cookie' do
-    user = create_user
-    user.remember_me!
-    assert_equal [user.id, user.remember_token], User.serialize_into_cookie(user)
+    admin = create_admin
+    admin.remember_me!
+    assert_equal [admin.id, admin.remember_token], Admin.serialize_into_cookie(admin)
   end
 
   test 'serialize from cookie' do
-    user = create_user
-    user.remember_me!
-    assert_equal user, User.serialize_from_cookie(user.id, user.remember_token)
+    admin = create_admin
+    admin.remember_me!
+    assert_equal admin, Admin.serialize_from_cookie(admin.id, admin.remember_token)
   end
 
-  test 'serialize should return nil if no user is found' do
-    assert_nil User.serialize_from_cookie(0, "123")
+  test 'serialize should return nil if no admin is found' do
+    assert_nil Admin.serialize_from_cookie(0, "123")
   end
 
-  test 'remember me return nil if is a valid user with invalid token' do
-    user = create_user
-    assert_nil User.serialize_from_cookie(user.id, "123")
+  test 'remember me return nil if is a valid admin with invalid token' do
+    admin = create_admin
+    assert_nil Admin.serialize_from_cookie(admin.id, "123")
   end
 
   test 'remember for should fallback to devise remember for default configuration' do
     swap Devise, :remember_for => 1.day do
-      user = create_user
-      user.remember_me!
-      assert_not user.remember_expired?
+      admin = create_admin
+      admin.remember_me!
+      assert_not admin.remember_expired?
     end
   end
 
   test 'remember expires at should sum date of creation with remember for configuration' do
     swap Devise, :remember_for => 3.days do
-      user = create_user
-      user.remember_me!
-      assert_equal 3.days.from_now.to_date, user.remember_expires_at.to_date
+      admin = create_admin
+      admin.remember_me!
+      assert_equal 3.days.from_now.to_date, admin.remember_expires_at.to_date
 
       Devise.remember_for = 5.days
-      assert_equal 5.days.from_now.to_date, user.remember_expires_at.to_date
+      assert_equal 5.days.from_now.to_date, admin.remember_expires_at.to_date
     end
   end
 
   test 'remember should be expired if remember_for is zero' do
     swap Devise, :remember_for => 0.days do
       Devise.remember_for = 0.days
-      user = create_user
-      user.remember_me!
-      assert user.remember_expired?
+      admin = create_admin
+      admin.remember_me!
+      assert admin.remember_expired?
     end
   end
 
   test 'remember should be expired if it was created before limit time' do
     swap Devise, :remember_for => 1.day do
-      user = create_user
-      user.remember_me!
-      user.remember_created_at = 2.days.ago
-      user.save
-      assert user.remember_expired?
+      admin = create_admin
+      admin.remember_me!
+      admin.remember_created_at = 2.days.ago
+      admin.save
+      assert admin.remember_expired?
     end
   end
 
   test 'remember should not be expired if it was created whitin the limit time' do
     swap Devise, :remember_for => 30.days do
-      user = create_user
-      user.remember_me!
-      user.remember_created_at = (30.days.ago + 2.minutes)
-      user.save
-      assert_not user.remember_expired?
+      admin = create_admin
+      admin.remember_me!
+      admin.remember_created_at = (30.days.ago + 2.minutes)
+      admin.save
+      assert_not admin.remember_expired?
     end
   end
 
   test 'if extend_remember_period is false, remember_me! should generate a new timestamp if expired' do
     swap Devise, :remember_for => 5.minutes do
-      user = create_user
-      user.remember_me!(false)
-      assert user.remember_created_at
+      admin = create_admin
+      admin.remember_me!(false)
+      assert admin.remember_created_at
 
-      user.remember_created_at = old = 10.minutes.ago
-      user.save
+      admin.remember_created_at = old = 10.minutes.ago
+      admin.save
 
-      user.remember_me!(false)
-      assert_not_equal old.to_i, user.remember_created_at.to_i
+      admin.remember_me!(false)
+      assert_not_equal old.to_i, admin.remember_created_at.to_i
     end
   end
 
   test 'if extend_remember_period is false, remember_me! should not generate a new timestamp' do
     swap Devise, :remember_for => 1.year do
-      user = create_user
-      user.remember_me!(false)
-      assert user.remember_created_at
+      admin = create_admin
+      admin.remember_me!(false)
+      assert admin.remember_created_at
 
-      user.remember_created_at = old = 10.minutes.ago.utc
-      user.save
+      admin.remember_created_at = old = 10.minutes.ago.utc
+      admin.save
 
-      user.remember_me!(false)
-      assert_equal old.to_i, user.remember_created_at.to_i
+      admin.remember_me!(false)
+      assert_equal old.to_i, admin.remember_created_at.to_i
     end
   end
 
   test 'if extend_remember_period is true, remember_me! should always generate a new timestamp' do
     swap Devise, :remember_for => 1.year do
-      user = create_user
-      user.remember_me!(true)
-      assert user.remember_created_at
+      admin = create_admin
+      admin.remember_me!(true)
+      assert admin.remember_created_at
 
-      user.remember_created_at = old = 10.minutes.ago
-      user.save
+      admin.remember_created_at = old = 10.minutes.ago
+      admin.save
 
-      user.remember_me!(true)
-      assert_not_equal old, user.remember_created_at
+      admin.remember_me!(true)
+      assert_not_equal old, admin.remember_created_at
     end
   end
 
   test 'if remember_across_browsers is true, remember_me! should create a new token if no token exists' do
     swap Devise, :remember_across_browsers => true, :remember_for => 1.year do
-      user = create_user
-      assert_equal nil, user.remember_token
-      user.remember_me!
-      assert_not_equal nil, user.remember_token
+      admin = create_admin
+      assert_equal nil, admin.remember_token
+      admin.remember_me!
+      assert_not_equal nil, admin.remember_token
     end
   end
 
   test 'if remember_across_browsers is true, remember_me! should create a new token if a token exists but has expired' do
     swap Devise, :remember_across_browsers => true, :remember_for => 1.day do
-      user = create_user
-      user.remember_me!
-      user.remember_created_at = 2.days.ago
-      user.save
-      token = user.remember_token
-      user.remember_me!
-      assert_not_equal token, user.remember_token
+      admin = create_admin
+      admin.remember_me!
+      admin.remember_created_at = 2.days.ago
+      admin.save
+      token = admin.remember_token
+      admin.remember_me!
+      assert_not_equal token, admin.remember_token
     end
   end
 
   test 'if remember_across_browsers is true, remember_me! should not create a new token if a token exists and has not expired' do
     swap Devise, :remember_across_browsers => true, :remember_for => 2.days do
-      user = create_user
-      user.remember_me!
-      user.remember_created_at = 1.day.ago
-      user.save
-      token = user.remember_token
-      user.remember_me!
-      assert_equal token, user.remember_token
+      admin = create_admin
+      admin.remember_me!
+      admin.remember_created_at = 1.day.ago
+      admin.save
+      token = admin.remember_token
+      admin.remember_me!
+      assert_equal token, admin.remember_token
     end
   end
 
   test 'if remember_across_browsers is false, remember_me! should create a new token if no token exists' do
     swap Devise, :remember_across_browsers => false do
-      user = create_user
-      assert_equal nil, user.remember_token
-      user.remember_me!
-      assert_not_equal nil, user.remember_token
+      admin = create_admin
+      assert_equal nil, admin.remember_token
+      admin.remember_me!
+      assert_not_equal nil, admin.remember_token
     end
   end
 
   test 'if remember_across_browsers is false, remember_me! should create a new token if a token exists but has expired' do
     swap Devise, :remember_across_browsers => false, :remember_for => 1.day do
-      user = create_user
-      user.remember_me!
-      user.remember_created_at = 2.days.ago
-      user.save
-      token = user.remember_token
-      user.remember_me!
-      assert_not_equal token, user.remember_token
+      admin = create_admin
+      admin.remember_me!
+      admin.remember_created_at = 2.days.ago
+      admin.save
+      token = admin.remember_token
+      admin.remember_me!
+      assert_not_equal token, admin.remember_token
     end
   end
 
   test 'if remember_across_browsers is false, remember_me! should create a new token if a token exists and has not expired' do
     swap Devise, :remember_across_browsers => false, :remember_for => 2.days do
-      user = create_user
-      user.remember_me!
-      user.remember_created_at = 1.day.ago
-      user.save
-      token = user.remember_token
-      user.remember_me!
-      assert_not_equal token, user.remember_token
+      admin = create_admin
+      admin.remember_me!
+      admin.remember_created_at = 1.day.ago
+      admin.save
+      token = admin.remember_token
+      admin.remember_me!
+      assert_not_equal token, admin.remember_token
     end
   end
 end

test/models_test.rb

@@ -26,16 +26,16 @@ class ActiveRecordTest < ActiveSupport::TestCase
   end
 
   test 'can cherry pick modules' do
-    assert_include_modules Admin, :database_authenticatable, :registerable, :timeoutable, :recoverable, :lockable
+    assert_include_modules Admin, :database_authenticatable, :registerable, :timeoutable, :recoverable, :lockable, :rememberable
   end
 
   test 'chosen modules are inheritable' do
-    assert_include_modules Inheritable, :database_authenticatable, :registerable, :timeoutable, :recoverable, :lockable
+    assert_include_modules Inheritable, :database_authenticatable, :registerable, :timeoutable, :recoverable, :lockable, :rememberable
   end
 
   test 'order of module inclusion' do
-    correct_module_order   = [:database_authenticatable, :recoverable, :registerable, :lockable, :timeoutable]
-    incorrect_module_order = [:database_authenticatable, :timeoutable, :registerable, :recoverable, :lockable]
+    correct_module_order   = [:database_authenticatable, :rememberable, :recoverable, :registerable, :lockable, :timeoutable]
+    incorrect_module_order = [:database_authenticatable, :timeoutable, :registerable, :recoverable, :lockable, :rememberable]
 
     assert_include_modules Admin, *incorrect_module_order
 

test/rails_app/db/migrate/20100401102949_create_tables.rb

@@ -16,6 +16,7 @@ class CreateTables < ActiveRecord::Migration
 
     create_table :admins do |t|
       t.database_authenticatable :null => true, :encryptor => :bcrypt
+      t.rememberable
       t.recoverable
       t.lockable
       t.timestamps

test/rails_app/lib/shared_admin.rb

@@ -2,6 +2,6 @@ module SharedAdmin
   extend ActiveSupport::Concern
 
   included do
-    devise :database_authenticatable, :registerable, :timeoutable, :recoverable, :lockable, :unlock_strategy => :time
+    devise :database_authenticatable, :registerable, :timeoutable, :recoverable, :rememberable, :lockable, :unlock_strategy => :time
   end
 end