moonrope 1.4.1 → 2.0.0

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

data/test/tests/param_set_test.rb

@@ -0,0 +1,44 @@
+require 'ostruct'
+
+class ParamSetTest < Test::Unit::TestCase
+
+  def test_param_set
+    set = Moonrope::ParamSet.new('fruit' => 'Banana')
+    # Test that values which aren't included are nil
+    assert_equal nil, set.vegetable
+    assert_equal nil, set[:vegetable]
+    # Test values can be accessed if they are provided
+    assert_equal 'Banana', set.fruit
+    assert_equal 'Banana', set[:fruit]
+    assert_equal 'Banana', set['fruit']
+  end
+
+  def test_default_params
+    set = Moonrope::ParamSet.new('fruit' => 'Banana')
+    set._defaults = {'vegetable' => 'Tomato', 'fruit' => 'Apple'}
+    # Check that the default is provided
+    assert_equal 'Tomato', set.vegetable
+    # Check that the fruit default isn't used.
+    assert_equal 'Banana', set.fruit
+  end
+
+  def test_nilification
+    set = Moonrope::ParamSet.new('fruit' => '')
+    assert_equal nil, set.fruit
+    assert_equal nil, set[:fruit]
+    assert_equal nil, set['fruit']
+  end
+
+  def test_key_presence
+    set = Moonrope::ParamSet.new('fruit' => 'Apple')
+    set._defaults = {'meat' => 'Beef'}
+    assert_equal true, set.has?(:fruit)
+    assert_equal true, set.has?(:meat)
+    assert_equal false, set.has?(:vegetable)
+  end
+
+  class ParamSetCopyTestThing
+    attr_accessor :fruit, :vegetable
+  end
+
+end

data/test/tests/rack_middleware_test.rb

@@ -0,0 +1,109 @@
+class RackMiddlewareTest < Test::Unit::TestCase
+
+  include Rack::Test::Methods
+
+  def app
+    @app ||= begin
+      base = Moonrope::Base.new do
+        authenticator :default do
+          error "Denied", "No suitable credentials were provided."
+          lookup do
+            # if there is a x-moonrope-username header, check the auth
+            # or raise access denied.
+            if request.headers['X-Moonrope-Username']
+              if request.headers['X-Moonrope-Username'] == 'user' && request.headers['X-Moonrope-Password'] == 'password'
+                User.new(:admin => true)
+              else
+                error "Denied"
+              end
+            end
+          end
+        end
+        controller :users do
+          action :list do
+            # return an empty array
+            action { [] }
+          end
+
+          action :echo do
+            param :name, :required => true
+            action { params.name }
+          end
+        end
+      end
+      Moonrope::RackMiddleware.new(nil, base)
+    end
+  end
+
+  def test_non_api_requests_404
+    get "/"
+    assert_equal 404, last_response.status
+  end
+
+  def test_api_request_validation
+    get "/api/"
+    assert_equal 400, last_response.status
+    get "/api/v1"
+    assert_equal 400, last_response.status
+    get "/api/v1/controller"
+    assert_equal 400, last_response.status
+  end
+
+  def test_api_methods
+    params = {:page => 1}.to_json
+    get "/api/v1/users/list", {:params => params}
+    assert_equal 200, last_response.status
+    assert response_json = JSON.parse(last_response.body)
+    assert_equal 'success', response_json['status']
+    assert response_json['data'].is_a?(Array)
+    assert_equal 'application/json', last_response.headers['Content-Type']
+    assert last_response.headers['Content-Length']
+  end
+
+  def test_params_in_body
+    post "/api/v1/users/echo", '{"name":"Adam"}', {'CONTENT_TYPE' => 'application/json'}
+    assert_equal 200, last_response.status
+    assert response_json = JSON.parse(last_response.body)
+    assert_equal 'success', response_json['status']
+    assert_equal 'Adam', response_json['data']
+  end
+
+  def test_passing_invalid_json_renders_a_bad_request
+    get "/api/v1/users/list", {:params => "{invalidjson}"}
+    assert_equal 400, last_response.status
+    assert response_json = JSON.parse(last_response.body)
+    assert_equal 'invalid-json', response_json['status']
+  end
+
+  def test_authenticated_api_methods
+    # correct credential
+    get "/api/v1/users/list", {}, auth_headers('user', 'password')
+    assert response_json = JSON.parse(last_response.body)
+    assert_equal 'success', response_json['status']
+    # invalid password
+    get "/api/v1/users/list", {}, auth_headers('user-invalid', 'password-invalid')
+    assert response_json = JSON.parse(last_response.body)
+    assert_equal 'error', response_json['status']
+    assert_equal 'Denied', response_json['data']['code']
+  end
+
+  def test_request_callback_is_invoked
+    request_count = 0
+    app.base.on_request = Proc.new do |base, env|
+      request_count += 1
+    end
+    assert_equal 0, request_count
+    get "/api/v1/users/list"
+    assert_equal 1, request_count
+    get "/api/v1/users/list"
+    assert_equal 2, request_count
+  end
+
+
+  private
+
+  def auth_headers(username, password)
+    {'HTTP_X_MOONROPE_USERNAME' => username, 'HTTP_X_MOONROPE_PASSWORD' => password}
+  end
+
+end

data/test/tests/request_test.rb

@@ -0,0 +1,232 @@
+class RequestTest < Test::Unit::TestCase
+
+
+  def test_validation
+    # Create a simple API server with just the users & list controller
+    base = Moonrope::Base.new do
+      controller :users do
+        action :list
+      end
+    end
+
+    request = base.request(make_rack_env_hash('/api/v1/users/list'))
+    assert_equal true, request.valid?
+    request = base.request(make_rack_env_hash('/api/v1/missing/unknown'))
+    assert_equal false, request.valid?
+
+    request = base.request(make_rack_env_hash('/api/v1'))
+    assert_equal false, request.valid?
+    request = base.request(make_rack_env_hash('/api/v1/users'))
+    assert_equal false, request.valid?
+  end
+
+  def test_version
+    base = Moonrope::Base.new
+    request = base.request(make_rack_env_hash('/api/v0/users/list'))
+    assert_equal 1, request.version
+    request = base.request(make_rack_env_hash('/api/v1/users/list'))
+    assert_equal 1, request.version
+    request = base.request(make_rack_env_hash('/api/v2/users/list'))
+    assert_equal 2, request.version
+    request = base.request(make_rack_env_hash('/api/v100/users/list'))
+    assert_equal 100, request.version
+  end
+
+  def test_controllers_and_actions
+    base = Moonrope::Base.new do
+      controller :users do
+        action :list
+      end
+    end
+    request = base.request(make_rack_env_hash('/api/v1/users/list'))
+    assert request.controller.is_a?(Moonrope::Controller)
+    assert_equal :users, request.controller.name
+    assert request.action.is_a?(Moonrope::Action)
+    assert_equal :list, request.action.name
+  end
+
+  def test_params_are_accessible
+    env = make_rack_env_hash('/api/v1/users/list', {'params' => {'page' => 1}})
+    request = Moonrope::Base.new.request(env)
+    assert request.params.is_a?(Moonrope::ParamSet)
+    assert_equal '1', request.params.page
+  end
+
+  def test_actions_can_be_executed
+    base = Moonrope::Base.new do
+      controller :users do
+        action :list do
+          action { true }
+        end
+      end
+    end
+
+    request = base.request(make_rack_env_hash('/api/v1/users/list'))
+    assert result = request.execute
+    assert result.is_a?(Moonrope::ActionResult), "request.action does not return an ActionResult, was a #{result.class}"
+  end
+
+  def test_headers_are_accessible
+    base = Moonrope::Base.new
+    env = make_rack_env_hash('/api/v1/users/list', {}, {'HTTP_X_EXAMPLE_HEADER' => 'Hello'})
+    request = base.request(env)
+    assert_equal 'Hello', request.headers['X-Example-Header']
+  end
+
+  def test_ip_is_accessible
+    base = Moonrope::Base.new
+    env = make_rack_env_hash('/api/v1/users/list')
+    request = base.request(env)
+    assert_equal '127.0.0.1', request.ip
+  end
+
+  def test_authenticated_requests
+    base = Moonrope::Base.new do
+      authenticator :default do
+        lookup do
+          User.new(:admin => true)
+        end
+      end
+      controller :users do
+        action :list do
+          action { true }
+        end
+      end
+    end
+    # authenticated
+    request = base.request(make_rack_env_hash('/api/v1/users/list'))
+    assert result = request.execute
+    assert_equal User, request.identity.class
+    assert_equal false, request.anonymous?
+    assert_equal true, request.authenticated?
+  end
+
+  def test_authentication_failures
+    base = Moonrope::Base.new do
+      authenticator :default do
+        lookup do
+          error :access_denied, "Not permitted"
+        end
+      end
+
+      controller :users do
+        action :list do
+          action { true}
+        end
+      end
+    end
+    request = base.request(make_rack_env_hash('/api/v1/users/list'))
+    assert result = request.execute
+    assert_equal "access-denied", result.status
+    assert_equal nil, request.identity
+    assert_equal true, request.anonymous?
+    assert_equal false, request.authenticated?
+  end
+
+  def test_requests_which_authenticator_says_are_anonymous
+    base = Moonrope::Base.new do
+      authenticator :default do
+        lookup { nil }
+      end
+      controller :users do
+        action :list do
+          action { true }
+        end
+      end
+    end
+    request = base.request(make_rack_env_hash('/api/v1/users/list'))
+    assert result = request.execute
+    assert_equal "success", result.status
+    assert_equal nil, request.identity
+    assert_equal true, request.anonymous?
+    assert_equal false, request.authenticated?
+  end
+
+  def test_trying_to_use_invalid_authenticator_raises_error
+    base = Moonrope::Base.new do
+      authenticator :default do
+        lookup do
+          User.new(:admin => true)
+        end
+      end
+      controller :users do
+        action :list do
+          authenticator :blah
+          action { true }
+        end
+      end
+    end
+
+    request = base.request(make_rack_env_hash('/api/v1/users/list'))
+    assert_raises Moonrope::Errors::MissingAuthenticator do
+      request.execute
+    end
+  end
+
+  def test_raising_errors_from_the_authenticator_lookup
+    base = Moonrope::Base.new do
+      authenticator :default do
+        error 'InvalidToken', 'Token provided is invalid', :attributes => {:token => 'The token looked up'}
+        lookup do
+          error 'InvalidToken', :token => request.headers['X-Example-Header']
+        end
+      end
+      controller :users do
+        action :list do
+          action { true }
+        end
+      end
+    end
+    request = base.request(make_rack_env_hash('/api/v1/users/list', {}, {"HTTP_X_EXAMPLE_HEADER" => "1234567"}))
+    assert result = request.execute
+    assert_equal "error", result.status
+    assert_equal "InvalidToken", result.data[:code]
+    assert_equal "1234567", result.data[:token]
+    assert_equal "Token provided is invalid", result.data[:message]
+  end
+
+  def test_appropriate_error_is_returned_from_access_checks
+    base = Moonrope::Base.new do
+      authenticator :default do
+        lookup { :admin }
+        rule :default, "CustomError", "Must be authenticated as admin user" do
+          identity == :anonymous
+        end
+      end
+      controller :users do
+        action :list do
+          action { true }
+        end
+      end
+    end
+    request = base.request(make_rack_env_hash('/api/v1/users/list', {}, {"HTTP_X_EXAMPLE_HEADER" => "1234567"}))
+    assert result = request.execute
+    assert_equal "error", result.status
+    assert_equal "CustomError", result.data[:code]
+    assert_equal "Must be authenticated as admin user", result.data[:message]
+  end
+
+  def test_appropriate_error_can_be_returned_from_authenticator_error_hash
+    base = Moonrope::Base.new do
+      authenticator :default do
+        lookup { :admin }
+        error "CustomError", "Some custom error message override"
+        rule :default, "CustomError", "Must be authenticated as admin user" do
+          identity == :anonymous
+        end
+      end
+      controller :users do
+        action :list do
+          action { true }
+        end
+      end
+    end
+    request = base.request(make_rack_env_hash('/api/v1/users/list', {}, {"HTTP_X_EXAMPLE_HEADER" => "1234567"}))
+    assert result = request.execute
+    assert_equal "error", result.status
+    assert_equal "CustomError", result.data[:code]
+    assert_equal "Some custom error message override", result.data[:message]
+  end
+
+
+end