moonrope 1.3.3 → 2.0.2

data/test/tests/authenticators_test.rb

@@ -0,0 +1,87 @@
+class AuthenticatorsTest < Test::Unit::TestCase
+
+  def test_that_by_default_actions_dont_have_an_authenticator
+    base = Moonrope::Base.new do
+      controller :users do
+        action :list
+      end
+    end
+    assert_equal :none, (base/:users/:list).authenticator_to_use
+  end
+
+  def test_actions_will_use_default_authenticator
+    base = Moonrope::Base.new do
+      authenticator :default do
+        lookup { true }
+      end
+      controller :users do
+        action :list
+      end
+    end
+    assert_equal :default, (base/:users/:list).authenticator_to_use.name
+  end
+
+  def test_actions_will_use_controller_authenticator
+    base = Moonrope::Base.new do
+      authenticator :default
+      authenticator :controller_specific
+      authenticator :action_specific
+      controller :animals do
+        action :list
+      end
+      controller :users do
+        authenticator :controller_specific
+        action :list
+        action :show do
+          authenticator :action_specific
+        end
+      end
+    end
+    assert_equal :default, (base/:animals/:list).authenticator_to_use.name
+    assert_equal :controller_specific, (base/:users/:list).authenticator_to_use.name
+    assert_equal :action_specific, (base/:users/:show).authenticator_to_use.name
+  end
+
+  def test_that_missing_authenticators_return_not_found
+    base = Moonrope::Base.new do
+      authenticator :default
+      controller :animals do
+        authenticator :missing
+        action :list
+      end
+    end
+    assert_equal :not_found, (base/:animals/:list).authenticator_to_use
+  end
+
+  def test_authentication_can_be_defined_via_access_rule
+    base = Moonrope::Base.new do
+      authenticator :some_authenticator
+      controller :users do
+        action :list do
+          access_rule :some_authenticator => :some_rule
+        end
+      end
+    end
+    assert_equal :some_authenticator, (base/:users/:list).authenticator
+    assert_equal :some_rule, (base/:users/:list).access_rule
+  end
+
+  def test_that_access_rules_can_inherit
+    base = Moonrope::Base.new do
+      controller :animals do
+        action :list
+      end
+      controller :users do
+        access_rule :controller_specific
+        action :list
+        action :show do
+          access_rule :action_specific
+        end
+      end
+    end
+    assert_equal :default, (base/:animals/:list).access_rule_to_use
+    assert_equal :controller_specific, (base/:users/:list).access_rule_to_use
+    assert_equal :action_specific, (base/:users/:show).access_rule_to_use
+  end
+
+end

data/test/tests/base_test.rb

@@ -0,0 +1,35 @@
+class ControllersTest < Test::Unit::TestCase
+
+  def test_basic_definitions
+    base = Moonrope::Base.new do
+      authenticator :default do
+        lookup { :person }
+      end
+      controller :users do
+        action :list
+      end
+      controller :animals
+      structure :user
+      structure :animal
+    end
+
+    # Check they are added to the base
+    assert_equal 2, base.controllers.size
+    assert_equal true, base.controllers.all? { |s| s.is_a?(Moonrope::Controller)}
+    assert_equal 2, base.structures.size
+    assert_equal true, base.structures.all? { |s| s.is_a?(Moonrope::Structure)}
+    assert_equal 1, base.authenticators.size
+    assert_equal true, base.authenticators.all? { |_,v| v.is_a?(Moonrope::Authenticator) }
+
+    # Check they can be accessed
+    assert_equal :users, base.controller(:users).name
+    assert_equal :animals, base.controller(:animals).name
+    assert_equal :user, base.structure(:user).name
+    assert_equal :animal, base.structure(:animal).name
+
+    # Check controllers & actions can be found nicely
+    assert_equal :list, (base / :users / :list).name
+    assert_equal :user, (base[:user]).name
+  end
+
+end

data/test/tests/controllers_test.rb

@@ -0,0 +1,49 @@
+class ControllersTest < Test::Unit::TestCase
+
+  def setup
+    @base = Moonrope::Base.new
+  end
+
+  def test_controllers_actions_can_be_found_easily
+    controller = Moonrope::Controller.new(@base, :users) do
+      action :list do
+        action { true }
+      end
+    end
+    action = controller / :list
+    assert_equal :list, action.name
+    assert action.is_a?(Moonrope::Action)
+  end
+
+  def test_controllers_can_have_before_filters
+    controller = Moonrope::Controller.new(@base, :users) do
+      before { 1 }
+      before(:list) { 3 }
+      action :list do
+        action { true }
+      end
+
+      action :show do
+        action { true }
+      end
+    end
+    assert_equal 2, controller.befores.size
+    assert_equal 2, controller.before_actions_for(:list).size
+    assert_equal 1, controller.before_actions_for(:show).size
+  end
+
+  def test_definining_shared_params
+    controller = Moonrope::Controller.new(@base, :users) do
+      shared_action :crud do
+        param :username
+        param :first_name
+        error 'SomeError'
+      end
+    end
+
+    assert_equal(Hash, controller.shared_actions.class)
+    assert_equal(Proc, controller.shared_actions[:crud].class)
+
+  end
+
+end

data/test/tests/eval_environment_test.rb

@@ -0,0 +1,136 @@
+class EvalEnvironmentTest < Test::Unit::TestCase
+
+  def setup
+    @auth_user = User.new(:name => 'Admin User')
+    @request = FakeRequest.new(:params => {'page' => '1'}, :version => 2, :identity => @auth_user)
+    @environment = Moonrope::EvalEnvironment.new(Moonrope::Base.new, @request, nil, :accessor1 => 'Hello')
+  end
+
+  def test_version
+    assert_equal 2, @environment.version
+  end
+
+  def test_params
+    assert @environment.params.is_a?(Moonrope::ParamSet)
+    assert_equal '1', @environment.params.page
+  end
+
+  def test_accessors
+    assert_equal 'Hello', @environment.accessor1
+  end
+
+  def test_identity_access
+    assert_equal @auth_user, @environment.identity
+  end
+
+  def test_setting_headers
+    @environment.set_header 'Header1', 'A'
+    assert_equal 'A', @environment.headers['Header1']
+    @environment.set_header 'Header2', 'B'
+    assert_equal 'B', @environment.headers['Header2']
+  end
+
+  def test_setting_flags
+    @environment.set_flag 'Flag1', 'A'
+    assert_equal 'A', @environment.flags['Flag1']
+    @environment.set_flag 'Flag2', 'B'
+    assert_equal 'B', @environment.flags['Flag2']
+  end
+
+  def test_structure_access
+    user_structure = Moonrope::Structure.new(@environment.base, :user) do
+      basic { {:id => o.id} }
+    end
+    structure = @environment.structure(user_structure, User.new)
+    assert structure.is_a?(Hash), "structure was not a Hash, was a #{structure.class}"
+  end
+
+  def test_structure_access_with_auto_determination
+    user_structure = @environment.base.dsl.structure(:user) do
+      basic { {:id => o.id} }
+    end
+    structure = @environment.structure(UserWithUnderscore.new)
+    assert structure.is_a?(Hash), "structure was not a Hash, was a #{structure.class}"
+  end
+
+  def test_structure_for
+    user_structure = @environment.base.dsl.structure(:user) do
+      basic { {:id => o.id} }
+    end
+    structure = @environment.structure_for(:user)
+    assert_equal structure, user_structure
+  end
+
+  def test_has_structure_for
+    user_structure = @environment.base.dsl.structure(:user) do
+      basic { {:id => o.id} }
+    end
+    assert_equal false, @environment.has_structure_for?(:blah)
+    assert_equal true, @environment.has_structure_for?(:user)
+  end
+
+  def test_copy_attributes_from_param_set_to_an_object
+    base = Moonrope::Base.new
+    controller = Moonrope::Controller.new(base, :users) do
+      action :save do
+        param :username do |object, value|
+          object.username = "#{value}!"
+        end
+        param :id
+      end
+    end
+
+    request = FakeRequest.new(:params => {'id' => 123, 'username' => 'adam'})
+    env = Moonrope::EvalEnvironment.new(base, request, controller/:save)
+    user = User.new
+    env.copy_params_to user, :username, :id
+    assert_equal user.id, 123
+    assert_equal user.username, "adam!"
+  end
+
+  def test_copy_attributes_from_share
+    base = Moonrope::Base.new
+    controller = Moonrope::Controller.new(base, :users) do
+      shared_action :crud do
+        param :username
+        param :id
+      end
+      action :save do
+        use :crud
+      end
+    end
+
+    request = FakeRequest.new(:params => {'id' => 123, 'username' => 'adam'})
+    env = Moonrope::EvalEnvironment.new(base, request, controller/:save)
+    user = User.new
+    env.copy_params_to user, :from => :crud
+    assert_equal user.id, 123
+    assert_equal user.username, "adam"
+  end
+
+  def test_copy_attribute_from_shared_action_within_shared_action
+    base = Moonrope::Base.new
+    controller = Moonrope::Controller.new(base, :users) do
+      shared_action :private_code do
+        param :private_code
+      end
+      shared_action :crud do
+        param :username
+        param :id
+        use :private_code
+      end
+      action :save do
+        use :crud
+      end
+    end
+
+    request = FakeRequest.new(:params => {'id' => 123, 'username' => 'adam', 'private_code' => 'llama'})
+    env = Moonrope::EvalEnvironment.new(base, request, controller/:save)
+    user = User.new
+    env.copy_params_to user, :from => :crud
+    assert_equal user.username, "adam"
+    assert_equal user.private_code, "llama"
+  end
+
+end
+

data/test/tests/evel_helpers_test.rb

@@ -0,0 +1,60 @@
+class EvalHelpersTest < Test::Unit::TestCase
+
+  def setup
+    @environment = Moonrope::EvalEnvironment.new(Moonrope::Base.new, FakeRequest.new(:params => {'page' => 1}))
+    @environment.reset
+  end
+
+  def test_errors
+    assert_raises Moonrope::Errors::NotFound do
+      @environment.error(:not_found, "Page not found")
+    end
+
+    assert_raises Moonrope::Errors::AccessDenied do
+      @environment.error(:access_denied, "User not authenticated")
+    end
+
+    assert_raises Moonrope::Errors::ValidationError do
+      @environment.error(:validation_error, [{:field => 'user', :message => 'should not be blank'}])
+    end
+
+    assert_raises Moonrope::Errors::ParameterError do
+      @environment.error(:parameter_error, [{:field => 'page', :message => 'should be present'}])
+    end
+
+    assert_raises Moonrope::Errors::RequestError do
+      @environment.error(:misc_error, "Unknown issue")
+    end
+  end
+
+  def test_paginate
+    items = PaginationCollection.new
+    result = @environment.paginate(items)  { |r| r }
+    assert result.is_a?(Array)
+    assert @environment.flags[:paginated].is_a?(Hash)
+  end
+
+  class PaginationCollection
+    def to_a
+      [1,2,3,4,5,6]
+    end
+
+    def page(page)
+      self
+    end
+
+    def per(max_per_page)
+      self
+    end
+
+    def total_pages
+      2
+    end
+
+    def total_count
+      34
+    end
+  end
+
+
+end

data/test/tests/examples_test.rb

@@ -0,0 +1,11 @@
+class ExamplesTest < Test::Unit::TestCase
+
+  def setup
+    @base = Moonrope::Base.load(File.expand_path('../../../example', __FILE__))
+  end
+
+  def test_examples_are_valid
+    assert_equal 2, @base.controllers.size
+  end
+
+end

data/test/tests/helpers_test.rb

@@ -0,0 +1,97 @@
+class HelpersTest < Test::Unit::TestCase
+
+  def test_helper_definitions_and_selection
+    base = Moonrope::Base.new do
+      # A global helper
+      helper :say_hello do |name|
+        "Hello #{name}!"
+      end
+
+      # A controller specific helper
+      controller :users do
+        helper :user_helper do |name|
+          "Your name is #{name}!"
+        end
+
+        action :action1 do
+          action do
+            say_hello('David')
+          end
+        end
+
+        action :action2 do
+          action do
+            user_helper('Michael')
+          end
+        end
+
+        action :action3 do
+          action do
+            animal_helper('Bob')
+          end
+        end
+      end
+
+      # Another controller
+      controller :animals do
+        helper :animal_helper do |name|
+          "Animal name is #{name}"
+        end
+      end
+    end
+
+    assert_equal 3, base.helpers.size
+    assert_equal Moonrope::Helper, base.helper(:say_hello).class
+
+    # see if the controller-scoped helper is only available to the cobntroller
+    assert_equal nil, base.helper(:user_helper)
+    assert_equal nil, base.helper(:user_helper, base / :animals)
+    assert_equal Moonrope::Helper, base.helper(:user_helper, base/:users).class
+
+    # see if running the actuions will allow usage of helpers
+    result = (base/:users/:action1).execute
+    assert_equal "Hello David!", result.data
+
+    result = (base/:users/:action2).execute
+    assert_equal "Your name is Michael!", result.data
+
+    assert_raises(NoMethodError) { (base/:users/:action3).execute }
+  end
+
+  def test_unloadable_helpers
+    base = Moonrope::Base.new
+    base.dsl.instance_eval do
+      helper :unloadable_helper, :unloadable => false do
+        666
+      end
+
+      helper :normal_helper do
+        111
+      end
+    end
+    # initially they'll both exist
+    assert_equal Moonrope::Helper, base.helper(:unloadable_helper).class
+    assert_equal Moonrope::Helper, base.helper(:normal_helper).class
+    # unload the base
+    base.unload
+    # now only the unloadable helper remains
+    assert_equal Moonrope::Helper, base.helper(:unloadable_helper).class
+    assert_equal nil, base.helper(:normal_helper)
+  end
+
+  def test_ensure_helpers_cant_be_double_loaded
+    base = Moonrope::Base.new do
+      helper :my_helper do
+        123
+      end
+    end
+
+    assert_raises Moonrope::Errors::HelperAlreadyDefined do
+      base.dsl.instance_eval do
+        helper :my_helper do
+        end
+      end
+    end
+  end
+
+end