devise_invitable 1.1.8 → 1.3.0

data/test/models/invitable_test.rb

@@ -0,0 +1,558 @@
+require 'test_helper'
+require 'model_tests_helper'
+
+class InvitableTest < ActiveSupport::TestCase
+
+  def setup
+    setup_mailer
+  end
+
+  test 'should not generate invitation token after creating a record' do
+    assert_nil new_user.invitation_token
+  end
+
+  test 'should regenerate invitation token each time' do
+    user = new_user
+    user.invite!
+    token = user.invitation_token
+    assert_not_nil user.invitation_token
+    assert_not_nil user.invitation_created_at
+    3.times do
+      user = User.find(user.id)
+      user.invite!
+      assert_not_equal token, user.invitation_token
+      token = user.invitation_token
+    end
+  end
+
+  test 'should set invitation created and sent at each time' do
+    user = new_user
+    user.invite!
+    old_invitation_created_at = 3.days.ago
+    old_invitation_sent_at = 3.days.ago
+    user.update_attributes(:invitation_sent_at => old_invitation_sent_at, :invitation_created_at => old_invitation_created_at)
+    3.times do
+      user.invite!
+      assert_not_equal old_invitation_sent_at, user.invitation_sent_at
+      assert_not_equal old_invitation_created_at, user.invitation_created_at
+      user.update_attributes(:invitation_sent_at => old_invitation_sent_at, :invitation_created_at => old_invitation_created_at)
+    end
+  end
+
+  test 'should test invitation sent at with invite_for configuration value' do
+    user = User.invite!(:email => "valid@email.com")
+
+    User.stubs(:invite_for).returns(nil)
+    user.invitation_created_at = Time.now.utc
+    assert user.valid_invitation?
+
+    User.stubs(:invite_for).returns(nil)
+    user.invitation_created_at = 1.year.ago
+    assert user.valid_invitation?
+
+    User.stubs(:invite_for).returns(0)
+    user.invitation_created_at = Time.now.utc
+    assert user.valid_invitation?
+
+    User.stubs(:invite_for).returns(0)
+    user.invitation_created_at = 1.day.ago
+    assert user.valid_invitation?
+
+    User.stubs(:invite_for).returns(1.day)
+    user.invitation_created_at = Time.now.utc
+    assert user.valid_invitation?
+
+    User.stubs(:invite_for).returns(1.day)
+    user.invitation_created_at = 2.days.ago
+    assert !user.valid_invitation?
+  end
+
+  test 'should never generate the same invitation token for different users' do
+    invitation_tokens = []
+    3.times do
+      user = new_user
+      user.invite!
+      token = user.invitation_token
+      assert !invitation_tokens.include?(token)
+      invitation_tokens << token
+    end
+  end
+
+  test 'should invite with mutiple columns for invite key' do
+    User.stubs(:invite_key).returns(:email => Devise.email_regexp, :username => /\A.+\z/)
+    user = User.invite!(:email => "valid@email.com", :username => "name")
+    assert user.persisted?
+    assert user.errors.empty?
+  end
+
+  test 'should not invite with some missing columns when invite key is an array' do
+    User.stubs(:invite_key).returns(:email => Devise.email_regexp, :username => /\A.+\z/)
+    user = User.invite!(:email => "valid@email.com")
+    assert user.new_record?
+    assert user.errors.present?
+    assert user.errors[:username]
+    assert user.errors[:email].empty?
+  end
+
+  test 'should return mail object' do
+    mail = User.invite_mail!(:email => 'valid@email.com')
+    assert mail.class.name == 'Mail::Message'
+  end
+
+  test 'should disallow login when invited' do
+    invited_user = User.invite!(:email => "valid@email.com")
+    assert !invited_user.valid_password?('1234')
+  end
+
+  test 'should set password and password confirmation from params' do
+    invited_user = User.invite!(:email => "valid@email.com")
+    user = User.accept_invitation!(:invitation_token => Thread.current[:token], :password => '123456789', :password_confirmation => '123456789')
+    assert user.valid_password?('123456789')
+  end
+
+  test 'should set password and save the record' do
+    user = User.invite!(:email => "valid@email.com")
+    old_encrypted_password = user.encrypted_password
+    user = User.accept_invitation!(:invitation_token => Thread.current[:token], :password => '123456789', :password_confirmation => '123456789')
+    assert_not_equal old_encrypted_password, user.encrypted_password
+  end
+
+  test 'should clear invitation token and set invitation_accepted_at while accepting the password' do
+    user = User.invite!(:email => "valid@email.com")
+    assert_present user.invitation_token
+    assert_nil user.invitation_accepted_at
+    user.accept_invitation!
+    user.reload
+    assert_nil user.invitation_token
+    assert_present user.invitation_accepted_at
+  end
+
+  test 'should not clear invitation token or set accepted_at if record is invalid' do
+    user = User.invite!(:email => "valid@email.com")
+    assert_present user.invitation_token
+    assert_nil user.invitation_accepted_at
+    User.accept_invitation!(:invitation_token => user.invitation_token, :password => '123456789', :password_confirmation => '987654321')
+    user.reload
+    assert_present user.invitation_token
+    assert_nil user.invitation_accepted_at
+  end
+
+  test 'should clear invitation token while resetting the password' do
+    user = User.invite!(:email => "valid@email.com")
+    assert user.invited_to_sign_up?
+    token, user.reset_password_token = Devise.token_generator.generate(User, :reset_password_token)
+    user.reset_password_sent_at = Time.now.utc
+    user.save
+
+    assert_present user.reset_password_token
+    assert_present user.invitation_token
+    User.reset_password_by_token(:reset_password_token => token, :password => '123456789', :password_confirmation => '123456789')
+    assert_nil user.reload.reset_password_token
+    assert_nil user.reload.invitation_token
+    assert !user.invited_to_sign_up?
+  end
+
+  test 'should not accept invitation on failing to reset the password' do
+    user = User.invite!(:email => "valid@email.com")
+    assert user.invited_to_sign_up?
+    token, user.reset_password_token = Devise.token_generator.generate(User, :reset_password_token)
+    user.reset_password_sent_at = Time.now.utc
+    user.save
+
+    assert_present user.reset_password_token
+    assert_present user.invitation_token
+    User.reset_password_by_token(:reset_password_token => token, :password => '123456789', :password_confirmation => '12345678')
+    assert_present user.reload.reset_password_token
+    assert_present user.reload.invitation_token
+    assert user.invited_to_sign_up?
+  end
+
+  test 'should not set invitation_accepted_at if just resetting password' do
+    user = User.create!(:email => "valid@email.com", :password => "123456780")
+    assert !user.invited_to_sign_up?
+    token, user.reset_password_token = Devise.token_generator.generate(User, :reset_password_token)
+    user.reset_password_sent_at = Time.now.utc
+    user.save
+
+    assert_present user.reset_password_token
+    assert_nil user.invitation_token
+    User.reset_password_by_token(:reset_password_token => token, :password => '123456789', :password_confirmation => '123456789')
+    assert_nil user.reload.invitation_token
+    assert_nil user.reload.invitation_accepted_at
+  end
+
+  test 'should reset invitation token and send invitation by email' do
+    user = new_user
+    assert_difference('ActionMailer::Base.deliveries.size') do
+      token = user.invitation_token
+      user.invite!
+      assert_not_equal token, user.invitation_token
+    end
+  end
+
+  test 'should return a record with invitation token and no errors to send invitation by email' do
+    invited_user = User.invite!(:email => "valid@email.com")
+    assert invited_user.errors.blank?
+    assert_present invited_user.invitation_token
+    assert_equal 'valid@email.com', invited_user.email
+    assert invited_user.persisted?
+  end
+
+  test 'should set all attributes with no errors' do
+    invited_user = User.invite!(:email => "valid@email.com", :username => 'first name')
+    assert invited_user.errors.blank?
+    assert_equal 'first name', invited_user.username
+    assert invited_user.persisted?
+  end
+
+  test 'should not validate other attributes when validate_on_invite is disabled' do
+    validate_on_invite = User.validate_on_invite
+    User.validate_on_invite = false
+    invited_user = User.invite!(:email => "valid@email.com", :username => "a"*50)
+    assert invited_user.errors.empty?
+    User.validate_on_invite = validate_on_invite
+  end
+
+  test 'should validate other attributes when validate_on_invite is enabled' do
+    validate_on_invite = User.validate_on_invite
+    User.validate_on_invite = true
+    invited_user = User.invite!(:email => "valid@email.com", :username => "a"*50)
+    assert invited_user.errors[:username].present?
+    User.validate_on_invite = validate_on_invite
+  end
+
+  test 'should not validate password when validate_on_invite is enabled' do
+    validate_on_invite = User.validate_on_invite
+    User.validate_on_invite = true
+    invited_user = User.invite!(:email => "valid@email.com", :username => "a"*50)
+    assert invited_user.errors.present?
+    assert invited_user.errors[:password].empty?
+    User.validate_on_invite = validate_on_invite
+  end
+
+  test 'should validate other attributes when validate_on_invite is enabled and email is not present' do
+    validate_on_invite = User.validate_on_invite
+    User.validate_on_invite = true
+    invited_user = User.invite!(:email => "", :username => "a"*50)
+    assert invited_user.errors[:email].present?
+    assert invited_user.errors[:username].present?
+    User.validate_on_invite = validate_on_invite
+  end
+
+  test 'should return a record with errors if user was found by e-mail' do
+    existing_user = User.new(:email => "valid@email.com")
+    existing_user.save(:validate => false)
+    user = User.invite!(:email => "valid@email.com")
+    assert_equal user, existing_user
+    assert_equal ['has already been taken'], user.errors[:email]
+    same_user = User.invite!("email" => "valid@email.com")
+    assert_equal same_user, existing_user
+    assert_equal ['has already been taken'], same_user.errors[:email]
+  end
+
+  test 'should return a record with errors if user with pending invitation was found by e-mail' do
+    existing_user = User.invite!(:email => "valid@email.com")
+    user = User.invite!(:email => "valid@email.com")
+    assert_equal user, existing_user
+    assert_equal [], user.errors[:email]
+    resend_invitation = User.resend_invitation
+    begin
+      User.resend_invitation = false
+
+      user = User.invite!(:email => "valid@email.com")
+      assert_equal user, existing_user
+      assert_equal ['has already been taken'], user.errors[:email]
+    ensure
+      User.resend_invitation = resend_invitation
+    end
+  end
+
+  test 'should return a record with errors if user was found by e-mail with validate_on_invite' do
+    begin
+      validate_on_invite = User.validate_on_invite
+      User.validate_on_invite = true
+      existing_user = User.new(:email => "valid@email.com")
+      existing_user.save(:validate => false)
+      user = User.invite!(:email => "valid@email.com", :username => "a"*50)
+      assert_equal user, existing_user
+      assert_equal ['has already been taken'], user.errors[:email]
+      assert user.errors[:username].present?
+    ensure
+      User.validate_on_invite = validate_on_invite
+    end
+  end
+
+  test 'should return a new record with errors if e-mail is blank' do
+    invited_user = User.invite!(:email => '')
+    assert invited_user.new_record?
+    assert_equal ["can't be blank"], invited_user.errors[:email]
+  end
+
+  test 'should return a new record with errors if e-mail is invalid' do
+    invited_user = User.invite!(:email => 'invalid_email')
+    assert invited_user.new_record?
+    assert_equal ["is invalid"], invited_user.errors[:email]
+  end
+
+  test 'should set all attributes with errors if e-mail is invalid' do
+    invited_user = User.invite!(:email => "invalid_email.com", :username => 'first name')
+    assert invited_user.new_record?
+    assert_equal 'first name', invited_user.username
+    assert invited_user.errors.present?
+  end
+
+  test 'should find a user to set his password based on invitation_token' do
+    user = new_user
+    user.invite!
+    invited_user = User.accept_invitation!(:invitation_token => Thread.current[:token])
+    assert_equal invited_user, user
+  end
+
+  test 'should return a new record with errors if no invitation_token is found' do
+    invited_user = User.accept_invitation!(:invitation_token => 'invalid_token')
+    assert invited_user.new_record?
+    assert_equal ['is invalid'], invited_user.errors[:invitation_token]
+  end
+
+  test 'should return a new record with errors if invitation_token is blank' do
+    invited_user = User.accept_invitation!(:invitation_token => '')
+    assert invited_user.new_record?
+    assert_equal ["can't be blank"], invited_user.errors[:invitation_token]
+  end
+
+  test 'should return record with errors if invitation_token has expired' do
+    User.stubs(:invite_for).returns(10.hours)
+    invited_user = User.invite!(:email => "valid@email.com")
+    invited_user.invitation_created_at = 2.days.ago
+    invited_user.save(:validate => false)
+    user = User.accept_invitation!(:invitation_token => Thread.current[:token])
+    assert_equal user, invited_user
+    assert_equal ["is invalid"], user.errors[:invitation_token]
+  end
+
+  test 'should allow record modification using block' do
+    invited_user = User.invite!(:email => "valid@email.com", :username => "a"*50) do |u|
+      u.password = '123123'
+      u.password_confirmation = '123123'
+    end
+    assert_equal '123123', invited_user.reload.password
+  end
+
+  test 'should set successfully user password given the new password and confirmation' do
+    user = new_user(:password => nil, :password_confirmation => nil)
+    user.invite!
+
+    invited_user = User.accept_invitation!(
+      :invitation_token => Thread.current[:token],
+      :password => 'new_password',
+      :password_confirmation => 'new_password'
+    )
+    user.reload
+
+    assert user.valid_password?('new_password')
+  end
+
+  test 'should return errors on other attributes even when password is valid' do
+    user = new_user(:password => nil, :password_confirmation => nil)
+    user.invite!
+
+    invited_user = User.accept_invitation!(
+      :invitation_token => Thread.current[:token],
+      :password => 'new_password',
+      :password_confirmation => 'new_password',
+      :username => 'a'*50
+    )
+    assert invited_user.errors[:username].present?
+
+    user.reload
+    assert !user.valid_password?('new_password')
+  end
+
+  test 'should set other attributes on accepting invitation' do
+    user = new_user(:password => nil, :password_confirmation => nil)
+    user.invite!
+
+    invited_user = User.accept_invitation!(
+      :invitation_token => Thread.current[:token],
+      :password => 'new_password',
+      :password_confirmation => 'new_password',
+      :username => 'a'
+    )
+    assert invited_user.errors[:username].blank?
+
+    user.reload
+    assert_equal 'a', user.username
+    assert user.valid_password?('new_password')
+  end
+
+  test 'should not confirm user on invite' do
+    user = new_user
+
+    user.invite!
+
+    assert !user.confirmed?
+  end
+
+  test 'user.has_invitations_left? test' do
+    # By default with invitation_limit nil, users can send unlimited invitations
+    user = new_user
+    assert_nil user.invitation_limit
+    assert user.has_invitations_left?
+
+    # With invitation_limit set to a value, all users can send that many invitations
+    User.stubs(:invitation_limit).returns(2)
+    assert user.has_invitations_left?
+
+    # With an individual invitation_limit of 0, a user shouldn't be able to send an invitation
+    user.invitation_limit = 0
+    assert user.save
+    assert !user.has_invitations_left?
+
+    # With in invitation_limit of 2, a user should be able to send two invitations
+    user.invitation_limit = 2
+    assert user.save
+    assert user.has_invitations_left?
+  end
+
+  test 'should not send an invitation if we want to skip the invitation' do
+    assert_no_difference('ActionMailer::Base.deliveries.size') do
+      invited_user = User.invite!(:email => "valid@email.com", :username => "a"*50, :skip_invitation => true)
+    end
+  end
+
+  test 'should not send an invitation if we want to skip the invitation with block' do
+    assert_no_difference('ActionMailer::Base.deliveries.size') do
+      invited_user = User.invite!(:email => "valid@email.com", :username => "a"*50) do |u|
+        u.skip_invitation = true
+      end
+    end
+  end
+
+  test 'user.invite! should not send an invitation if we want to skip the invitation' do
+    user = new_user
+    user.skip_invitation = true
+    assert_no_difference('ActionMailer::Base.deliveries.size') do
+      user.invite!
+    end
+    assert_present user.invitation_created_at
+    assert_nil user.invitation_sent_at
+  end
+
+  test 'user.invite! should not set the invited_by attribute if not passed' do
+    user = new_user
+    user.invite!
+    assert_equal nil, user.invited_by
+  end
+
+  test 'user.invite! should set the invited_by attribute if passed' do
+    user = new_user
+    inviting_user = User.new(:email => "valid@email.com")
+    inviting_user.save(:validate => false)
+    user.invite!(inviting_user)
+    assert_equal inviting_user, user.invited_by
+    assert_equal inviting_user.class.to_s, user.invited_by_type
+  end
+
+  test 'user.accept_invitation! should trigger callbacks' do
+    user = User.invite!(:email => "valid@email.com")
+    assert_callbacks_not_fired user
+    user.accept_invitation!
+    assert_callbacks_fired user
+  end
+
+  test 'user.accept_invitation! should not trigger callbacks if validation fails' do
+    user = User.invite!(:email => "valid@email.com")
+    assert_callbacks_not_fired user
+    user.username='a'*50
+    user.accept_invitation!
+    assert_callbacks_not_fired user
+  end
+
+  test 'user.accept_invitation! should confirm user if confirmable' do
+    user = User.invite!(:email => "valid@email.com")
+    user.accept_invitation!
+
+    assert user.confirmed?
+  end
+
+  test 'user.accept_invitation! should not confirm user if validation fails' do
+    user = User.invite!(:email => "valid@email.com")
+    user.username='a'*50
+    user.accept_invitation!
+
+    assert !user.confirmed?
+  end
+
+  def assert_callbacks_fired(user)
+    assert_callbacks_status user, true
+  end
+
+  def assert_callbacks_not_fired(user)
+    assert_callbacks_status user, nil
+  end
+
+  def assert_callbacks_status(user, fired)
+    assert_equal fired, user.callback_works
+  end
+
+  test "user.invite! should downcase the class's case_insensitive_keys" do
+    # Devise default is :email
+    user = User.invite!(:email => "UPPERCASE@email.com")
+    assert user.email == "uppercase@email.com"
+  end
+
+  test "user.invite! should strip whitespace from the class's strip_whitespace_keys" do
+    # Devise default is email
+    user = User.invite!(:email => " valid@email.com ")
+    assert user.email == "valid@email.com"
+  end
+
+  test 'should pass validation before accept if field is required in post-invited instance' do
+    user = User.invite!(:email => "valid@email.com")
+    user.testing_accepting_or_not_invited = true
+    assert_equal true, user.valid?
+  end
+
+  test 'should fail validation after accept if field is required in post-invited instance' do
+    user = User.invite!(:email => "valid@email.com")
+    user.testing_accepting_or_not_invited = true
+    user.accept_invitation!
+    assert_equal false, user.valid?
+  end
+
+  test 'should pass validation after accept if field is required in post-invited instance' do
+    user = User.invite!(:email => "valid@email.com")
+    user.username = 'test'
+    user.testing_accepting_or_not_invited = true
+    user.bio = "Test"
+    user.accept_invitation!
+    assert_equal true, user.valid?
+  end
+
+  test 'should return instance with errors if invitation_token is nil' do
+    registered_user = User.create(:email => 'admin@test.com', :password => '123456', :password_confirmation => '123456')
+    user = User.accept_invitation!
+    assert !user.errors.empty?
+  end
+
+  test "should count accepted and not accepted invitations" do
+    assert_equal 0, User.invitation_not_accepted.count
+    assert_equal 0, User.invitation_accepted.count
+
+    User.invite!(:email => "invalid@email.com")
+    user = User.invite!(:email => "valid@email.com")
+
+    assert_equal 2, User.invitation_not_accepted.count
+    assert_equal 0, User.invitation_accepted.count
+
+    user.accept_invitation!
+    assert_equal 1, User.invitation_not_accepted.count
+    assert_equal 1, User.invitation_accepted.count
+  end
+
+  test "should preserve return values of Devise::Recoverable#reset_password!" do
+    user = new_user
+    retval = user.reset_password!('anewpassword', 'anewpassword')
+    assert_equal true, retval
+  end
+end

data/test/models_test.rb

@@ -0,0 +1,74 @@
+require 'test_helper'
+
+class Invitable < User
+  devise :invitable, :invite_for => 5.days, :validate_on_invite => true
+end
+
+class ModelsTest < ActiveSupport::TestCase
+  def include_module?(klass, mod)
+    klass.devise_modules.include?(mod) &&
+    klass.included_modules.include?(Devise::Models::const_get(mod.to_s.classify))
+  end
+
+  def assert_include_modules(klass, *modules)
+    modules.each do |mod|
+      assert include_module?(klass, mod), "#{klass} not include #{mod}"
+    end
+
+    (Devise::ALL - modules).each do |mod|
+      assert !include_module?(klass, mod), "#{klass} include #{mod}"
+    end
+  end
+
+  test 'should include Devise modules' do
+    assert_include_modules User, :database_authenticatable, :registerable, :validatable, :confirmable, :invitable, :recoverable
+  end
+
+  test 'should have a default value for invite_for' do
+    assert_equal 0, User.invite_for
+  end
+
+  test 'should have a default value for invitation_limit' do
+    assert_nil User.invitation_limit
+  end
+
+  test 'should have a default value for invite_key' do
+    assert !User.invite_key.nil?
+  end
+
+  test 'set a custom value for invite_for' do
+    old_invite_for = User.invite_for
+    User.invite_for = 5.days
+
+    assert_equal 5.days, User.invite_for
+
+    User.invite_for = old_invite_for
+  end
+
+  test 'set a custom value for invite_key' do
+    old_invite_key = User.invite_key
+    User.invite_key = {:username => /\A.+\z/}
+
+    assert_equal({:username => /\A.+\z/}, User.invite_key)
+
+    User.invite_key = old_invite_key
+  end
+
+  test 'set a custom value for invitation_limit' do
+    old_invitation_limit = User.invitation_limit
+    User.invitation_limit = 2
+
+    assert_equal 2, User.invitation_limit
+
+    User.invitation_limit = old_invitation_limit
+  end
+
+  test 'set a default value for validate_on_invite' do
+    assert_equal true, Invitable.validate_on_invite
+  end
+
+  test 'invitable attributes' do
+    assert_nil User.new.invitation_token
+    assert_nil User.new.invitation_sent_at
+  end
+end

data/test/orm/active_record.rb

@@ -0,0 +1,4 @@
+ActiveRecord::Migration.verbose = false
+ActiveRecord::Base.logger = Logger.new(nil)
+
+ActiveRecord::Migrator.migrate(File.expand_path("../../rails_app/db/migrate/", __FILE__))

data/test/orm/mongoid.rb

@@ -0,0 +1,20 @@
+Mongoid.configure do |config|
+  if Mongoid::VERSION < '3.0.0'
+    config.master = Mongo::Connection.new('127.0.0.1', 27017).db("devise_invitable-test-suite")
+  else
+    config.connect_to("devise_invitable-test-suite")
+    config.use_utc = true
+    config.include_root_in_json = true
+  end
+end
+
+class ActiveSupport::TestCase
+  setup do
+    if Mongoid::VERSION < '3.0.0'
+      User.delete_all
+      Admin.delete_all
+    else
+      Mongoid.purge!
+    end
+  end
+end

data/test/rails_app/Rakefile

@@ -0,0 +1,7 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+require 'rake'
+
+RailsApp::Application.load_tasks

data/test/rails_app/app/controllers/admins_controller.rb

@@ -0,0 +1,6 @@
+class AdminsController < Devise::InvitationsController
+  protected
+  def authenticate_inviter!
+    authenticate_admin!(:force => true)
+  end
+end

data/test/rails_app/app/controllers/application_controller.rb

@@ -0,0 +1,10 @@
+class ApplicationController < ActionController::Base
+  protect_from_forgery
+  before_filter :configure_permitted_parameters, :if => :devise_controller?
+
+  protected
+
+  def configure_permitted_parameters
+    devise_parameter_sanitizer.for(:sign_up) { |u| u.permit(:email, :password, :bio) } if defined?(ActionController::StrongParameters)
+  end
+end

data/test/rails_app/app/controllers/free_invitations_controller.rb

@@ -0,0 +1,6 @@
+class FreeInvitationsController < Devise::InvitationsController
+  protected
+  def authenticate_inviter!
+  # everyone can invite
+  end
+end