sorcery 0.1.4 → 0.2.0

data/spec/rails3/{controller_remember_me_spec.rb → app_root/spec/controller_remember_me_spec.rb}

@@ -6,7 +6,7 @@ describe ApplicationController do
   describe ApplicationController, "with remember me features" do
     before(:all) do
       ActiveRecord::Migrator.migrate("#{Rails.root}/db/migrate/remember_me")
-      plugin_model_configure([:remember_me])
+      sorcery_reload!([:remember_me])
     end
     
     before(:each) do
@@ -25,7 +25,7 @@ describe ApplicationController do
     
     it "should set cookie on remember_me!" do
       post :test_login_with_remember, :username => 'gizmo', :password => 'secret'
-      cookies["remember_me_token"].should == assigns[:logged_in_user].remember_me_token
+      cookies["remember_me_token"].should == assigns[:current_user].remember_me_token
     end
     
     it "should clear cookie on forget_me!" do
@@ -50,11 +50,11 @@ describe ApplicationController do
       session[:user_id] = @user.id
       subject.remember_me!
       subject.instance_eval do
-        @logged_in_user = nil
+        @current_user = nil
       end
       session[:user_id] = nil
       get :test_login_from_cookie
-      assigns[:logged_in_user].should == @user
+      assigns[:current_user].should == @user
     end
     
     it "should not remember_me! when not asked to" do

data/spec/rails3/{controller_session_timeout_spec.rb → app_root/spec/controller_session_timeout_spec.rb}

@@ -5,8 +5,8 @@ describe ApplicationController do
   # ----------------- SESSION TIMEOUT -----------------------
   describe ApplicationController, "with session timeout features" do
     before(:all) do
-      plugin_model_configure([:session_timeout])
-      plugin_set_controller_config_property(:session_timeout,0.5)
+      sorcery_reload!([:session_timeout])
+      sorcery_controller_property_set(:session_timeout,0.5)
       create_new_user
     end
     
@@ -26,7 +26,7 @@ describe ApplicationController do
     end
     
     it "with 'session_timeout_from_last_action' should not logout if there was activity" do
-      plugin_set_controller_config_property(:session_timeout_from_last_action, true)
+      sorcery_controller_property_set(:session_timeout_from_last_action, true)
       login_user
       sleep 0.3
       get :test_should_be_logged_in
@@ -38,7 +38,7 @@ describe ApplicationController do
     end
     
     it "with 'session_timeout_from_last_action' should logout if there was no activity" do
-      plugin_set_controller_config_property(:session_timeout_from_last_action, true)
+      sorcery_controller_property_set(:session_timeout_from_last_action, true)
       login_user
       sleep 0.6
       get :test_should_be_logged_in

data/spec/rails3/{controller_spec.rb → app_root/spec/controller_spec.rb}

@@ -5,21 +5,21 @@ describe ApplicationController do
   # ----------------- PLUGIN CONFIGURATION -----------------------
   describe ApplicationController, "plugin configuration" do
     before(:all) do
-      plugin_model_configure
+      sorcery_reload!
     end
     
     after(:each) do
       Sorcery::Controller::Config.reset!
-      plugin_model_configure
+      sorcery_reload!
     end
     
     it "should enable configuration option 'user_class'" do
-      plugin_set_controller_config_property(:user_class, TestUser)
+      sorcery_controller_property_set(:user_class, TestUser)
       Sorcery::Controller::Config.user_class.should equal(TestUser)
     end
     
     it "should enable configuration option 'not_authenticated_action'" do
-      plugin_set_controller_config_property(:not_authenticated_action, :my_action)
+      sorcery_controller_property_set(:not_authenticated_action, :my_action)
       Sorcery::Controller::Config.not_authenticated_action.should equal(:my_action)
     end
     
@@ -34,7 +34,7 @@ describe ApplicationController do
   
     after(:each) do
       Sorcery::Controller::Config.reset!
-      plugin_set_controller_config_property(:user_class, User)
+      sorcery_controller_property_set(:user_class, User)
     end
     
     it "should respond to the instance method login" do
@@ -49,8 +49,8 @@ describe ApplicationController do
       should respond_to(:logged_in?)
     end
     
-    it "should respond to the instance method logged_in_user" do
-      should respond_to(:logged_in_user)
+    it "should respond to the instance method current_user" do
+      should respond_to(:current_user)
     end
   
     it "login(username,password) should return the user when success and set the session with user.id" do
@@ -82,15 +82,15 @@ describe ApplicationController do
       subject.logged_in?.should be_false
     end
     
-    it "logged_in_user should return the user instance if logged in" do
+    it "current_user should return the user instance if logged in" do
       create_new_user
       session[:user_id] = @user.id
-      subject.logged_in_user.should == @user
+      subject.current_user.should == @user
     end
     
-    it "logged_in_user should return false if not logged in" do
+    it "current_user should return false if not logged in" do
       session[:user_id] = nil
-      subject.logged_in_user.should == false
+      subject.current_user.should == false
     end
     
     it "should respond to 'require_login'" do
@@ -99,17 +99,24 @@ describe ApplicationController do
     
     it "should call the configured 'not_authenticated_action' when authenticate before_filter fails" do
       session[:user_id] = nil
-      plugin_set_controller_config_property(:not_authenticated_action, :test_not_authenticated_action)
+      sorcery_controller_property_set(:not_authenticated_action, :test_not_authenticated_action)
       get :test_logout
       response.body.should == "test_not_authenticated_action"
     end
     
     it "require_login before_filter should save the url that the user originally wanted" do
       get :some_action
-      session[:user_wanted_url].should == "http://test.host/some_action"
+      session[:return_to_url].should == "http://test.host/application/some_action"
       response.should redirect_to("http://test.host/")
     end
     
+    it "on successful login the user should be redirected to the url he originally wanted" do
+      session[:return_to_url] = "http://test.host/some_action"
+      post :test_return_to, :username => 'gizmo', :password => 'secret'
+      response.should redirect_to("http://test.host/some_action")
+      flash[:notice].should == "haha!"
+    end
+    
   end
   
 end

data/spec/rails3/app_root/spec/spec_helper.orig.rb

@@ -0,0 +1,27 @@
+# This file is copied to spec/ when you run 'rails generate rspec:install'
+ENV["RAILS_ENV"] ||= 'test'
+require File.expand_path("../../config/environment", __FILE__)
+require 'rspec/rails'
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[Rails.root.join("spec/support/**/*.rb")].each {|f| require f}
+
+RSpec.configure do |config|
+  # == Mock Framework
+  #
+  # If you prefer to use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+  config.mock_with :rspec
+
+  # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
+  config.fixture_path = "#{::Rails.root}/spec/fixtures"
+
+  # If you're not using ActiveRecord, or you'd prefer not to run each of your
+  # examples within a transaction, remove the following line or assign false
+  # instead of true.
+  config.use_transactional_fixtures = true
+end

data/spec/rails3/app_root/spec/spec_helper.rb

@@ -0,0 +1,61 @@
+$: << File.join(File.dirname(__FILE__), '..', '..', 'lib' )
+
+require 'simplecov'
+SimpleCov.root File.join(File.dirname(__FILE__), "..", "..", "app_root" )
+SimpleCov.start do
+  add_filter "/config/"
+  
+  add_group 'Controllers', 'app/controllers'
+  add_group 'Models', 'app/models'
+  add_group 'Helpers', 'app/helpers'
+  add_group 'Libraries', 'lib'
+  add_group 'Plugins', 'vendor/plugins'
+  add_group 'Migrations', 'db/migrate'
+end
+
+require 'spork'
+
+Spork.prefork do
+  # Set the default environment to sqlite3's in_memory database
+  ENV['RAILS_ENV'] ||= 'in_memory'
+  ENV['RAILS_ROOT'] = 'app_root'
+  
+  # Load the Rails environment and testing framework
+  require "#{File.dirname(__FILE__)}/../config/environment"
+  #require "#{File.dirname(__FILE__)}/../../init" # for plugins
+  require 'rspec/rails'
+
+  RSpec.configure do |config|
+    config.use_transactional_fixtures = true
+    config.use_instantiated_fixtures  = false
+    config.include RSpec::Rails::ControllerExampleGroup, :example_group => { :file_path => /controller(.)*_spec.rb$/ }
+
+    config.before(:suite) do
+      ActiveRecord::Migrator.migrate("#{Rails.root}/db/migrate/core")
+    end
+
+    config.after(:suite) do
+      ActiveRecord::Migrator.rollback("#{Rails.root}/db/migrate/core")
+    end
+  end
+  
+  #----------------------------------------------------------------
+  # needed when running individual specs
+  require File.join(File.dirname(__FILE__), '..','app','models','user')
+  require File.join(File.dirname(__FILE__), '..','app','models','authentication')
+
+  class TestUser < ActiveRecord::Base
+    activate_sorcery!
+  end
+
+  class TestMailer < ActionMailer::Base
+
+  end
+  
+  include ::Sorcery::TestHelpers
+  
+end
+
+Spork.each_run do
+  # This code will be run each time you run your specs.
+end

data/spec/rails3/{user_activation_spec.rb → app_root/spec/user_activation_spec.rb}

@@ -1,5 +1,5 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-require File.expand_path(File.dirname(__FILE__) + '/app_root/app/mailers/sorcery_mailer')
+require File.expand_path(File.dirname(__FILE__) + '/../app/mailers/sorcery_mailer')
 
 describe "User with activation submodule" do
   before(:all) do
@@ -13,53 +13,53 @@ describe "User with activation submodule" do
   # ----------------- PLUGIN CONFIGURATION -----------------------
   describe User, "loaded plugin configuration" do
     before(:all) do
-      plugin_model_configure([:user_activation], :user_activation_mailer => ::SorceryMailer)
+      sorcery_reload!([:user_activation], :user_activation_mailer => ::SorceryMailer)
     end
   
     after(:each) do
       User.sorcery_config.reset!
-      plugin_model_configure([:user_activation], :user_activation_mailer => ::SorceryMailer)
+      sorcery_reload!([:user_activation], :user_activation_mailer => ::SorceryMailer)
     end
     
     it "should enable configuration option 'activation_state_attribute_name'" do
-      plugin_set_model_config_property(:activation_state_attribute_name, :status)
+      sorcery_model_property_set(:activation_state_attribute_name, :status)
       User.sorcery_config.activation_state_attribute_name.should equal(:status)    
     end
     
-    it "should enable configuration option 'activation_code_attribute_name'" do
-      plugin_set_model_config_property(:activation_code_attribute_name, :code)
-      User.sorcery_config.activation_code_attribute_name.should equal(:code)    
+    it "should enable configuration option 'activation_token_attribute_name'" do
+      sorcery_model_property_set(:activation_token_attribute_name, :code)
+      User.sorcery_config.activation_token_attribute_name.should equal(:code)    
     end
     
     it "should enable configuration option 'user_activation_mailer'" do
-      plugin_set_model_config_property(:user_activation_mailer, TestMailer)
+      sorcery_model_property_set(:user_activation_mailer, TestMailer)
       User.sorcery_config.user_activation_mailer.should equal(TestMailer)    
     end
     
     it "should enable configuration option 'activation_needed_email_method_name'" do
-      plugin_set_model_config_property(:activation_needed_email_method_name, :my_activation_email)
+      sorcery_model_property_set(:activation_needed_email_method_name, :my_activation_email)
       User.sorcery_config.activation_needed_email_method_name.should equal(:my_activation_email)
     end
     
     it "should enable configuration option 'activation_success_email_method_name'" do
-      plugin_set_model_config_property(:activation_success_email_method_name, :my_activation_email)
+      sorcery_model_property_set(:activation_success_email_method_name, :my_activation_email)
       User.sorcery_config.activation_success_email_method_name.should equal(:my_activation_email)
     end
     
     it "if mailer is nil on activation, throw exception!" do
-      expect{plugin_model_configure([:user_activation])}.to raise_error(ArgumentError)
+      expect{sorcery_reload!([:user_activation])}.to raise_error(ArgumentError)
     end
   end
 
   # ----------------- ACTIVATION PROCESS -----------------------
   describe User, "activation process" do
     before(:all) do
-      plugin_model_configure([:user_activation], :user_activation_mailer => ::SorceryMailer)
+      sorcery_reload!([:user_activation], :user_activation_mailer => ::SorceryMailer)
     end
     
     it "should generate an activation code on registration" do
       create_new_user
-      @user.activation_code.should_not be_nil
+      @user.activation_token.should_not be_nil
     end
     
     it "should initialize user state to 'pending'" do
@@ -74,12 +74,12 @@ describe "User with activation submodule" do
     
     it "should clear activation code and change state to 'active' on activation" do
       create_new_user
-      activation_code = @user.activation_code
+      activation_token = @user.activation_token
       @user.activate!
       @user2 = User.find(@user.id) # go to db to make sure it was saved and not just in memory
-      @user2.activation_code.should be_nil
+      @user2.activation_token.should be_nil
       @user2.activation_state.should == "active"
-      User.find_by_activation_code(activation_code).should be_nil
+      User.find_by_activation_token(activation_token).should be_nil
     end
     
     it "should send the user an activation email" do
@@ -113,14 +113,14 @@ describe "User with activation submodule" do
     end
     
     it "activation needed email is optional" do
-      plugin_set_model_config_property(:activation_needed_email_method_name, nil)
+      sorcery_model_property_set(:activation_needed_email_method_name, nil)
       old_size = ActionMailer::Base.deliveries.size
       create_new_user
       ActionMailer::Base.deliveries.size.should == old_size
     end
     
     it "activation success email is optional" do
-      plugin_set_model_config_property(:activation_success_email_method_name, nil)
+      sorcery_model_property_set(:activation_success_email_method_name, nil)
       create_new_user
       old_size = ActionMailer::Base.deliveries.size
       @user.activate!
@@ -130,7 +130,7 @@ describe "User with activation submodule" do
 
   describe User, "prevent non-active login feature" do
     before(:all) do
-      plugin_model_configure([:user_activation], :user_activation_mailer => ::SorceryMailer)
+      sorcery_reload!([:user_activation], :user_activation_mailer => ::SorceryMailer)
     end
     
     it "should not allow a non-active user to authenticate" do
@@ -140,9 +140,49 @@ describe "User with activation submodule" do
     
     it "should allow a non-active user to authenticate if configured so" do
       create_new_user
-      plugin_set_model_config_property(:prevent_non_active_users_to_login, false)
+      sorcery_model_property_set(:prevent_non_active_users_to_login, false)
       User.authenticate(@user.username,'secret').should be_true
     end
   end
   
+  describe User, "load_from_activation_token" do
+    before(:all) do
+      sorcery_reload!([:user_activation], :user_activation_mailer => ::SorceryMailer)
+    end
+    
+    it "load_from_activation_token should return user when token is found" do
+      create_new_user
+      User.load_from_activation_token(@user.activation_token).should == @user
+    end
+    
+    it "load_from_activation_token should NOT return user when token is NOT found" do
+      create_new_user
+      User.load_from_activation_token("a").should == nil
+    end
+    
+    it "load_from_activation_token should return user when token is found and not expired" do
+      sorcery_model_property_set(:activation_token_expiration_period, 500)
+      create_new_user
+      User.load_from_activation_token(@user.activation_token).should == @user
+    end
+    
+    it "load_from_activation_token should NOT return user when token is found and expired" do
+      sorcery_model_property_set(:activation_token_expiration_period, 0.1)
+      create_new_user
+      sleep 0.5
+      User.load_from_activation_token(@user.activation_token).should == nil
+    end
+    
+    it "load_from_activation_token should return nil if token is blank" do
+      User.load_from_activation_token(nil).should == nil
+      User.load_from_activation_token("").should == nil
+    end
+    
+    it "load_from_activation_token should always be valid if expiration period is nil" do
+      sorcery_model_property_set(:activation_token_expiration_period, nil)
+      create_new_user
+      User.load_from_activation_token(@user.activation_token).should == @user
+    end
+  end
+  
 end

data/spec/rails3/{user_activity_logging_spec.rb → app_root/spec/user_activity_logging_spec.rb}

@@ -10,7 +10,7 @@ describe "User with activity logging submodule" do
   # ----------------- PLUGIN CONFIGURATION -----------------------
   describe User, "loaded plugin configuration" do
     before(:all) do
-      plugin_model_configure([:activity_logging])
+      sorcery_reload!([:activity_logging])
     end
   
     after(:each) do
@@ -18,17 +18,17 @@ describe "User with activity logging submodule" do
     end
     
     it "should allow configuration option 'last_login_at_attribute_name'" do
-      plugin_set_model_config_property(:last_login_at_attribute_name, :login_time)
+      sorcery_model_property_set(:last_login_at_attribute_name, :login_time)
       User.sorcery_config.last_login_at_attribute_name.should equal(:login_time)
     end
     
     it "should allow configuration option 'last_logout_at_attribute_name'" do
-      plugin_set_model_config_property(:last_logout_at_attribute_name, :logout_time)
+      sorcery_model_property_set(:last_logout_at_attribute_name, :logout_time)
       User.sorcery_config.last_logout_at_attribute_name.should equal(:logout_time)
     end
     
     it "should allow configuration option 'last_activity_at_attribute_name'" do
-      plugin_set_model_config_property(:last_activity_at_attribute_name, :activity_time)
+      sorcery_model_property_set(:last_activity_at_attribute_name, :activity_time)
       User.sorcery_config.last_activity_at_attribute_name.should equal(:activity_time)
     end
   end

data/spec/rails3/{user_brute_force_protection_spec.rb → app_root/spec/user_brute_force_protection_spec.rb}

@@ -13,7 +13,7 @@ describe "User with brute_force_protection submodule" do
   describe User, "loaded plugin configuration" do
   
     before(:all) do
-      plugin_model_configure([:brute_force_protection])
+      sorcery_reload!([:brute_force_protection])
       create_new_user
     end
   
@@ -30,22 +30,22 @@ describe "User with brute_force_protection submodule" do
     end
  
     it "should enable configuration option 'failed_logins_count_attribute_name'" do
-      plugin_set_model_config_property(:failed_logins_count_attribute_name, :my_count)
+      sorcery_model_property_set(:failed_logins_count_attribute_name, :my_count)
       User.sorcery_config.failed_logins_count_attribute_name.should equal(:my_count)    
     end
     
     it "should enable configuration option 'lock_expires_at_attribute_name'" do
-      plugin_set_model_config_property(:lock_expires_at_attribute_name, :expires)
+      sorcery_model_property_set(:lock_expires_at_attribute_name, :expires)
       User.sorcery_config.lock_expires_at_attribute_name.should equal(:expires)    
     end
     
     it "should enable configuration option 'consecutive_login_retries_amount_allowed'" do
-      plugin_set_model_config_property(:consecutive_login_retries_amount_allowed, 34)
-      User.sorcery_config.consecutive_login_retries_amount_allowed.should equal(34)    
+      sorcery_model_property_set(:consecutive_login_retries_amount_limit, 34)
+      User.sorcery_config.consecutive_login_retries_amount_limit.should equal(34)    
     end
     
     it "should enable configuration option 'login_lock_time_period'" do
-      plugin_set_model_config_property(:login_lock_time_period, 2.hours)
+      sorcery_model_property_set(:login_lock_time_period, 2.hours)
       User.sorcery_config.login_lock_time_period.should == 2.hours    
     end
   end
@@ -54,7 +54,7 @@ describe "User with brute_force_protection submodule" do
   describe User, "when activated with sorcery" do
   
     before(:all) do
-      plugin_model_configure([:brute_force_protection])
+      sorcery_reload!([:brute_force_protection])
     end
   
     before(:each) do