aihs_devise_invitable 0.4.rc

data/lib/devise_invitable/version.rb

@@ -0,0 +1,3 @@
+module DeviseInvitable
+  VERSION = '0.4.rc'.freeze
+end

data/lib/generators/active_record/devise_invitable_generator.rb

@@ -0,0 +1,13 @@
+require 'rails/generators/active_record'
+
+module ActiveRecord
+  module Generators
+    class DeviseInvitableGenerator < ActiveRecord::Generators::Base
+      source_root File.expand_path("../templates", __FILE__)
+
+      def copy_devise_migration
+        migration_template "migration.rb", "db/migrate/devise_invitable_add_to_#{table_name}"
+      end
+    end
+  end
+end

data/lib/generators/active_record/templates/migration.rb

@@ -0,0 +1,20 @@
+class DeviseInvitableAddTo<%= table_name.camelize %> < ActiveRecord::Migration
+  def self.up
+    change_table :<%= table_name %> do |t|
+      t.string   :invitation_token, :limit => 60
+      t.datetime :invitation_sent_at
+      t.index    :invitation_token # for invitable
+    end
+    
+    # And allow null encrypted_password and password_salt:
+    change_column_null :<%= table_name %>, :encrypted_password, true
+<% if class_name.constantize.columns_hash['password_salt'] -%>
+    change_column_null :<%= table_name %>, :password_salt,      true
+<% end -%>
+  end
+  
+  def self.down
+    remove_column :<%= table_name %>, :invitation_sent_at
+    remove_column :<%= table_name %>, :invitation_token
+  end
+end

data/lib/generators/devise_invitable/devise_invitable_generator.rb

@@ -0,0 +1,16 @@
+module DeviseInvitable
+  module Generators
+    class DeviseInvitableGenerator < Rails::Generators::NamedBase
+      namespace "devise_invitable"
+
+      desc "Add :invitable directive in the given model. Also generate migration for ActiveRecord"
+
+      def inject_devise_invitable_content
+        path = File.join("app", "models", "#{file_path}.rb")
+        inject_into_file(path, "invitable, :", :after => "devise :") if File.exists?(path)
+      end
+
+      hook_for :orm
+    end
+  end
+end

data/lib/generators/devise_invitable/install_generator.rb

@@ -0,0 +1,35 @@
+module DeviseInvitable
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("../../templates", __FILE__)
+      desc "Add DeviseInvitable config variables to the Devise initializer and copy DeviseInvitable locale files to your application."
+      
+      def add_config_options_to_initializer
+        devise_initializer_path = "config/initializers/devise.rb"
+        if File.exist?(devise_initializer_path)
+          old_content = File.read(devise_initializer_path)
+          
+          if old_content.match(Regexp.new(/^\s# ==> Configuration for :invitable\n/))
+            false
+          else
+            inject_into_file(devise_initializer_path, :before => "  # ==> Configuration for :confirmable\n") do
+<<-CONTENT
+  # ==> Configuration for :invitable
+  # The period the generated invitation token is valid, after
+  # this period, the invited resource won't be able to accept the invitation.
+  # When invite_for is 0 (the default), the invitation won't expire.
+  # config.invite_for = 2.weeks
+  
+CONTENT
+            end
+          end
+        end
+      end
+      
+      def copy_locale
+        copy_file "../../../config/locales/en.yml", "config/locales/devise_invitable.en.yml"
+      end
+      
+    end
+  end
+end

data/lib/generators/devise_invitable/views_generator.rb

@@ -0,0 +1,10 @@
+require 'generators/devise/views_generator'
+
+module DeviseInvitable
+  module Generators
+    class ViewsGenerator < Devise::Generators::ViewsGenerator
+      source_root File.expand_path("../../../../app/views", __FILE__)
+      desc 'Copies all DeviseInvitable views to your application.'
+    end
+  end
+end

data/test/generators_test.rb

@@ -0,0 +1,45 @@
+require 'test/test_helper'
+require 'rails/generators'
+require 'generators/devise_invitable/devise_invitable_generator'
+
+class GeneratorsTest < ActiveSupport::TestCase
+  RAILS_APP_PATH = File.expand_path("../rails_app", __FILE__)
+  
+  test "rails g should include the 3 generators" do
+    output = `cd #{RAILS_APP_PATH} && rails g`
+    assert output.match(%r|DeviseInvitable:\n  devise_invitable\n  devise_invitable:install\n  devise_invitable:views|)
+  end
+
+  test "rails g devise_invitable:install" do
+    output = `cd #{RAILS_APP_PATH} && rails g devise_invitable:install -p`
+    assert output.match(%r|inject.+  config/initializers/devise\.rb\n|)
+    assert output.match(%r|create.+  config/locales/devise_invitable\.en\.yml\n|)
+  end
+  
+  test "rails g devise_invitable:views not scoped" do
+    output = `cd #{RAILS_APP_PATH} && rails g devise_invitable:views -p`
+    assert output.match(%r|create.+  app/views/devise\n|)
+    assert output.match(%r|create.+  app/views/devise/invitations/edit\.html\.erb\n|)
+    assert output.match(%r|create.+  app/views/devise/invitations/new\.html\.erb\n|)
+    assert output.match(%r|create.+  app/views/devise/mailer/invitation_instructions\.html\.erb\n|)
+  end
+    
+  test "rails g devise_invitable:views scoped" do
+    output = `cd #{RAILS_APP_PATH} && rails g devise_invitable:views octopussies -p`
+    assert output.match(%r|create.+  app/views/octopussies\n|)
+    assert output.match(%r|create.+  app/views/octopussies/invitations/edit\.html\.erb\n|)
+    assert output.match(%r|create.+  app/views/octopussies/invitations/new\.html\.erb\n|)
+    assert output.match(%r|create.+  app/views/octopussies/mailer/invitation_instructions\.html\.erb\n|)
+  end
+    
+  test "rails g devise_invitable Octopussy" do
+    output = `cd #{RAILS_APP_PATH} && rails g devise_invitable Octopussy -p`
+    assert output.match(%r|inject.+  app/models/octopussy\.rb\n|)
+    assert output.match(%r|invoke.+  #{DEVISE_ORM}\n|)
+    if DEVISE_ORM == :active_record
+      assert output.match(%r|create.+  db/migrate/\d{14}_devise_invitable_add_to_octopussies\.rb\n|)
+    elsif DEVISE_ORM == :mongoid
+      assert !output.match(%r|create.+  db/migrate/\d{14}_devise_invitable_add_to_octopussies\.rb\n|)
+    end
+  end
+end

data/test/integration/invitation_test.rb

@@ -0,0 +1,107 @@
+require 'test/test_helper'
+require 'test/integration_tests_helper'
+
+class InvitationTest < ActionDispatch::IntegrationTest
+  def teardown
+    Capybara.reset_sessions!
+  end
+
+  def send_invitation(&block)
+    visit new_user_invitation_path
+
+    fill_in 'user_email', :with => 'user@test.com'
+    yield if block_given?
+    click_button 'Send an invitation'
+  end
+
+  def set_password(options={}, &block)
+    unless options[:visit] == false
+      visit accept_user_invitation_path(:invitation_token => options[:invitation_token])
+    end
+
+    fill_in 'user_password', :with => '987654321'
+    fill_in 'user_password_confirmation', :with => '987654321'
+    yield if block_given?
+    click_button 'Set my password'
+  end
+
+  test 'not authenticated user should not be able to send an invitation' do
+    get new_user_invitation_path
+    assert_redirected_to new_user_session_path
+  end
+
+  test 'authenticated user should be able to send an invitation' do
+    sign_in_as_user
+
+    send_invitation
+    assert_equal root_path, current_path
+    assert page.has_css?('p#notice', :text => 'An invitation email has been sent to user@test.com.')
+  end
+
+  test 'authenticated user with invalid email should receive an error message' do
+    user = create_full_user
+    sign_in_as_user(user)
+    send_invitation do
+      fill_in 'user_email', :with => user.email
+    end
+
+    assert_equal user_invitation_path, current_path
+    assert page.has_css?("input[type=text][value='#{user.email}']")
+    assert page.has_css?('#error_explanation li', :text => 'Email has already been taken')
+  end
+
+  test 'authenticated user should not be able to visit edit invitation page' do
+    sign_in_as_user
+
+    visit accept_user_invitation_path
+
+    assert_equal root_path, current_path
+  end
+
+  test 'not authenticated user with invalid invitation token should not be able to set his password' do
+    user = create_user
+    visit accept_user_invitation_path(:invitation_token => 'invalid_token')
+
+    assert_equal root_path, current_path
+    assert page.has_css?('p#alert', :text => 'The invitation token provided is not valid!')
+  end
+
+  test 'not authenticated user with valid invitation token but invalid password should not be able to set his password' do
+    user = create_user(false)
+    set_password :invitation_token => user.invitation_token do
+      fill_in 'Password confirmation', :with => 'other_password'
+    end
+    assert_equal user_invitation_path, current_path
+    assert page.has_css?('#error_explanation li', :text => 'Password doesn\'t match confirmation')
+    assert_nil user.encrypted_password
+  end
+
+  test 'not authenticated user with valid data should be able to change his password' do
+    user = create_user(false)
+    set_password :invitation_token => user.invitation_token
+
+    assert_equal root_path, current_path
+    assert page.has_css?('p#notice', :text => 'Your password was set successfully. You are now signed in.')
+    assert user.reload.valid_password?('987654321')
+  end
+
+  test 'after entering invalid data user should still be able to set his password' do
+    user = create_user(false)
+    set_password :invitation_token => user.invitation_token do
+      fill_in 'Password confirmation', :with => 'other_password'
+    end
+    assert_equal user_invitation_path, current_path
+    assert page.has_css?('#error_explanation')
+    assert_nil user.encrypted_password
+
+    set_password :visit => false
+    assert page.has_css?('p#notice', :text => 'Your password was set successfully. You are now signed in.')
+    assert user.reload.valid_password?('987654321')
+  end
+
+  test 'sign in user automatically after setting it\'s password' do
+    user = create_user(false)
+    set_password :invitation_token => user.invitation_token
+    assert_equal root_path, current_path
+  end
+end

data/test/integration_tests_helper.rb

@@ -0,0 +1,58 @@
+class ActionController::IntegrationTest
+
+  def warden
+    request.env['warden']
+  end
+  
+  def create_full_user
+    @user ||= begin
+      user = User.create!(
+        :username => 'usertest',
+        :email => 'fulluser@test.com',
+        :password => '123456',
+        :password_confirmation => '123456',
+        :created_at => Time.now.utc
+      )
+      user.confirm!
+      user
+    end
+  end
+
+  def sign_in_as_user(user = nil)
+    user ||= create_full_user
+    visit new_user_session_path
+    fill_in 'user_email', :with => user.email
+    fill_in 'user_password', :with => '123456'
+    fill_in 'user_password', :with => user.password
+    click_button 'Sign in'
+  end
+
+  def create_user(accept_invitation = true)
+    user = User.new :email => 'newuser@test.com'
+    user.skip_confirmation!
+    user.invitation_token = 'token'
+    user.invitation_sent_at = Time.now.utc
+    user.save(:validate => false)
+    user.accept_invitation! if accept_invitation
+    user
+  end
+
+  # Fix assert_redirect_to in integration sessions because they don't take into
+  # account Middleware redirects.
+  #
+  def assert_redirected_to(url)
+    assert [301, 302].include?(@integration_session.status),
+           "Expected status to be 301 or 302, got #{@integration_session.status}"
+
+    url = prepend_host(url)
+    location = prepend_host(@integration_session.headers["Location"])
+    assert_equal url, location
+  end
+
+  protected
+
+    def prepend_host(url)
+      url = "http://#{request.host}#{url}" if url[0] == ?/
+      url
+    end
+end

data/test/mailers/invitation_mail_test.rb

@@ -0,0 +1,63 @@
+require 'test/test_helper'
+require 'test/model_tests_helper'
+
+class InvitationMailTest < ActionMailer::TestCase
+
+  def setup
+    setup_mailer
+    Devise.mailer_sender = 'test@example.com'
+  end
+
+  def user
+    @user ||= begin
+      user = create_user_with_invitation('token')
+      user.invite!
+      user
+    end
+  end
+
+  def mail
+    @mail ||= begin
+      user
+      ActionMailer::Base.deliveries.last
+    end
+  end
+
+  test 'email sent after reseting the user password' do
+    assert_not_nil mail
+  end
+
+  test 'content type should be set to html' do
+    assert_equal 'text/html; charset=UTF-8', mail.content_type
+  end
+
+  test 'send invitation to the user email' do
+    assert_equal [user.email], mail.to
+  end
+
+  test 'setup sender from configuration' do
+    assert_equal ['test@example.com'], mail.from
+  end
+
+  test 'setup subject from I18n' do
+    store_translations :en, :devise => { :mailer => { :invitation_instructions => { :subject => 'Localized Invitation' } } } do
+      assert_equal 'Localized Invitation', mail.subject
+    end
+  end
+
+  test 'subject namespaced by model' do
+    store_translations :en, :devise => { :mailer => { :invitation_instructions => { :user_subject => 'User Invitation' } } } do
+      assert_equal 'User Invitation', mail.subject
+    end
+  end
+
+  test 'body should have user info' do
+    assert_match /#{user.email}/, mail.body
+  end
+
+  test 'body should have link to confirm the account' do
+    host = ActionMailer::Base.default_url_options[:host]
+    invitation_url_regexp = %r{<a href=\"http://#{host}/users/invitation/accept\?invitation_token=#{user.invitation_token}">}
+    assert_match invitation_url_regexp, mail.body
+  end
+end

data/test/model_tests_helper.rb

@@ -0,0 +1,41 @@
+class ActiveSupport::TestCase
+  def setup_mailer
+    ActionMailer::Base.deliveries = []
+  end
+
+  def store_translations(locale, translations, &block)
+    begin
+      I18n.backend.store_translations locale, translations
+      yield
+    ensure
+      I18n.reload!
+    end
+  end
+
+  # Helpers for creating new users
+  #
+  def generate_unique_email
+    @@email_count ||= 0
+    @@email_count += 1
+    "test#{@@email_count}@email.com"
+  end
+
+  def valid_attributes(attributes={})
+    { :email => generate_unique_email,
+      :password => '123456',
+      :password_confirmation => '123456' }.update(attributes)
+  end
+
+  def new_user(attributes={})
+    User.new(valid_attributes(attributes))
+  end
+
+  def create_user_with_invitation(invitation_token, attributes={})
+    user = new_user({:password => nil, :password_confirmation => nil}.update(attributes))
+    user.skip_confirmation!
+    user.invitation_token = invitation_token
+    user.invitation_sent_at = Time.now.utc
+    user.save(:validate => false)
+    user
+  end
+end

data/test/models/invitable_test.rb

@@ -0,0 +1,213 @@
+require 'test/test_helper'
+require 'test/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 not 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_sent_at
+    3.times do
+      user.invite!
+      assert_equal token, user.invitation_token
+    end
+  end
+
+  test 'should set invitation sent at each time' do
+    user = new_user
+    user.invite!
+    old_invitation_sent_at = 3.days.ago
+    user.update_attribute :invitation_sent_at, old_invitation_sent_at
+    3.times do
+      user.invite!
+      assert_not_equal old_invitation_sent_at, user.invitation_sent_at
+      user.update_attribute :invitation_sent_at, old_invitation_sent_at
+    end
+  end
+
+  test 'should not regenerate invitation token even after the invitation token is not valid' do
+    User.invite_for = 1.day
+    user = new_user
+    user.invite!
+    token = user.invitation_token
+    user.invitation_sent_at = 3.days.ago
+    user.save
+    user.invite!
+    assert_equal token, user.invitation_token
+  end
+
+  test 'should test invitation sent at with invite_for configuration value' do
+    user = create_user_with_invitation('token')
+    
+    User.stubs(:invite_for).returns(nil)
+    user.invitation_sent_at = Time.now.utc
+    assert user.valid_invitation?
+
+    User.stubs(:invite_for).returns(nil)
+    user.invitation_sent_at = 1.year.ago
+    assert user.valid_invitation?
+
+    User.stubs(:invite_for).returns(0)
+    user.invitation_sent_at = Time.now.utc
+    assert user.valid_invitation?
+
+    User.stubs(:invite_for).returns(0)
+    user.invitation_sent_at = 1.day.ago
+    assert user.valid_invitation?
+
+    User.stubs(:invite_for).returns(1.day)
+    user.invitation_sent_at = Time.now.utc
+    assert user.valid_invitation?
+
+    User.stubs(:invite_for).returns(1.day)
+    user.invitation_sent_at = 1.day.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 set password and password confirmation from params' do
+    create_user_with_invitation('valid_token', :password => nil, :password_confirmation => nil)
+    user = User.accept_invitation!(:invitation_token => 'valid_token', :password => '123456789', :password_confirmation => '123456789')
+    assert user.valid_password?('123456789')
+  end
+
+  test 'should set password and save the record' do
+    user = create_user_with_invitation('valid_token', :password => nil, :password_confirmation => nil)
+    old_encrypted_password = user.encrypted_password
+    user = User.accept_invitation!(:invitation_token => 'valid_token', :password => '123456789', :password_confirmation => '123456789')
+    assert_not_equal old_encrypted_password, user.encrypted_password
+  end
+
+  test 'should clear invitation token while setting the password' do
+    user = new_user
+    user.skip_confirmation!
+    user.update_attribute(:invitation_token, 'valid_token')
+    assert_present user.invitation_token
+    assert user.accept_invitation!
+    assert_nil user.invitation_token
+  end
+
+  test 'should not clear invitation token if record is invalid' do
+    user = new_user
+    user.skip_confirmation!
+    user.update_attribute(:invitation_token, 'valid_token')
+    assert_present user.invitation_token
+    User.accept_invitation!(:invitation_token => 'valid_token', :password => '123456789', :password_confirmation => '987654321')
+    user.reload
+    assert_present user.invitation_token
+  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 return a record with errors if user was found by e-mail' do
+    user = create_user_with_invitation('')
+    user.update_attribute(:invitation_token, nil)
+    invited_user = User.invite!(:email => user.email)
+    assert_equal invited_user, user
+    assert_equal ['has already been taken'], invited_user.errors[:email]
+  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 => user.invitation_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 = create_user_with_invitation('valid_token')
+    user.update_attribute(:invitation_sent_at, 1.day.ago)
+    User.stubs(:invite_for).returns(10.hours)
+    invited_user = User.accept_invitation!(:invitation_token => 'valid_token')
+    assert_equal user, invited_user
+    assert_equal ["is invalid"], invited_user.errors[:invitation_token]
+  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 => user.invitation_token,
+      :password => 'new_password',
+      :password_confirmation => 'new_password'
+    )
+    user.reload
+
+    assert user.valid_password?('new_password')
+  end
+end