devise_certifiable 0.1.0

data/lib/generators/devise_certifiable/devise_certifiable_generator.rb

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

data/lib/generators/devise_certifiable/install_generator.rb

@@ -0,0 +1,11 @@
+module DeviseCertifiable
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("../../templates", __FILE__)
+      
+      def copy_locale
+        copy_file "../../../config/locales/en.yml", "config/locales/devise_certifiable.en.yml"
+      end
+    end
+  end
+end

data/test/controllers/url_helpers_test.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+
+class RoutesTest < ActionController::TestCase
+  tests ApplicationController
+
+  def assert_path_and_url(name, prepend_path=nil)
+    @request.path = '/users/session'
+    prepend_path = "#{prepend_path}_" if prepend_path
+
+    # Resource param
+    assert_equal @controller.send(:"#{prepend_path}#{name}_path", :user),
+                 send(:"#{prepend_path}user_#{name}_path")
+    assert_equal @controller.send(:"#{prepend_path}#{name}_url", :user),
+                 send(:"#{prepend_path}user_#{name}_url")
+
+    # Default url params
+    assert_equal @controller.send(:"#{prepend_path}#{name}_path", :user, :param => 123),
+                 send(:"#{prepend_path}user_#{name}_path", :param => 123)
+    assert_equal @controller.send(:"#{prepend_path}#{name}_url", :user, :param => 123),
+                 send(:"#{prepend_path}user_#{name}_url", :param => 123)
+
+    @request.path = nil
+    # With an object
+    assert_equal @controller.send(:"#{prepend_path}#{name}_path", User.new),
+                 send(:"#{prepend_path}user_#{name}_path")
+    assert_equal @controller.send(:"#{prepend_path}#{name}_url", User.new),
+                 send(:"#{prepend_path}user_#{name}_url")
+  end
+
+  test 'should alias certification to mapped user certification' do
+    assert_path_and_url :certification
+    assert_path_and_url :certification, :edit
+  end
+end

data/test/generators/active_record_generator_test.rb

@@ -0,0 +1,24 @@
+require "test_helper"
+require "rails/generators/test_case"
+
+if DEVISE_ORM == :active_record
+  require "generators/active_record/devise_certifiable_generator"
+
+  class ActiveRecordGeneratorTest < Rails::Generators::TestCase
+    tests ActiveRecord::Generators::DeviseCertifiableGenerator
+    
+    destination File.expand_path("../../tmp", __FILE__)
+    setup :prepare_destination
+  
+    test "migration is properly created" do
+      run_generator %w(monster)
+      assert_migration "db/migrate/devise_certifiable_add_to_monsters.rb"
+    end
+  
+    test "all files are properly deleted" do
+      run_generator %w(monster)
+      run_generator %w(monster), :behavior => :revoke
+      assert_no_migration "db/migrate/devise_create_monsters.rb"
+    end
+  end
+end

data/test/generators/devise_certifiable_generator_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+require 'rails/generators'
+require "generators/devise_certifiable/devise_certifiable_generator"
+
+class DeviseCertifiableGeneratorTest < Rails::Generators::TestCase
+  tests DeviseCertifiable::Generators::DeviseCertifiableGenerator
+  
+  destination File.expand_path("../../tmp", __FILE__)
+
+  setup do
+    prepare_destination
+    copy_model
+  end
+
+  test "add :certifiable to model" do
+#    run_generator %w(monster)
+#    assert_file "app/models/monster.rb", /devise :certifiable/
+    flunk 'TODO'
+  end
+
+  def copy_model
+    model = File.expand_path("../../rails_app/app/models/monster.rb", __FILE__)
+    destination = File.join(destination_root, 'app/models')
+    FileUtils.mkdir_p(destination)
+    FileUtils.cp model, destination
+  end
+end

data/test/generators/install_generator_test.rb

@@ -0,0 +1,15 @@
+require "test_helper"
+require 'rails/generators'
+require "generators/devise_certifiable/install_generator"
+
+class InstallGeneratorTest < Rails::Generators::TestCase
+  tests DeviseCertifiable::Generators::InstallGenerator
+  
+  destination File.expand_path("../../tmp", __FILE__)
+  setup :prepare_destination
+
+  test "Assert all files are properly created" do
+    run_generator
+    assert_file "config/locales/devise_certifiable.en.yml"
+  end
+end

data/test/integration/certification_test.rb

@@ -0,0 +1,80 @@
+require 'test_helper'
+
+class CertificationTest < ActionController::IntegrationTest
+  def teardown
+    Capybara.reset_sessions!
+  end
+
+  def visit_certify_with_token(token)
+    visit edit_user_certification_path(:certification_token => token)
+  end
+  
+  test 'new user need to be certified and confirmed before signing in' do
+    admin = create_user
+    user = sign_in_as_user
+    assert page.has_selector? 'div#flash_alert', :text => 'Your account needs to be certified.'
+    user.certify!(admin)
+    sign_in_as_user(user)
+    assert page.has_selector? 'div#flash_alert', :text => 'You have to confirm your account before continuing.'
+    user.confirm!
+    sign_in_as_user(user)
+    assert page.has_selector? 'div#flash_notice', :text => 'Signed in successfully.'
+    assert page.has_content? "Hello User #{user.email}!"
+    assert page.has_content? 'Home!'
+  end
+
+  test 'certifier should login before certifying user' do
+    user = create_user
+    visit_certify_with_token user.certification_token
+    assert page.has_selector? 'div#flash_alert', :text => 'You need to sign in or sign up before continuing.'
+
+    admin = sign_in_as_admin
+    visit_certify_with_token user.certification_token
+    assert page.has_selector? 'h2', :text => 'User Certification'
+    assert page.has_selector? 'label', :text => user.email
+    assert page.has_button? 'Certify'
+  end
+  
+  test 'complete certifications proces' do
+    user = create_user
+    admin = sign_in_as_admin
+    visit_certify_with_token user.certification_token
+    #click_button 'user_submit'
+    flunk 'TODO'
+  end
+  
+
+  test 'invalid certification token should produce an error' do
+    admin = sign_in_as_admin
+    visit_certify_with_token 'invalid_confirmation'
+    assert page.has_selector? 'div#flash_alert', :text => 'The certification token provided is not valid!'
+  end
+
+  test 'new sign up should provide a message and redirect to root url' do
+    visit new_user_registration_path
+    fill_in 'user_email',    :with => 'test1@email.com'
+    fill_in 'user_password', :with => '123456'
+    fill_in 'user_password_confirmation', :with => '123456'
+    click_button 'Sign up'
+    # save_and_open_page
+
+#    assert page.has_selector? 'div#flash_notice', :text => 'You have signed up successfully. However, we could not sign you in because your account is uncertified.'
+#    assert_current_url "/"
+#    assert_not warden.authenticated(:user)
+#    assert page.has_button? 'Sign in'
+    flunk 'TODO'
+  end
+
+  test 'already certified user should be presented with a message instead' do
+    user = create_user
+    user.certified_at = Time.now
+    user.save
+    
+    admin = sign_in_as_admin
+    visit_certify_with_token user.certification_token
+    #save_and_open_page
+    #assert page.has_selector? 'div#flash_notice', :text => 'Already certified'
+    flunk 'TODO'
+    
+  end
+end

data/test/mailers/certification_request_test.rb

@@ -0,0 +1,63 @@
+require 'test_helper'
+
+class CertificationRequestTest < ActionMailer::TestCase
+
+  def setup
+    setup_mailer
+    Devise.mailer_sender = 'test@example.com'
+  end
+
+  def user
+    @user ||= create_user
+  end
+
+  def mail
+    @mail ||= begin
+      user
+      ActionMailer::Base.deliveries.first
+    end
+  end
+
+  test 'email sent after creating the user' do
+    assert_not_nil mail
+  end
+
+  test 'content type should be set to html' do
+    assert mail.content_type.include?('text/html')
+  end
+
+  test 'send confirmation instructions to the user email' do
+    mail
+    assert_equal ['test@example.com'], mail.to
+  end
+
+  test 'setup sender from configuration' do
+    assert_equal ['test@example.com'], mail.from
+  end
+
+  test 'setup reply to as copy from sender' do
+    assert_equal ['test@example.com'], mail.reply_to
+  end
+
+  test 'setup subject from I18n' do
+    store_translations :en, :devise => { :mailer => { :certification_request => { :subject => 'New Certification Request' } } } do
+      assert_equal 'New Certification Request', mail.subject
+    end
+  end
+
+  test 'subject namespaced by model' do
+    store_translations :en, :devise => { :mailer => { :certification_request => { :user_subject => 'User Certification Request' } } } do
+      assert_equal 'User Certification Request', mail.subject
+    end
+  end
+
+  test 'body should have user info' do
+    assert_match /#{user.email}/, mail.body.encoded
+  end
+
+  test 'body should have link to certify the account' do
+    host = ActionMailer::Base.default_url_options[:host]
+    edit_certification_url_regexp = %r{<a href=\"http://#{host}/users/certification/edit\?certification_token=#{user.certification_token}">}
+    assert_match edit_certification_url_regexp, mail.body.encoded
+  end
+end

data/test/models/certifiable_test.rb

@@ -0,0 +1,172 @@
+require 'test_helper'
+
+class CertifiableTest < ActiveSupport::TestCase
+
+  def setup
+    setup_mailer
+  end
+
+  test 'should generate certification token after creating a record' do
+    assert_nil new_user.certification_token
+    assert_not_nil create_user.certification_token
+  end
+
+  test 'should not generate certification token if already certified' do
+    flunk 'TODO'
+  end
+
+  test 'should never generate the same certification token for different users' do
+    certification_tokens = []
+    3.times do
+      token = create_user.certification_token
+      assert !certification_tokens.include?(token)
+      certification_tokens << token
+    end
+  end
+
+  test 'should certify a user by updating certfied at and certified by' do
+    admin = create_user
+    user = create_user
+    assert_nil user.certified_at
+    assert_nil user.certified_by
+    assert user.certify!(admin)
+    assert_not_nil user.certified_at
+    assert_not_nil user.certified_by
+    assert_equal user.certified_by, admin
+  end
+
+  test 'should clear certification token while certifiying a user' do
+    admin = create_user
+    user = create_user
+    assert_present user.certification_token
+    user.certify!(admin)
+    assert_nil user.certification_token
+  end
+
+  test 'should not certify without a certification_authority' do
+    user = create_user
+    assert_not user.certify!(nil)
+    assert_equal "(certification authority) not specified", user.errors[:certified_by].join
+
+    user2 = create_user
+    assert_not user2.certify!('')
+    assert_equal "(certification authority) not specified", user2.errors[:certified_by].join
+  end
+  
+  test 'should verify whether a user is certified' do
+    admin = create_user
+    assert_not new_user.certified?
+    user = create_user
+    assert_not user.certified?
+    user.certify!(admin)
+    assert user.certified?
+  end
+
+  test 'should not certify a user already certified' do
+    admin = create_user
+    user = create_user
+    assert user.certify!(admin)
+    assert_blank user.errors[:email]
+    assert_not user.certify!(admin)
+    assert_equal "was already certified!", user.errors[:email].join
+  end
+
+  test 'should find a user by token, but not certify it' do
+    user = create_user
+    certifiable_user = User.find_resource_by_token(user.certification_token)
+    assert_equal certifiable_user, user
+    assert_not user.reload.certified?
+  end
+  
+  test 'should find a user by token and certify it' do
+    admin = create_user
+    user = create_user
+    certifiable_user = User.certify_by_token(user.certification_token, admin)
+    assert_equal certifiable_user, user
+    assert user.reload.certified?
+  end
+
+  test 'should return a new record with errors when a invalid token is given' do
+    certifiable_user = User.find_resource_by_token('invalid_certification_token')
+    assert_not certifiable_user.persisted?
+    assert_equal "is invalid", certifiable_user.errors[:certification_token].join
+  end
+
+  test 'should return a new record with errors when a blank or nil token is given' do
+    certifiable_user = User.find_resource_by_token('')
+    assert_not certifiable_user.persisted?
+    assert_equal "can't be blank", certifiable_user.errors[:certification_token].join
+    certifiable_user = User.find_resource_by_token(nil)
+    assert_not certifiable_user.persisted?
+    assert_equal "can't be blank", certifiable_user.errors[:certification_token].join
+  end
+
+  test 'should send certification instructions by email only after creating user' do
+    assert_email_sent do
+      create_user
+    end
+  end
+
+  test 'should not send certification instructions by email before creating user' do
+    assert_email_not_sent do
+      new_user
+    end
+  end
+
+  test 'should not send certification when trying to save an invalid user' do
+ #   assert_email_not_sent do
+ #     user = new_user
+ #     user.stubs(:valid?).returns(false)
+ #     user.save
+ #   end
+    flunk 'TODO'
+  end
+
+  test 'should always have certification token when email is sent' do
+    user = new_user
+    user.save
+    user.request_certification
+    assert_not_nil user.reload.certification_token
+  end
+
+  test 'should automatically certify new invited user with inviter' do
+#    admin = create_user
+#    user = User.invite!({ :username => "usertest", :email => generate_unique_email}, admin)
+#    assert_nil user.reload.certification_token
+#    assert_not_nil user.certified_at
+#    assert_equal user.certified_by, admin
+    flunk 'TODO'
+  end
+
+  test 'should not send instructions if the user is already certified' do
+    admin = create_user
+    user = create_user
+    user.certify!(admin)
+    assert_email_not_sent do
+      user.certify!(admin)
+    end
+  end
+
+  test 'should not send confirmation instructions before being certified' do
+    admin = create_user
+    assert_equal 1, ActionMailer::Base.deliveries.size
+    user = create_user
+    assert_equal 2, ActionMailer::Base.deliveries.size
+    assert_equal 'Certification request', ActionMailer::Base.deliveries.last.subject
+    user.certify!(admin)
+    assert_equal 3, ActionMailer::Base.deliveries.size
+    assert_equal 'Confirmation instructions', ActionMailer::Base.deliveries.last.subject
+  end
+
+  test 'should be active after being certified and confirmed' do
+    admin = create_user
+    user = create_user
+    assert_not user.active_for_authentication?
+    assert_equal :uncertified, user.inactive_message
+    user.certify!(admin)
+    assert_not user.active_for_authentication?
+    assert_equal :unconfirmed, user.inactive_message
+    user.confirm!
+    assert user.reload.active_for_authentication?
+  end
+end