trust 0.8.3 → 1.4.2

data/test/dummy/test/functional/accounts_controller_test.rb

@@ -63,7 +63,7 @@ class AccountsControllerTest < ActionController::TestCase
 
     should "update account" do
       put :update, client_id: @client, id: @account, account: { name: @account.name }
-      assert_redirected_to client_account_path(assigns(:account))
+      assert_redirected_to client_account_path(@client, assigns(:account))
     end
 
     should "destroy account" do
@@ -106,7 +106,7 @@ class AccountsControllerTest < ActionController::TestCase
     context 'but having ownership' do
       should 'allow updates' do
         put :update, client_id: @client, id: @account, account: { name: @account.name }
-        assert_redirected_to client_account_path(assigns(:account))
+        assert_redirected_to client_account_path(@client, assigns(:account))
       end
     end
     context 'having no ownership' do

data/test/dummy/test/functional/mongo_accounts_controller_test.rb

@@ -48,30 +48,30 @@ class MongoAccountsControllerTest < ActionController::TestCase
         post :create, mongo_client_id: @client, mongo_account: { name: @account.name }
       end
 
-      assert_redirected_to mongo_client_mongo_account_path(@client,assigns(:mongo_account))
+      assert_redirected_to mongo_account_path(assigns(:mongo_account))
     end
 
     should "show account" do
-      get :show, mongo_client_id: @client.id, id: @account.id
+      get :show, id: @account.id
       assert_response :success
     end
 
     should "get edit" do
-      get :edit, mongo_client_id: @client, id: @account
+      get :edit, id: @account
       assert_response :success
     end
 
     should "update account" do
-      put :update, mongo_client_id: @client, id: @account, mongo_account: { name: @account.name }
-      assert_redirected_to mongo_client_mongo_account_path(assigns(:mongo_account))
+      put :update, id: @account, mongo_account: { name: @account.name }
+      assert_redirected_to mongo_account_path(assigns(:mongo_account))
     end
 
     should "destroy account" do
       assert_difference('MongoAccount.count', -1) do
-        delete :destroy, mongo_client_id: @client, id: @account
+        delete :destroy, id: @account
       end
 
-      assert_redirected_to mongo_client_mongo_accounts_path
+      assert_redirected_to mongo_client_mongo_accounts_path(@client.id)
     end
   end
   
@@ -106,7 +106,7 @@ class MongoAccountsControllerTest < ActionController::TestCase
     context 'but having ownership' do
       should 'allow updates' do
         put :update, mongo_client_id: @client, id: @account, mongo_account: { name: @account.name }
-        assert_redirected_to mongo_client_mongo_account_path(assigns(:mongo_account))
+        assert_redirected_to mongo_account_path(assigns(:mongo_account))
       end
     end
     context 'having no ownership' do

data/test/dummy/test/functional/mongo_clients_controller_test.rb

@@ -26,8 +26,8 @@ require 'test_helper'
 
 class MongoClientsControllerTest < ActionController::TestCase
   setup do
-    @client = MongoClient.create #clients(:one)
     login_as(:system_admin)
+    @client = MongoClient.create #clients(:one)
   end
 
   test "should get index" do

data/test/dummy/test/unit/permissions_test.rb

@@ -27,7 +27,7 @@ require 'test_helper'
 class PermissionsTest < ActiveSupport::TestCase
   setup do
     def login_as(role)
-      Trust::Authorization.user = @user = User.find_or_create_by_name(role)
+      Trust::Authorization.user = @user = User.find_or_create_by(name: role)
     end
   end
   context 'Client' do

data/test/test_helper.rb

@@ -26,9 +26,13 @@
 ENV["RAILS_ENV"] = "test"
 
 require File.expand_path("../dummy/config/environment.rb",  __FILE__)
+ActiveRecord::Migrator.migrations_paths = [File.expand_path("../../test/dummy/db/migrate", __FILE__)]
 require "rails/test_help"
+require 'mocha/mini_test'
 
-Rails.backtrace_cleaner.remove_silencers!
+# Filter out Minitest backtrace while allowing backtrace from other libraries
+# to be shown.
+Minitest.backtrace_filter = Minitest::BacktraceFilter.new
 
 # Load support files
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
@@ -40,6 +44,6 @@ end
 
 class ActionController::TestCase
   def login_as(role = :guest)
-    User.current = @controller.send(:current_user=, User.find_or_create_by_name(role.to_s))
+    User.current = @controller.send(:current_user=, User.find_or_create_by(name: role.to_s))
   end
 end

data/test/trust_test.rb

@@ -28,4 +28,8 @@ class TrustTest < ActiveSupport::TestCase
   test "truth" do
     assert_kind_of Module, Trust
   end
+  
+  should 'return the appropriate rails generation' do
+    assert 6 > Trust.rails_generation
+  end
 end

data/test/unit/trust/authorization_test.rb

@@ -24,103 +24,197 @@
 
 require 'test_helper'
 
+class TestBase < ActiveRecord::Base
+end
+class TestDescendant < TestBase
+end
+class TestParentLess < ActiveRecord::Base
+end
+
+class Permissions::TestBase < Trust::Permissions
+end
+
 class Trust::AuthorizationTest < ActiveSupport::TestCase
-  context 'user' do
-    should 'be set in thread' do
-      Trust::Authorization.user = 1
-      assert_equal 1, Thread.current["current_user"]
-    end
-    should 'be retrieved from thread' do
-      Thread.current["current_user"] = 2
-      assert_equal 2, Trust::Authorization.user
+
+  class Resource < Trust::Controller::Resource
+    def initialize
     end
+    attr_accessor :params_handler
+    def parent; :parent; end
+    def instance; :instance; end
+    def klass; TestBase; end
   end
-  
-  context 'authorizing_class' do
-    setup do
-      class ::TestBase < ActiveRecord::Base
+
+  context 'class method' do
+    context 'access_denied!' do
+      should 'raise exception' do
+        auth = Trust::Authorization.new(:index, TestBase)
+        assert_raises Trust::AccessDenied do
+          auth.access_denied!
+        end
       end
-      class ::TestDescendant < TestBase
+    end
+    context 'delegation' do
+      setup do
+        @obj = stub('authorization')
+        Trust::Authorization.expects(:new).with(:action, :object_or_class, [:hello]).returns(@obj)
       end
-      def authorizing_class(klass)
-        Trust::Authorization.send(:authorizing_class, klass)
+      should 'include authorized?' do
+        @obj.expects(:authorized?).returns(:good)
+        assert_equal :good, Trust::Authorization.authorized?(:action, :object_or_class, [:hello])
+      end
+      should 'include authorize!' do
+        @obj.expects(:authorize!).returns(:good)
+        assert_equal :good, Trust::Authorization.authorize!(:action, :object_or_class, [:hello])
       end
     end
-    should 'return associated Authorization class if it exists' do
-      class ::Permissions::TestBase < Trust::Permissions
+    context 'user' do
+      should 'be set in thread' do
+        Trust::Authorization.user = 1
+        assert_equal 1, Thread.current["current_user"]
+      end
+      should 'be retrieved from thread' do
+        Thread.current["current_user"] = 2
+        assert_equal 2, Trust::Authorization.user
       end
-      assert_equal ::Permissions::TestBase, authorizing_class(::TestBase)
     end
-    should 'return Authorization::Default if no assocated Authorization class' do
-      assert_equal ::Permissions::Default, authorizing_class(::TestDescendant)
+  end
+  
+  context 'initializtion' do
+    setup do
+      @parent = stub('parent')
+      @user = stub('user')
+      @resource = Resource.new
     end
-    should 'return parent Authorization if specified and none exist for the class' do
-      class ::Permissions::TestBase < Trust::Permissions
-      end
-      assert_equal ::Permissions::TestBase, authorizing_class(::TestDescendant)
+    should 'be done properly when no resource is given' do
+      @auth = Trust::Authorization.new('index', TestDescendant, parent: @parent, by: @user)
+      assert_equal :index, @auth.action
+      assert_equal TestDescendant, @auth.klass
+      assert_nil @auth.object
+      assert_equal @parent, @auth.parent
+      assert_equal @user, @auth.actor
     end
+    should 'be done properly when resource is given' do
+      Trust::Authorization.user = 1
+      @auth = Trust::Authorization.new('show', @resource, by: @user)
+      assert_equal :show, @auth.action
+      assert_equal TestBase, @auth.klass
+      assert_equal :instance, @auth.object
+      assert_equal :parent, @auth.parent
+      assert_equal @user, @auth.actor
+      @auth = Trust::Authorization.new('show', @resource)
+      assert_equal 1, @auth.actor
+    end    
   end
   
-  context 'authorize?' do
+  context 'behaviour' do
     setup do
-      class Validator
+      @user = stub('user', role_symbols: [:admin])
+      @resource = Resource.new
+      @auth = Trust::Authorization.new('show', @resource, by: @user)
+    end
+    context 'authorize!' do
+      should 'set params_handler on resource' do
+        ph = {require: :klass, permit: [:name, :address]}
+        @auth.resource.expects(:params_handler=).with(ph)
+        @auth.expects(:permissions).returns(ph)
+        @auth.authorize!
       end
-      class TestAuthorizing # overrides authorizing_class
-        def initialize(user, action, klass, object, parent)
-          Validator.values user, action, klass, object, parent
+      should 'raise exception unless authorized' do
+        @auth.expects(:permissions).returns(false)
+        assert_raises Trust::AccessDenied do
+          @auth.authorize!
         end
       end
-      TestAuthorizing.any_instance.stubs(:authorized?).returns(true)
-      Trust::Authorization.expects(:authorizing_class).with(String).returns(TestAuthorizing)
-    end
-    should 'instanciate authorizing class and set correct parameters for object' do
-      Trust::Authorization.expects(:user).returns(:user)
-      Validator.expects(:values).with(:user, :action, String, 'object_or_class', :parent)
-      assert Trust::Authorization.authorized?('action', 'object_or_class', :parent)
     end
-    should 'instanciate authorizing class and set correct parameters for class' do
-      Trust::Authorization.expects(:user).returns(:user)
-      Validator.expects(:values).with(:user, :action, String, nil, :parent)
-      assert Trust::Authorization.authorized?('action', String, :parent)
+    context 'authorized?' do
+      should 'return the permissions as a boolean value' do
+        @auth.expects(:permissions).returns(false)
+        assert_equal false, @auth.authorized?
+        @auth.expects(:permissions).returns(nil)
+        assert_equal false, @auth.authorized?
+        @auth.expects(:permissions).returns({})
+        assert_equal true, @auth.authorized?
+      end
     end
-    should 'allow actor to override user with actor' do
-      Validator.expects(:values).with('TheActor', :action, String, nil, :parent)
-      assert Trust::Authorization.authorized?('action', String, :parent, :by => 'TheActor')      
-      Trust::Authorization.expects(:authorizing_class).with(String).returns(TestAuthorizing)
-      Validator.expects(:values).with('TheActor', :action, String, nil, nil)
-      assert Trust::Authorization.authorized?('action', String, :by => 'TheActor')      
+    context 'instance_loaded' do
+      should 'set instance on authorizing class' do
+        @auth.authorization.expects(:subject=).with(:cool)
+        @auth.instance_loaded :cool        
+      end
     end
-    should 'support option for :parent' do
-      Trust::Authorization.expects(:user).returns(:user)
-      Validator.expects(:values).with(:user, :action, String, nil, 'parent')
-      assert Trust::Authorization.authorized?('action', String, :parent => 'parent')
+    context 'preload' do
+      should 'require resource to be accessible when instantiated' do
+        @auth.instance_variable_set :@resource, nil
+        assert_raises Trust::Authorization::ResourceNotLoaded do
+          @auth.preload
+        end
+      end
+      should 'delegate to permission if resource is set' do
+        @auth.authorization.expects(:preload).returns(:good)
+        @resource.expects(:params_handler=).with(:good)
+        @auth.preload
+      end
     end
-    should 'support option alias for :parent, namely :for' do
-      Trust::Authorization.expects(:user).returns(:user)
-      Validator.expects(:values).with(:user, :action, String, nil, 'parent')
-      assert Trust::Authorization.authorized?('action', String, :for => 'parent')
+    context 'permissions' do
+      should 'return the values from the authorizing class' do
+        @authorization = stub('authorizing_class')
+        @auth.instance_variable_set(:@authorization,@authorization)
+        @authorization.expects(:authorized?).returns(false)
+        assert !@auth.permissions
+        @authorization.expects(:authorized?).returns({})
+        assert ({}), @auth.permissions
+      end
     end
   end
-
-  context 'authorize!' do
-    should 'call access_denied! unless authorized?' do
-      Trust::Authorization.expects(:access_denied!).once
-      Trust::Authorization.expects(:authorized?).with(1, 2, 3, {}).returns(false)
-      Trust::Authorization.authorize!(1,2,3)
-    end
-    should 'call access_denied! if authorized?' do
-      Trust::Authorization.expects(:access_denied!).never
-      Trust::Authorization.expects(:authorized?).with(1, 2, 3, {}).returns(true)
-      Trust::Authorization.authorize!(1,2,3)
-    end    
-  end
   
-  context 'access_denied!' do
-    should 'raise exception' do
-      assert_raises Trust::AccessDenied do
-        Trust::Authorization.access_denied!
+  context 'authorizing_class' do
+    setup do
+      def authorizing_class(klass)
+        Trust::Authorization.new(:index, klass).send(:authorizing_class)
       end
     end
+    should 'return associated Authorization class if it exists' do
+      assert_equal ::Permissions::TestBase, authorizing_class(::TestBase)
+    end
+    should 'return Authorization::Default if no assocated Authorization class' do
+      assert_equal ::Permissions::Default, authorizing_class(::TestParentLess)
+    end
+    should 'return parent Authorization if specified and none exist for the class' do
+      assert_equal ::Permissions::TestBase, authorizing_class(::TestDescendant)
+    end
+    should 'support customized base classes' do
+      class ::TheBaseClass
+      end
+      class ::TheBaseDescendant < ::TheBaseClass
+      end
+      class ::Permissions::TheBaseClass < Trust::Permissions
+      end
+      assert_equal ::Permissions::TheBaseClass, authorizing_class(::TheBaseDescendant)
+    end
   end
   
+  
+
+  # context 'authorize!' do
+  #   setup do
+  #     @resource = Resource.new
+  #   end
+  #   should 'call access_denied! unless permissions given' do
+  #     Trust::Authorization.expects(:access_denied!).twice
+  #     Trust::Authorization.expects(:check_permissions).with(:index, :instance, :parent, {}).returns(false)
+  #     Trust::Authorization.authorize!(:index, @resource)
+  #     @resource.expects(:instance).returns nil
+  #     Trust::Authorization.expects(:check_permissions).with(:index, :klass, :parent, {}).returns(false)
+  #     Trust::Authorization.authorize!(:index, @resource)
+  #     assert_equal false, @resource.params_handler
+  #   end
+  #   should 'call access_denied! if authorized?' do
+  #     Trust::Authorization.expects(:access_denied!).never
+  #     Trust::Authorization.expects(:check_permissions).with(:show, :instance, :parent, {}).returns({})
+  #     Trust::Authorization.authorize!(:show, @resource)
+  #     assert_equal ({}), @resource.params_handler
+  #   end    
+  # end
+  
 end

data/test/unit/trust/controller/properties_test.rb

@@ -97,6 +97,21 @@ class Trust::Controller::PropertiesTest < ActiveSupport::TestCase
       assert_equal [:show, :edit, :update, :destroy], @properties.member_actions
       assert_equal [:index], @properties.collection_actions
     end
+    should 'discover new_action?' do
+      assert @properties.new_action?( :new)
+      assert @properties.new_action?( 'new')
+      assert !@properties.new_action?( :show)
+    end
+    should 'discover collection_action?' do
+      assert @properties.collection_action?( :index)
+      assert @properties.collection_action?( 'index')
+      assert !@properties.collection_action?( :show)
+    end
+    should 'discover member_action?' do
+      assert @properties.member_action?( :show)
+      assert @properties.member_action?( 'show')
+      assert !@properties.member_action?( :index)
+    end
   end
   
   context 'belongs_to' do