challah 0.5.2 → 0.5.3

data/test/factories.rb

@@ -14,7 +14,7 @@ FactoryGirl.define do
       name { "Manage Users" }
       key { "manage_users" }
     end
-  end 
+  end
 
   factory :role do
     name { "Sample Role" }
@@ -23,13 +23,13 @@ FactoryGirl.define do
 
     factory :administrator_role do
       name "Administrator"
-      
-      after_create do |role| 
-        Factory(:admin_permission_role, :role => role)
-        Factory(:user_permission_role, :role => role)
+
+      after_create do |role|
+        FactoryGirl.create(:admin_permission_role, :role => role)
+        FactoryGirl.create(:user_permission_role, :role => role)
       end
     end
-    
+
     factory :default_role do
       name { "Default" }
     end
@@ -57,7 +57,7 @@ FactoryGirl.define do
       sequence(:username) { |n| "plain#{n}" }
       role_id nil
     end
-    
+
     factory :normal_user do
       first_name { "Normal" }
       sequence(:username) { |n| "normal#{n}" }

data/test/helper.rb

@@ -32,31 +32,33 @@ require 'challah/test'
 ActiveRecord::Migration.verbose = false
 ActiveRecord::Migrator.migrate("#{Rails.root}/db/migrate")
 
-# Use ActiveSupport::TestCase for any tests using factories and database saving, 
+# Use ActiveSupport::TestCase for any tests using factories and database saving,
 # so we can have a transactional rollback after each test.
 class ActiveSupport::TestCase
+  include FactoryGirl::Syntax::Methods
+
   self.use_transactional_fixtures = true
 end
 
 class MockController
   include Challah::Controller
-  
+
   attr_accessor :request, :session, :params
-  
+
   def initialize()
     @request = MockRequest.new
     @session ||= {}
     @params ||= {}
   end
-  
+
   def redirect_to(*args)
     # do nothing
   end
-  
+
   def login_path
     "/login"
   end
-  
+
   def logout_path
     "/logout"
   end
@@ -64,31 +66,31 @@ end
 
 class MockRequest
   attr_accessor :cookie_jar, :session_options, :url
-  
+
   class MockCookieJar < Hash
     def delete(key, options = {})
       super(key)
     end
   end
-  
+
   def initialize
     @cookie_jar = MockCookieJar.new
     @session_options = { :domain => 'test.dev' }
     @url = "http://example.com/"
   end
-  
+
   def cookies
     @cookie_jar
   end
-  
+
   def cookies=(value)
     @cookie_jar = value
   end
-  
+
   def remote_ip
     "8.8.8.8"
   end
-  
+
   def user_agent
     "Some Cool Browser"
   end

data/test/permission_test.rb

@@ -3,25 +3,25 @@ require 'helper'
 class PermissionTest < ActiveSupport::TestCase
   should validate_presence_of :name
   should validate_presence_of :key
-  
+
   should have_many :roles
   should have_many :users
   should have_many :permission_roles
   should have_many :permission_users
-  
+
   context "With existing permissions" do
     setup do
-      Factory(:permission)
+      create(:permission)
     end
-    
+
     should validate_uniqueness_of :name
     should validate_uniqueness_of :key
   end
-  
+
   context "The Permission class" do
     should "load with the brackets shortcut" do
-      one = Factory(:permission, :name => 'Permission One', :key => 'permission_one')
-      two = Factory(:permission, :name => 'Permission Two', :key => 'permission_two')
+      one = create(:permission, :name => 'Permission One', :key => 'permission_one')
+      two = create(:permission, :name => 'Permission Two', :key => 'permission_two')
 
       assert_equal one, Permission[:permission_one]
       assert_equal one, Permission[:Permission_One]
@@ -30,19 +30,19 @@ class PermissionTest < ActiveSupport::TestCase
       assert_equal nil, Permission[:no_permission_exists]
     end
   end
-  
-  context "A Permission instance" do    
+
+  context "A Permission instance" do
     should "get added to the admin role on create" do
-      admin_role = Factory(:role, :name => 'Administrator')
+      admin_role = create(:role, :name => 'Administrator')
       assert_equal nil, admin_role.permission_keys.index('new_permission')
-      
+
       #Role.stubs(:admin).returns(admin_role)
-      
+
       permission = Permission.new(:name => 'New Permission', :key => 'new_permission', :description => 'This is just a test.')
-      
+
       assert_difference [ 'Permission.count', 'PermissionRole.count' ], 1 do
         assert permission.save
-      end      
+      end
     end
   end
 end

data/test/restrictions_controller_test.rb

@@ -2,101 +2,100 @@ require 'helper'
 
 class RestrictionsControllerTest < ActionController::TestCase
   tests Challah::Test::RestrictionsController
-  
+
   context "The restrictions controller" do
     context "With no user" do
       setup do
-        Challah::Session.destroy
+        logout
       end
-      
+
       should "be able to get to the index page" do
         get :index
         assert_response :success
         assert_equal nil, assigns(:current_user)
-      end 
-      
+      end
+
       should "not be able to get to the edit page" do
         get :edit
         assert_redirected_to '/login'
       end
-      
+
       should "not get to the new page" do
         get :new
         assert_redirected_to '/login'
       end
     end
-    
+
     context "with a regular user" do
       setup do
-        @user = Factory(:user)
-        
-        Challah::Session.create!(@user)
+        @user = create(:user)
+        login_as(@user)
       end
-      
+
       should "get to the index page" do
         get :index
         assert_response :success
         assert_equal @user, assigns(:current_user)
       end
-      
+
       should "get to the edit page" do
         get :edit
         assert_response :success
       end
-      
+
       should "get to the show page" do
         get :show
         assert_response :success
       end
-      
+
       should "not get to the new page" do
         get :new
-        
+
         assert_template 'sessions/access_denied'
         assert_response :unauthorized
       end
     end
-    
+
     context "with an admin user" do
       setup do
-        @user = Factory(:admin_user)
-        @permission = Factory(:permission, :key => 'special')
-        
-        Challah::Session.create!(@user)
+        @user = create(:admin_user)
+        @permission = create(:permission, :key => 'special')
+
+        login_as(@user)
       end
-      
+
       should "get to the index page" do
         get :index
         assert_response :success
         assert_equal @user, assigns(:current_user)
       end
-      
+
       should "get to the edit page" do
         get :edit
         assert_response :success
       end
-      
+
       should "get to the show page" do
         get :show
         assert_response :success
       end
-      
+
       should "get to the new page" do
         get :new
         assert_response :success
       end
     end
-    
+
     context "With an api key" do
       setup do
-        @user = Factory(:user)
+        @user = create(:user)
       end
-      
+
       context "and api_key functionality enabled" do
         setup do
           Challah.options[:api_key_enabled] = true
         end
-        
+
         should "get to the index page" do
           get :index, :key => @user.api_key
           assert_response :success
@@ -120,12 +119,12 @@ class RestrictionsControllerTest < ActionController::TestCase
           assert_response :unauthorized
         end
       end
-      
+
       context "and api_key functionality disabled" do
         setup do
           Challah.options[:api_key_enabled] = false
         end
-        
+
         should "get to the index page" do
           get :index, :key => @user.api_key
           assert_response :success

data/test/role_test.rb

@@ -1,24 +1,24 @@
 require 'helper'
 
 class RoleTest < ActiveSupport::TestCase
-  should validate_presence_of :name  
+  should validate_presence_of :name
   should have_many :users
 
   should have_many :permission_roles
   should have_many :permissions
-  
+
   context "With existing roles" do
     setup do
-      Factory(:role)
+      create(:role)
     end
-    
+
     should validate_uniqueness_of :name
   end
-  
+
   context "The Role model" do
     should "load with the brackets shortcut" do
-      test = Factory(:role, :name => 'Test Role')
-      default = Factory(:default_role)
+      test = create(:role, :name => 'Test Role')
+      default = create(:default_role)
 
       assert_equal test, Role[:test_role]
       assert_equal default, Role[:default]
@@ -26,54 +26,54 @@ class RoleTest < ActiveSupport::TestCase
       assert_equal default, Role[' defAult  ']
       assert_equal nil, Role[:bad_role]
     end
-    
+
     should "be able to quickly load the admin role" do
-      admin_role = Factory(:role, :name => 'Administrator')
-      
+      admin_role = create(:role, :name => 'Administrator')
+
       assert_equal admin_role, Role[:administrator]
       assert_equal admin_role, Role.admin
-    end 
+    end
   end
-  
+
   context "A Role instance" do
     should "have a permission keys array" do
-      admin_permission = Factory(:admin_permission)
-      users_permission = Factory(:users_permission)
-      
-      role = Factory.build(:role)      
-      
+      admin_permission = create(:admin_permission)
+      users_permission = create(:users_permission)
+
+      role = build(:role)
+
       assert_equal 0, role.permission_keys.length
-      
+
       assert_difference 'Role.count', 1 do
         role.save
       end
-      
+
       assert_difference 'PermissionRole.count', 2 do
         role.permission_keys = %w( admin manage_users )
         role.save
       end
-      
+
       assert_equal %w( admin manage_users ), role.permission_keys.sort
     end
-    
+
     should "be able to check for a permission" do
       role = Role.new
       role.stubs(:permission_keys).returns(%w( admin permission1 permission 2 ))
-      
+
       assert_equal true, role.permission?(:admin)
       assert_equal true, role.has(:admin)
       assert_equal true, role.admin?
-      
+
       assert_equal true, role.permission?(:permission1)
       assert_equal true, role.has(:permission1)
       assert_equal true, role.permission1?
-      
+
       assert_equal false, role.permission?(:bad)
       assert_equal false, role.has(:bad)
       assert_equal false, role.bad?
-      
+
       # no question mark, use regular method_missing
-      
+
       assert_raises NoMethodError do
         role.bad_call_without_question_mark
       end

data/test/session_test.rb

@@ -2,173 +2,173 @@ require 'helper'
 
 class SessionTest < ActiveSupport::TestCase
   include Challah
-  
+
   context "An Challah::Session class" do
     should "use the test storage method" do
       assert_equal TestSessionStore, Challah.options[:storage_class]
     end
-    
+
     should "create a new session instance from a user or id" do
-      user = Factory(:user)
-            
-      assert_equal true, user.active?      
-      
-      session = Session.create(user)      
+      user = create(:user)
+
+      assert_equal true, user.active?
+
+      session = Session.create(user)
       assert_equal true, session.valid?
       assert_equal user.id, session.user_id
     end
-    
+
     should "create a blank but invalid session for a non-existant or inactive user" do
       session = Session.create(999)
       assert_equal false, session.valid?
       assert_equal nil, session.user_id
     end
-    
+
     should "persist a session" do
-      user = Factory(:user)
-      
+      user = create(:user)
+
       session = Session.create(user)
       assert_equal true, session.valid?
       assert_equal user, session.user
-      
+
       session.save
-      
+
       session_two = Session.find
       assert_equal true, session_two.valid?
       assert_equal user, session_two.user
-      
+
       Session.destroy
-      
+
       session_three = Session.find
       assert_equal false, session_three.valid?
       assert_equal nil, session_three.user
     end
   end
-  
-  context "A Challah::Session instance" do    
+
+  context "A Challah::Session instance" do
     should "receive a request and params object" do
       session = Session.new(MockRequest.new, { :username => 'test-user', :password => 'test123' })
-      
+
       assert_not_nil session.request
       assert_not_nil session.params
-      
+
       assert_equal true, session.username?
     end
-    
+
     should "be able to set a username" do
       session = Session.new
-      
+
       assert_equal false, session.username?
-      
+
       session.username = 'test-user'
-      
+
       assert_equal true, session.username?
-      
+
       assert_equal 'test-user', session.username
     end
-    
+
     should "be able to set attributes" do
       session = Session.new
-      
+
       assert_equal Hash.new, session.params
-            
+
       session.username = 'test-user'
       expected = { :username => 'test-user' }
       assert_equal expected, session.params
       assert_equal true, session.username?
-      
+
       session.password = 'abc123'
       expected = { :username => 'test-user', :password => 'abc123' }
       assert_equal expected, session.params
       assert_equal true, session.password?
-      
+
       session.api_key = '122345873847'
       expected = { :username => 'test-user', :password => 'abc123', :api_key => '122345873847' }
       assert_equal expected, session.params
       assert_equal true, session.api_key?
-      
+
       session.other = true
       expected = { :username => 'test-user', :password => 'abc123', :api_key => '122345873847', :other => true }
       assert_equal expected, session.params
       assert_equal true, session.other?
-      
+
       assert_raises NoMethodError do
         session.no_key
       end
-    end    
-    
+    end
+
     should "validate with a password" do
-      user = Factory(:user, :username => 'test-user')
-      
+      user = create(:user, :username => 'test-user')
+
       User.stubs(:find_for_session).returns(user)
-      
+
       session = Session.new
       session.ip = '127.0.0.1'
       session.username = 'test-user'
       session.password = 'abc123'
-      
+
       user.expects(:successful_authentication!).with('127.0.0.1').once
-      
+
       assert_equal true, session.valid?
       assert_equal user, session.user
       assert_equal user.id, session.user_id
       assert_equal true, session.persist?
       assert_equal true, session.save
-      
+
       User.unstub(:find_for_session)
     end
-    
+
     should "validate with an api key" do
       Challah.options[:api_key_enabled] = true
-      
-      user = Factory(:user, :api_key => '123456abcdefg')
-      
+
+      user = create(:user, :api_key => '123456abcdefg')
+
       User.stubs(:find_for_session).returns(user)
-      
+
       session = Session.new
       session.ip = '127.0.0.1'
       session.key = '123456abcdefg'
-      
+
       assert_equal true, session.valid?
       assert_equal user, session.user
-      assert_equal user.id, session.user_id      
+      assert_equal user.id, session.user_id
       assert_equal false, session.persist?
       assert_equal false, session.save
-      
+
       user.expects(:successful_authentication!).with('127.0.0.1').once
-      
+
       User.unstub(:find_for_session)
-      
+
       Challah.options[:api_key_enabled] = false
-    end 
-    
+    end
+
     should "reject if password is incorrect" do
-      user = Factory(:user, :username => 'test-user')
-      
+      user = create(:user, :username => 'test-user')
+
       User.stubs(:find_for_session).returns(user)
-      
+
       session = Session.new
       session.username = 'test-user'
       session.password = 'bad-pass'
-      
+
       user.expects(:failed_authentication!).once
-                  
-      assert_equal false, session.valid?      
+
+      assert_equal false, session.valid?
       assert_equal nil, session.user
-      
+
       User.unstub(:find_for_session)
     end
-    
+
     should "have a default_path attribute" do
-      user = Factory(:user, :username => 'test-user')
-      
+      user = create(:user, :username => 'test-user')
+
       user.stubs(:default_path).returns("/user-path")
-      
-      session = Session.new      
+
+      session = Session.new
       assert_equal '/', session.default_path
-      
+
       session = Session.create(user)
       assert_equal '/user-path', session.default_path
-    end 
+    end
   end
 end