trust 0.5.0

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

@@ -0,0 +1,251 @@
+# Copyright (c) 2012 Bingo Entreprenøren AS
+# Copyright (c) 2012 Teknobingo Scandinavia AS
+# Copyright (c) 2012 Knut I. Stenmark
+# Copyright (c) 2012 Patrick Hanevold
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require 'test_helper'
+
+class Trust::Controller::ResourceTest < ActiveSupport::TestCase
+
+
+  setup do
+    module ::NameSpacedResource
+
+      class MyEntity
+      end
+
+      class Person
+      end
+    end
+
+    class ::Parent
+    end
+    class ::Child < Parent; end
+    class ::Baluba < Parent; end
+    class ::GrandChild < Child; end
+  end
+
+
+  context 'Info classes' do
+    context 'Instance' do
+      setup do
+        @res = Trust::Controller::Resource::ResourceInfo.new('name_spaced_resource/my_entities', {:name_spaced_resource_my_entity => 'cool'})
+      end
+
+      should 'resolve name' do
+        assert_equal :name_spaced_resource_my_entity, @res.name
+      end
+      should 'resolve plural name' do
+        assert_equal :name_spaced_resource_my_entities, @res.plural_name
+      end
+      should 'resolve path' do
+        assert_equal 'name_spaced_resource/my_entities', @res.path
+      end
+      should 'resolve class' do
+        assert_equal NameSpacedResource::MyEntity, @res.klass
+      end
+
+      should 'resolve parameter' do
+        assert_equal 'cool', @res.params
+      end
+    end
+
+    context 'Irregular Instance' do
+      setup do
+        @res = Trust::Controller::Resource::ResourceInfo.new('name_spaced_resource/people', {:name_spaced_resource_person => 'cool' })
+      end
+
+      should 'resolve name' do
+        assert_equal :name_spaced_resource_person, @res.name
+      end
+      should 'resolve plural name' do
+        assert_equal :name_spaced_resource_people, @res.plural_name
+      end
+      should 'resolve path' do
+        assert_equal 'name_spaced_resource/people', @res.path
+      end
+      should 'resolve class' do
+        assert_equal NameSpacedResource::Person, @res.klass
+      end
+      should 'resolve parameter' do
+        assert_equal 'cool', @res.params
+      end
+    end
+
+    context 'Inheritable instance' do
+      should 'detect params for children' do
+        @res = Trust::Controller::Resource::ResourceInfo.new('parents', {:child => 'cool' })
+        assert_equal 'cool', @res.params
+      end
+
+      should 'detect params for grandchilds' do
+        @res = Trust::Controller::Resource::ResourceInfo.new('parents', {:grand_child => 'cool' })
+        assert_equal 'cool', @res.params
+      end
+      should 'detect params for base' do
+        @res = Trust::Controller::Resource::ResourceInfo.new('parents', {:parent => 'cool' })
+        assert_equal 'cool', @res.params
+      end
+      should 'resolve class' do
+        @res = Trust::Controller::Resource::ResourceInfo.new('parents', {:grand_child => 'cool' })
+        assert_equal Parent, @res.klass
+        assert_equal GrandChild, @res.real_class
+        @res = Trust::Controller::Resource::ResourceInfo.new('parents', {:parent => 'cool' })
+        assert_equal Parent, @res.klass
+        assert_equal Parent, @res.real_class
+      end
+    end
+
+    context 'Parent resource' do
+      setup do
+        @request = Object.new
+        @resources = [NameSpacedResource::Person, :child]
+      end
+      context 'when found' do
+        should 'return object for namespaced resource' do
+          @request.stubs(:symbolized_path_parameters).returns({:name_spaced_resource_person_id => 2 })
+          NameSpacedResource::Person.expects(:find).with(2).returns(@object = NameSpacedResource::Person.new)
+          @res = Trust::Controller::Resource::ParentInfo.new(@resources, {}, @request)
+          assert_equal @object, @res.object
+        end
+        should 'return object for regular resource' do
+          @request.stubs(:symbolized_path_parameters).returns({:child_id => 2 })
+          Child.expects(:find).with(2).returns(@object = Child.new)
+          @res = Trust::Controller::Resource::ParentInfo.new(@resources, {}, @request)
+          assert_equal @object, @res.object
+        end
+        context 'the attributes' do
+          setup do
+            @request.stubs(:symbolized_path_parameters).returns({:child_id => 2 })
+            Child.expects(:find).with(2).returns(@object = Child.new)
+            @res = Trust::Controller::Resource::ParentInfo.new(@resources, {:child => 'tie'}, @request)
+          end
+          should 'return class for object' do
+            assert_equal @object, @res.object
+            assert @res.object?        
+          end
+          should 'respond to object?' do
+            assert @res.object?        
+          end
+          should 'return name for class' do
+            assert_equal :child, @res.name
+          end
+          should 'return parameters' do
+            assert_equal 'tie', @res.params
+          end
+        end
+      end
+      should 'return nil for object if not found' do
+        @request.stubs(:symbolized_path_parameters).returns({:child_id => 2 })
+        Child.expects(:find).with(2).returns(nil)
+        @res = Trust::Controller::Resource::ParentInfo.new(@resources, {}, @request)
+        assert_nil @res.object
+        assert !@res.object?
+      end
+      should 'return nil for object if not specified' do
+        @request.stubs(:symbolized_path_parameters).returns({})
+        @res = Trust::Controller::Resource::ParentInfo.new(@resources, {}, @request)
+        assert_nil @res.object
+        assert !@res.object?
+      end
+      should 'return nil for klass when not found' do
+        @request.stubs(:symbolized_path_parameters).returns({})
+        @res = Trust::Controller::Resource::ParentInfo.new(@resources, {}, @request)
+        assert_nil @res.klass
+      end
+    end
+
+    context 'Parent resource with inheritance' do
+      setup do
+        @request = Object.new
+        @resources = [:parent]
+        @request.stubs(:symbolized_path_parameters).returns({:child_id => 2 })
+        Parent.expects(:find).with(2).returns(@object = Child.new)
+        @res = Trust::Controller::Resource::ParentInfo.new(@resources, {}, @request)
+      end
+      should 'resolve descendants' do
+        assert_equal @object, @res.object
+      end
+      should 'have correct name' do
+        assert_equal :child, @res.name
+      end
+      should 'have correct class' do
+        assert_equal Parent, @res.klass
+      end
+      should 'have real class' do
+        assert_equal Child, @res.real_class
+      end
+    end
+  end
+  
+  
+  context 'Resource' do
+    setup do
+      @controller = stub('Controller', :controller_path => :controller)
+      @properties = Trust::Controller::Properties.new(@controller, nil)
+      @properties.model :child
+      @properties.belongs_to :parent
+      @resource_info = stub('ResourceInfo')
+      @parent_info = stub(:object => 6, :name => :parent)
+      @resource_info.expects(:relation).with(@parent_info).returns(Child)
+      @resource_info.stubs(:name).returns(:child)
+      Trust::Controller::Resource.any_instance.expects(:extract_resource_info).with(:child, {}).returns(@resource_info)
+      Trust::Controller::Resource.any_instance.expects(:extract_parent_info).with({:parent => nil}, {}, @request).returns(@parent_info)
+    end
+    should 'instantiate properly' do      
+      @resource = Trust::Controller::Resource.new(@controller, @properties, 'new',{}, @request)      
+    end
+    should 'discover variable names' do
+      @resource = Trust::Controller::Resource.new(@controller, @properties, 'new',{}, @request)
+      @resource_info.expects(:plural_name).returns(:children)
+      assert_equal :child, @resource.send(:instance_name)
+      assert_equal :parent, @resource.send(:parent_name)
+      assert_equal :children, @resource.send(:plural_instance_name)
+    end
+    should 'have access to instances' do
+      @resource = Trust::Controller::Resource.new(@controller, @properties, 'new',{}, @request)
+      @resource.expects(:plural_instance_name).twice.returns(:children)
+      @resource.instances = [1]
+      assert_equal [1], @resource.instances
+      assert_equal [1], @controller.instance_variable_get(:@children)
+    end
+    should 'have access to instantiated' do
+      @resource = Trust::Controller::Resource.new(@controller, @properties, 'new',{}, @request)
+      @resource.expects(:instances).returns(1)
+      assert_equal 1, @resource.instantiated
+      @resource.expects(:instances).returns(nil)
+      @resource.expects(:instance).returns(2)
+      assert_equal 2, @resource.instantiated
+    end
+    should 'load as expected' do
+      @resource = Trust::Controller::Resource.new(@controller, @properties, 'new',{}, @request)      
+      @resource_info.stubs(:params).returns({})
+      @controller.expects(:respond_to?).with(:build).returns(false)
+      @resource.load
+      assert_equal 6, @controller.instance_variable_get(:@parent)
+      assert_equal 6, @resource.parent
+      assert @controller.instance_variable_get(:@child).is_a?(Child)
+      assert @resource.instance.is_a?(Child)
+    end
+  end
+  
+end

data/test/unit/trust/controller_test.rb

@@ -0,0 +1,160 @@
+# Copyright (c) 2012 Bingo Entreprenøren AS
+# Copyright (c) 2012 Teknobingo Scandinavia AS
+# Copyright (c) 2012 Knut I. Stenmark
+# Copyright (c) 2012 Patrick Hanevold
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require 'test_helper'
+
+class Trust::ControllerTest < ActiveSupport::TestCase
+  setup do
+    class Controller < ActionController::Base
+      trustee
+    end
+    class DerivedController < Controller
+    end
+  end
+  context 'class method' do
+    should 'instantiate properties' do
+      assert_kind_of Trust::Controller::Properties, Controller.properties
+    end
+    should 'trustee set filers' do
+      options = {:hello => :there}
+      Controller.expects(:before_filter).with(:set_user, options)
+      Controller.expects(:before_filter).with(:load_resource, options)
+      Controller.expects(:before_filter).with(:access_control, options)
+      Controller.trustee options
+    end
+    should 'delegate to resource' do
+      Controller.properties.expects(:belongs_to)
+      Controller.properties.expects(:actions)
+      Controller.properties.expects(:model)
+      Controller.belongs_to
+      Controller.actions
+      Controller.model
+    end
+
+    context 'callbacks' do
+      should 'be set_user, load_resource, access_control' do
+        %w(set_user load_resource access_control).map(&:to_sym).each do |callback|
+          assert Controller.respond_to?(callback), "'#{callback}' not included"
+          Controller.expects(:_filter_setting).with(callback, 'gurba')
+          Controller.send(callback, 'gurba')
+        end
+      end
+    end
+    
+    context '_filter_setting' do
+      should 'setup correct instance method callback' do
+        Controller.expects(:skip_before_filter).with(:access_control).times(3)
+        Controller.expects(:before_filter).with(:access_control,{})
+        Controller.access_control
+        Controller.expects(:before_filter).with(:access_control,{:only => :index})
+        Controller.access_control :only => :index
+        Controller.expects(:before_filter).never
+        Controller.access_control :off
+      end
+    end
+    
+  end
+  context 'instance methods' do
+    setup do
+      @controller = Controller.new
+    end
+    should 'set user' do
+      user = stub('user')
+      @controller.expects(:current_user).returns(user)
+      Trust::Authorization.expects(:user=).with(user)
+      @controller.set_user
+    end
+    should 'load resource' do
+      @controller.expects(:resource).returns(stub(:load => true))
+      @controller.load_resource
+    end
+    should 'expose resource as helper' do
+      assert @controller.class._helper_methods.include?(:resource)
+    end
+    should 'provide access control' do
+      resource = stub('resource')
+      instance = stub('resource instance')
+      klass    = stub('resource klass')
+      parent   = stub('resource parent')
+
+      resource.expects(:instance).returns(instance)
+      resource.expects(:parent).returns(parent)
+      @controller.expects(:resource).returns(resource).twice
+      Trust::Authorization.expects(:authorize!).with(nil,instance,parent)
+      @controller.access_control
+
+      resource.expects(:instance).returns(nil)
+      resource.expects(:parent).returns(parent)
+      resource.expects(:klass).returns(klass)
+      @controller.expects(:resource).returns(resource).times(3)
+      Trust::Authorization.expects(:authorize!).with(nil,klass,parent)
+      @controller.access_control
+    end
+    context 'can?' do
+      should 'call authorized?' do
+        user = User.new
+        account = Account.new
+        resource = stub('Resource')
+        resource.expects(:parent).returns(nil)
+        @controller.expects(:resource).returns(resource)
+        Trust::Authorization.expects(:authorized?).with(:manage,account,nil).returns(true)
+        @controller.can? :manage, account
+      end
+      should 'should have default parameters' do
+        resource = stub('Resource')
+        @controller.expects(:resource).returns(resource).at_least_once
+        resource.expects(:instance).returns(:instance)
+        resource.expects(:parent).returns(:parent)
+        Trust::Authorization.expects(:authorized?).with(:manage,:instance,:parent)
+        @controller.can? :manage
+        resource.expects(:instance).returns(nil)
+        resource.expects(:klass).returns(:klass)
+        resource.expects(:parent).returns(:parent)
+        Trust::Authorization.expects(:authorized?).with(:manage,:klass,:parent)
+        @controller.can? :manage
+      end
+      should 'be exposed as helper' do
+        assert @controller.class._helper_methods.include?(:can?)
+      end
+    end
+  end
+  context 'derived controller' do
+    should 'instantiate its properties' do
+      DerivedController.instance_variable_set('@properties',nil)
+      Trust::Controller::Properties.expects(:instantiate).with(DerivedController)
+      DerivedController.properties
+    end
+    should 'instantiate its own properties' do
+      assert_not_equal Controller.properties, DerivedController.properties
+    end
+    should 'delegate to its own resource' do
+      DerivedController.properties.expects(:belongs_to)
+      DerivedController.properties.expects(:actions)
+      DerivedController.properties.expects(:model)
+      DerivedController.belongs_to
+      DerivedController.actions
+      DerivedController.model
+    end
+  end
+end

data/test/unit/trust/inheritable_attribute_test.rb

@@ -0,0 +1,65 @@
+# Copyright (c) 2012 Bingo Entreprenøren AS
+# Copyright (c) 2012 Teknobingo Scandinavia AS
+# Copyright (c) 2012 Knut I. Stenmark
+# Copyright (c) 2012 Patrick Hanevold
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require 'test_helper'
+
+class Trust::InheritableAttributeTest < ActiveSupport::TestCase
+  setup do
+    class Cat
+      include Trust::InheritableAttribute
+      inheritable_attr :drinks
+      inheritable_attr :food, :instance_writer => false, :instance_reader => false
+      self.drinks = ["Becks"]
+    end
+  end
+  should 'have only one element in Cat and have two elements in Garfield' do
+    class Garfield < Cat
+      self.drinks << "Fireman's 4"
+    end
+    assert_equal ["Becks"], Cat.drinks
+    assert_equal ["Becks", "Fireman's 4"], Garfield.drinks
+  end
+  should 'have instance method' do
+    assert_equal ["Becks"], Cat.new.drinks
+    Cat.new.drinks << "Bud"
+    assert_equal ["Becks", "Bud"], Cat.drinks
+    assert_equal ["Becks", "Bud"], Cat.new.drinks
+    assert_raises NoMethodError do
+      Cat.new.food
+    end
+    assert_raises NoMethodError do
+      Cat.new.food = 'x'
+    end
+  end
+  context 'inheritance' do
+    should 'deep copy inheritable attributes' do
+      Cat.new.drinks << ['Corona', { :booze => [ 'Liquor', 'Spirit'] }]
+      class Sylvester < Cat
+        self.drinks.last << 'Wiskey'
+      end
+      assert_equal ['Becks', ['Corona', { :booze => [ 'Liquor', 'Spirit'] }]], Cat.drinks
+      assert_equal ['Becks', ['Corona', { :booze => [ 'Liquor', 'Spirit'] }, 'Wiskey']], Sylvester.drinks
+    end
+  end
+end