goma 0.0.1.rc1 → 0.0.1.rc2

data/test/models/confirmable_test.rb

@@ -1,227 +1,275 @@
 require "test_helper"
 
 class ConfirmableTest < ActiveSupport::TestCase
-  context "A newly created user" do
-    setup do
-      @user = User.new(username: 'foo', email: 'foo@example.com', password: 'password')
-    end
+  test 'should not be activated when user is created' do
+    user = User.create(username: 'foo', email: 'foo@example.com', password: 'password')
+    user.reload
+    refute user.activated?
+  end
+
+  test 'should send activation needed email when user is created' do
+    Goma.token_generator.expects(:friendly_token).returns('sesame')
 
-    should "not be activated" do
-      @user.save!
-      @user.reload
-      refute @user.activated?
+    user = User.new(username: 'foo', email: 'foo@example.com', password: 'password')
+    assert_emails 1 do
+      user.save!
     end
+    email = ActionMailer::Base.deliveries.last
+    assert_match %r{/confirmations/sesame}, email.body.encoded
+  end
 
-    should "be sent activation needed email when saving" do
-      assert_difference('ActionMailer::Base.deliveries.size', 1) do
-        @user.save!
+  test 'should not send activation needed email when user is created if activation_needed_email_method_name == nil' do
+    swap Goma.config(:user), activation_needed_email_method_name: nil do
+      user = User.new(username: 'foo', email: 'foo@example.com', password: 'password')
+      assert_no_emails do
+        user.save!
       end
     end
   end
 
-  context "User.load_from_activation_token!" do
-    setup do
-      @user = Fabricate(:unactivated_user)
-    end
+  test 'load_from_activation_token_with_error with correct token' do
+    user = Fabricate(:unactivated_user)
+    raw_token = user.raw_confirmation_token
+    loaded_user, error = User.load_from_activation_token_with_error(raw_token)
+    assert_equal user, loaded_user
+    assert_nil error
+  end
 
-    should "load user record with correct activation token" do
-      raw_token = @user.raw_confirmation_token
-      loaded_user = User.load_from_activation_token!(raw_token)
-      assert_equal @user, loaded_user
-    end
+  test 'load_from_activation_token_with_error with wrong token' do
+    user = Fabricate(:unactivated_user)
+    loaded_user, error = User.load_from_activation_token_with_error('beans')
+    assert_nil loaded_user
+    assert_equal :not_found, error
+  end
 
-    should "raise exception with incorrect activation token" do
-      assert_raise Goma::NotFound do
-        User.load_from_activation_token!('blahblahblah')
-      end
+  test 'load_from_activation_token_with_error with expired token' do
+    user = Fabricate(:unactivated_user)
+    raw_token = user.raw_confirmation_token
+    Timecop.travel 4.days.from_now do
+      loaded_user, error = User.load_from_activation_token_with_error(raw_token)
+      assert_nil loaded_user
+      assert_equal :token_expired, error
     end
+  end
 
-    should "raise exception with correct activation token which is expired" do
-      raw_token = @user.raw_confirmation_token
-      @user.update_attribute(:confirmation_token_sent_at, 7.days.ago)
+  test 'load_from_activation_token! with correct token' do
+    user = Fabricate(:unactivated_user)
+    raw_token = user.raw_confirmation_token
+    assert_equal user, User.load_from_activation_token!(raw_token)
+  end
 
+  test 'load_from_activation_token! with wrong token' do
+    user = Fabricate(:unactivated_user)
+    assert_raise Goma::NotFound do
+      User.load_from_activation_token!('beans')
+    end
+  end
+
+  test 'load_from_activation_token! with expired token' do
+    user = Fabricate(:unactivated_user)
+    raw_token = user.raw_confirmation_token
+    Timecop.travel 4.days.from_now do
       assert_raise Goma::TokenExpired do
         User.load_from_activation_token!(raw_token)
       end
     end
   end
 
-  context "User.load_from_activation_token_with_error" do
-    setup do
-      @user = Fabricate(:unactivated_user)
-    end
+  test 'load_from_activation_token with correct token' do
+    user = Fabricate(:unactivated_user)
+    raw_token = user.raw_confirmation_token
+    assert_equal user, User.load_from_activation_token(raw_token)
+  end
 
-    should "return user record and nil with correct activation token" do
-      raw_token = @user.raw_confirmation_token
-      loaded_user, error = User.load_from_activation_token_with_error(raw_token)
-      assert_equal @user, loaded_user
-      assert_nil error
-    end
+  test 'load_from_activation_token with wrong token' do
+    user = Fabricate(:unactivated_user)
+    assert_nil User.load_from_activation_token('beans')
+  end
 
-    should "return nil and :not_found with incorrect activation token" do
-      loaded_user, error = User.load_from_activation_token_with_error('blahblahblah')
-      assert_nil loaded_user
-      assert_equal :not_found, error
+  test 'load_from_activation_token with expired token' do
+    user = Fabricate(:unactivated_user)
+    raw_token = user.raw_confirmation_token
+    Timecop.travel 4.days.from_now do
+      assert_nil User.load_from_activation_token(raw_token)
     end
+  end
 
-    should "return nil and :token_expired with correct activation token which is expired" do
-      raw_token = @user.raw_confirmation_token
-      @user.update_attribute(:confirmation_token_sent_at, 7.days.ago)
+  test 'activate!' do
+    user = Fabricate(:unactivated_user)
+    refute user.activated?
 
-      loaded_user, error = User.load_from_activation_token_with_error(raw_token)
-      assert_nil loaded_user
-      assert_equal :token_expired, error
-    end
+    user.activate!
+    user.reload
+    assert user.activated?
+    assert_nil user.confirmation_token
+    assert_nil user.confirmation_token_sent_at
   end
 
-  context "User.load_from_activation_token" do
-    setup do
-      @user = Fabricate(:unactivated_user)
+  test 'should send activation success email when activating' do
+    user = Fabricate(:unactivated_user)
+    assert_emails 1 do
+      user.activate!
     end
+    email = ActionMailer::Base.deliveries.last
+    assert_match /You have successfully activated your account/, email.body.encoded
+  end
 
-    should "return user record with correct activation token" do
-      raw_token = @user.raw_confirmation_token
-      loaded_user = User.load_from_activation_token(raw_token)
-      assert_equal @user, loaded_user
+  test 'should not send activation success email when activating if activation_success_email_method_name == nil' do
+    swap Goma.config(:user), activation_success_email_method_name: nil do
+      user = Fabricate(:unactivated_user)
+      assert_no_emails do
+        user.activate!
+      end
     end
+  end
 
-    should "return nil with incorrect activation token" do
-      loaded_user = User.load_from_activation_token('blahblahblah')
-      assert_nil loaded_user
+  test 'should change email immediately if email_confirmation_enabled == false' do
+    swap Goma.config(:user), email_confirmation_enabled: false do
+      user = Fabricate(:user)
+      user.update(email: 'new@example.com')
+      user.reload
+      assert_equal 'new@example.com', user.email
     end
+  end
 
-    should "return nil with correct activation token which is expired" do
-      raw_token = @user.raw_confirmation_token
-      @user.update_attribute(:confirmation_token_sent_at, 7.days.ago)
-
-      loaded_user = User.load_from_activation_token(raw_token)
-      assert_nil loaded_user
-    end
+  test 'should postpone email change' do
+    user = Fabricate(:user)
+    old_email = user.email
+    user.update(email: 'new@example.com')
+    user.reload
+    assert_equal old_email, user.email
+    assert_equal 'new@example.com', user.unconfirmed_email
+    assert user.confirmation_token
+    assert user.confirmation_token_sent_at
   end
 
-  context "A user" do
-    setup do
-      @user = Fabricate(:unactivated_user)
-    end
+  test 'should send email confirmation needed email when email is changed' do
+    Goma.token_generator.stubs(:friendly_token).returns('sesame')
 
-    should "be filled activated_at field when activate!ing" do
-      refute @user.activated_at
-      @user.activate!
-      @user.reload
-      assert @user.activated_at
+    user = Fabricate(:user)
+    assert_emails 1 do
+      user.update(email: 'new@example.com')
     end
+    email = ActionMailer::Base.deliveries.last
+    assert_match %r{/confirmations/sesame/email}, email.body.encoded
+  end
 
-    should "be sent activation success email when activate!ing" do
-      assert_difference('ActionMailer::Base.deliveries.size', 1) do
-        @user.activate!
+  test 'should not send email confirmation needed email when email is changed if email_confirmation_needed_email_method_name == nil' do
+    swap Goma.config(:user), email_confirmation_needed_email_method_name: nil do
+      user = Fabricate(:user)
+      assert_no_emails do
+        user.update(email: 'new@example.com')
       end
     end
   end
 
-  context "A user who changed email" do
-    setup do
-      @user = Fabricate(:user)
-      @old_email = @user.email
-      @user.email = 'another@example.com'
-    end
-
-    should "be postponed email change" do
-      @user.save!
-      assert_equal @old_email, @user.email
-      assert_equal 'another@example.com', @user.unconfirmed_email
-    end
+  test 'load_from_email_confirmation_token_with_error with correct token' do
+    user = Fabricate(:user)
+    user.update(email: 'new@example.com')
+    raw_token = user.raw_confirmation_token
+    loaded_user, error = User.load_from_email_confirmation_token_with_error(raw_token)
+    assert_equal user, loaded_user
+    assert_nil error
+  end
 
-    should "be sent email confirmation needed email when saving" do
-      assert_difference('ActionMailer::Base.deliveries.size', 1) do
-        @user.save!
-      end
-    end
+  test 'load_from_email_confirmation_token_with_error with wrong token' do
+    user = Fabricate(:user)
+    user.update(email: 'new@example.com')
+    loaded_user, error = User.load_from_email_confirmation_token_with_error('beans')
+    assert_nil loaded_user
+    assert_equal :not_found, error
   end
 
-  context "User.load_from_email_confirmation_token!" do
-    setup do
-      @user = Fabricate(:user)
-      @user.email = 'another@example.com'
-      @user.save!
+  test 'load_from_email_confirmation_token_with_error with expired token' do
+    user = Fabricate(:user)
+    user.update(email: 'new@example.com')
+    raw_token = user.raw_confirmation_token
+    Timecop.travel 4.days.from_now do
+      loaded_user, error = User.load_from_email_confirmation_token_with_error(raw_token)
+      assert_nil loaded_user
+      assert_equal :token_expired, error
     end
+  end
 
-    should "find user record with correct email confirmation token" do
-      raw_token = @user.raw_confirmation_token
-      loaded_user = User.load_from_email_confirmation_token!(raw_token)
-      assert_equal @user, loaded_user
-    end
+  test 'load_from_email_confirmation_token! with correct token' do
+    user = Fabricate(:user)
+    user.update(email: 'new@example.com')
+    raw_token = user.raw_confirmation_token
+    assert_equal user, User.load_from_email_confirmation_token!(raw_token)
+  end
 
-    should "not find user record with incorrect confirmation token" do
-      assert_raise Goma::NotFound do
-        User.load_from_email_confirmation_token!('blahblahblah')
-      end
+  test 'load_from_email_confirmation_token! with wrong token' do
+    user = Fabricate(:user)
+    user.update(email: 'new@example.com')
+    assert_raise Goma::NotFound do
+      User.load_from_email_confirmation_token!('beans')
     end
+  end
 
-    should "not find user record with correct confirmation token which is expired" do
-      raw_token = @user.raw_confirmation_token
-      @user.update_attribute(:confirmation_token_sent_at, 7.days.ago)
-
+  test 'load_from_email_confirmation_token! with expired token' do
+    user = Fabricate(:user)
+    user.update(email: 'new@example.com')
+    raw_token = user.raw_confirmation_token
+    Timecop.travel 4.days.from_now do
       assert_raise Goma::TokenExpired do
         User.load_from_email_confirmation_token!(raw_token)
       end
     end
   end
 
-  context "User.load_from_email_confirmation_token_with_error" do
-    setup do
-      @user = Fabricate(:user)
-      @user.email = 'another@example.com'
-      @user.save!
-    end
-
-    should "return user record and nil with correct email_confirmation token" do
-      raw_token = @user.raw_confirmation_token
-      loaded_user, error = User.load_from_email_confirmation_token_with_error(raw_token)
-      assert_equal @user, loaded_user
-      assert_nil error
-    end
-
-    should "return nil and :not_found with incorrect email_confirmation token" do
-      loaded_user, error = User.load_from_email_confirmation_token_with_error('blahblahblah')
-      assert_nil loaded_user
-      assert_equal :not_found, error
-    end
-
-    should "return nil and :token_expired with correct email_confirmation token which is expired" do
-      raw_token = @user.raw_confirmation_token
-      @user.update_attribute(:confirmation_token_sent_at, 7.days.ago)
+  test 'load_from_email_confirmation_token with correct token' do
+    user = Fabricate(:user)
+    user.update(email: 'new@example.com')
+    raw_token = user.raw_confirmation_token
+    assert_equal user, User.load_from_email_confirmation_token(raw_token)
+  end
 
-      loaded_user, error = User.load_from_email_confirmation_token_with_error(raw_token)
-      assert_nil loaded_user
-      assert_equal :token_expired, error
-    end
+  test 'load_from_email_confirmation_token with wrong token' do
+    user = Fabricate(:user)
+    user.update(email: 'new@example.com')
+    assert_nil User.load_from_email_confirmation_token('beans')
   end
 
-  context "User.load_from_email_confirmation_token" do
-    setup do
-      @user = Fabricate(:user)
-      @user.email = 'another@example.com'
-      @user.save!
+  test 'load_from_email_confirmation_token with expired token' do
+    user = Fabricate(:user)
+    user.update(email: 'new@example.com')
+    raw_token = user.raw_confirmation_token
+    Timecop.travel 4.days.from_now do
+      assert_nil User.load_from_email_confirmation_token(raw_token)
     end
+  end
 
-    should "return user record with correct email_confirmation token" do
-      raw_token = @user.raw_confirmation_token
-      loaded_user = User.load_from_email_confirmation_token(raw_token)
-      assert_equal @user, loaded_user
-    end
+  test 'confirm_email!' do
+    user = Fabricate(:user)
+    user.update(email: 'new@example.com')
+    user.reload
+    user.confirm_email!
+    user.reload
+    assert_nil user.unconfirmed_email
+    assert_equal 'new@example.com', user.email
+    assert_nil user.confirmation_token
+    assert_nil user.confirmation_token_sent_at
+  end
 
-    should "return nil with incorrect email_confirmation token" do
-      loaded_user = User.load_from_email_confirmation_token('blahblahblah')
-      assert_nil loaded_user
+  test 'should send confirmation success email when confirm_email!' do
+    user = Fabricate(:user)
+    user.update(email: 'new@example.com')
+    user.reload
+    assert_emails 1 do
+      user.confirm_email!
     end
+    email = ActionMailer::Base.deliveries.last
+    assert_match /You have successfully changed your account email/, email.body.encoded
+  end
 
-    should "return nil with correct email_confirmation token which is expired" do
-      raw_token = @user.raw_confirmation_token
-      @user.update_attribute(:confirmation_token_sent_at, 7.days.ago)
-
-      loaded_user = User.load_from_email_confirmation_token(raw_token)
-      assert_nil loaded_user
+  test 'should not send confirmation success email when confirm_email! if email_confirmation_success_email_method_name == nil' do
+    swap Goma.config(:user), email_confirmation_success_email_method_name: nil do
+      user = Fabricate(:user)
+      user.update(email: 'new@example.com')
+      user.reload
+      assert_no_emails do
+        user.confirm_email!
+      end
     end
   end
-
 end

data/test/{goma_test.rb → models/goma_test.rb}

@@ -3,11 +3,6 @@ require 'test_helper'
 class GomaTest < ActiveSupport::TestCase
   test "goma class method is introduced to ActiveRecord::Base" do
     assert ActiveRecord::Base.respond_to?(:goma)
-    # assert User.respond_to?(:goma)
-
-    # user = User.new
-    # assert_equal "blahblah", user.blahblah
-    # puts Goma.config.encryptor
   end
 
   test "should have module existence methods" do

data/test/models/lockable_test.rb

@@ -0,0 +1,131 @@
+require "test_helper"
+
+class LockableTest < ActiveSupport::TestCase
+  test 'lock_access!' do
+    user = Fabricate(:user)
+    user.lock_access!
+    user.reload
+    assert user.access_locked?
+    assert user.unlock_token
+    assert user.unlock_token_sent_at
+    assert user.locked_at
+  end
+
+  test 'should send unlock token email when lock_access!' do
+    Goma.token_generator.expects(:friendly_token).returns('sesame')
+
+    user = Fabricate(:user)
+    assert_emails 1 do
+      user.lock_access!
+    end
+    email = ActionMailer::Base.deliveries.last
+    assert_match %r{/unlocks/sesame}, email.body.encoded
+  end
+
+  test 'should not send unlock token email when lock_access! if unlock_strategies does not include :email' do
+    swap Goma.config(:user), unlock_strategies: [:time] do
+      user = Fabricate(:user)
+      assert_nil user.locked_at
+      locked_at = Time.now.utc
+      assert_no_emails do
+        user.lock_access!
+      end
+      user.reload
+      assert user.locked_at
+    end
+  end
+
+  test 'load_from_unlock_token_with_error with correct token' do
+    user = Fabricate(:user)
+    user.lock_access!
+    raw_token = user.raw_unlock_token
+    loaded_user, error = User.load_from_unlock_token_with_error(raw_token)
+    assert_equal user, loaded_user
+    assert_nil error
+  end
+
+  test 'load_from_unlock_token_with_error with wrong token' do
+    user = Fabricate(:user)
+    user.lock_access!
+    loaded_user, error = User.load_from_unlock_token_with_error('beans')
+    assert_nil loaded_user
+    assert_equal :not_found, error
+  end
+
+  test 'load_from_unlock_token! with correct token' do
+    user = Fabricate(:user)
+    user.lock_access!
+    raw_token = user.raw_unlock_token
+    assert_equal user, User.load_from_unlock_token!(raw_token)
+  end
+
+  test 'load_from_unlock_token! with wrong token' do
+    user = Fabricate(:user)
+    user.lock_access!
+    assert_raise Goma::NotFound do
+      User.load_from_unlock_token!('beans')
+    end
+  end
+
+  test 'load_from_unlock_token with correct token' do
+    user = Fabricate(:user)
+    user.lock_access!
+    raw_token = user.raw_unlock_token
+    assert_equal user, User.load_from_unlock_token(raw_token)
+  end
+
+  test 'load_from_unlock_token with wrong token' do
+    user = Fabricate(:user)
+    user.lock_access!
+    assert_nil User.load_from_unlock_token('beans')
+  end
+
+  test 'unlock_access!' do
+    user = Fabricate(:user)
+    user.lock_access!
+    user.unlock_access!
+    user.reload
+    refute user.access_locked?
+    assert_nil user.unlock_token
+    assert_nil user.unlock_token_sent_at
+    assert_nil user.locked_at
+  end
+
+  test 'lock_expired?' do
+    user = Fabricate(:user)
+    user.lock_access!
+    user.reload
+    refute user.lock_expired?
+    Timecop.travel 1.hour.from_now
+    assert user.lock_expired?
+    Timecop.return
+  end
+
+  test 'valid_password?' do
+    swap Goma.config(:user), maximum_attempts: 3 do
+      user = Fabricate(:user)
+      3.times do
+        user.valid_password? 'wrongpass'
+      end
+      user.reload
+      refute user.access_locked?
+
+      user.valid_password? 'wrongpass'
+      user.reload
+      assert user.access_locked?
+    end
+  end
+
+  test 'last_attempt?' do
+    swap Goma.config(:user), maximum_attempts: 3 do
+      user = Fabricate(:user)
+      2.times do
+        user.valid_password? 'wrongpass'
+        refute user.last_attempt?
+      end
+
+      user.valid_password? 'wrongpass'
+      assert user.last_attempt?
+    end
+  end
+end