moonrope 1.4.1 → 2.0.0

data/spec/specs/action_spec.rb

@@ -0,0 +1,455 @@
+require 'spec_helper'
+require 'moonrope/base'
+require 'moonrope/controller'
+require 'moonrope/action'
+require 'moonrope/param_set'
+require 'moonrope/eval_environment'
+
+describe Moonrope::Action do
+  subject(:base) { Moonrope::Base.new }
+  subject(:controller) { Moonrope::Controller.new(base, :users) }
+  subject(:action) { Moonrope::Action.new(controller, :list) }
+  subject(:request) { FakeRequest.new }
+  subject(:env) { Moonrope::EvalEnvironment.new(base, request, action) }
+
+  context "an action" do
+    it "should be able to have a name" do
+      expect(action.name).to eq :list
+    end
+
+    it "should be able to have a description" do
+      action.dsl.description "Some description"
+      expect(action.description).to eq("Some description")
+    end
+
+    it "should have a hash of params" do
+      action.dsl.param :username
+      action.dsl.param :password
+      expect(action.params).to be_a(Hash)
+      expect(action.params.size).to eq(2)
+    end
+
+    it "should have a return value" do
+      action.dsl.returns :hash
+      expect(action.returns).to be_a(Hash)
+    end
+
+    it "should have errors" do
+      action.dsl.error 'SomeError', "With Description"
+      expect(action.errors).to be_a(Hash)
+      expect(action.errors.size).to eq 1
+    end
+
+    it "should be able to use shared actions from the controller" do
+      controller.dsl.shared_action :crud do
+        param :username
+      end
+      action.dsl.use :crud
+      expect(action.params.size).to eq 1
+    end
+
+    it "shuold raise an error if tries to use a share that doesn't exist" do
+      expect { action.dsl.use :crud }.to raise_error(Moonrope::Errors::InvalidSharedAction)
+    end
+
+    it "should be able to use shared actions from the base" do
+      base.dsl.shared_action :some_base_thing do
+        param :username
+      end
+      action.dsl.use :some_base_thing
+      expect(action.params.size).to eq 1
+    end
+
+    it "should have a action blocks" do
+      action.dsl.action { true }
+      expect(action.actions).to be_a(Array)
+      expect(action.actions.first).to be_a(Proc)
+    end
+  end
+
+  context "#default_params" do
+    it "should return the default params for the action" do
+      action.dsl.param :param_with_default, :default => 100
+      action.dsl.param :param_with_no_default
+      expect(action.default_params).to be_a Hash
+      expect(action.default_params.size).to eq 1
+      expect(action.default_params['param_with_default']).to eq 100
+    end
+  end
+
+  context "#validate_parameters" do
+    it "should return an error if a required parameter is missing" do
+      action = Moonrope::Action.new(controller, :list) do
+        param :param, :required => true
+      end
+      param_set = Moonrope::ParamSet.new
+      expect { action.validate_parameters(param_set) }.to raise_error(Moonrope::Errors::ParameterError)
+    end
+
+    it "should return an error if a parameter doesn't match its regex" do
+      action = Moonrope::Action.new(controller, :list) do
+        param :param, :regex => /\Ahello\z/
+      end
+      param_set = Moonrope::ParamSet.new('param' => 'nope')
+      expect { action.validate_parameters(param_set) }.to raise_error(Moonrope::Errors::ParameterError)
+      param_set = Moonrope::ParamSet.new('param' => 'hello')
+      expect { action.validate_parameters(param_set) }.to_not raise_error
+    end
+
+    it "should return an error if a parameter isn't included in an options list" do
+      action = Moonrope::Action.new(controller, :list) do
+        param :param, :options => ['apple', 'orange']
+      end
+      param_set = Moonrope::ParamSet.new('param' => 'banana')
+      expect { action.validate_parameters(param_set) }.to raise_error(Moonrope::Errors::ParameterError)
+      param_set = Moonrope::ParamSet.new('param' => 'apple')
+      expect { action.validate_parameters(param_set) }.to_not raise_error
+    end
+
+    it "should return an error if the type is invalid" do
+      action = Moonrope::Action.new(controller, :list) do
+        param :param, :type => String
+      end
+      param_set = Moonrope::ParamSet.new('param' => 123)
+      expect { action.validate_parameters(param_set) }.to raise_error(Moonrope::Errors::ParameterError)
+      param_set = Moonrope::ParamSet.new('param' => 'apple')
+      expect { action.validate_parameters(param_set) }.to_not raise_error
+    end
+
+    it "should return an error if the type is a boolean and it is invalid" do
+      action = Moonrope::Action.new(controller, :list) do
+        param :param, :type => :boolean
+      end
+      param_set = Moonrope::ParamSet.new('param' => 123)
+      expect { action.validate_parameters(param_set) }.to raise_error(Moonrope::Errors::ParameterError)
+      param_set = Moonrope::ParamSet.new('param' => 'true')
+      expect { action.validate_parameters(param_set) }.to_not raise_error
+      param_set = Moonrope::ParamSet.new('param' => 1)
+      expect { action.validate_parameters(param_set) }.to_not raise_error
+      param_set = Moonrope::ParamSet.new('param' => false)
+      expect { action.validate_parameters(param_set) }.to_not raise_error
+    end
+
+    it "should not return an error if the type is a symbol" do
+      action = Moonrope::Action.new(controller, :list) do
+        param :param, :type => :something
+      end
+      param_set = Moonrope::ParamSet.new('param' => 'anything')
+      expect { action.validate_parameters(param_set) }.to_not raise_error
+      param_set = Moonrope::ParamSet.new('param' => 1234.3)
+      expect { action.validate_parameters(param_set) }.to_not raise_error
+    end
+  end
+
+  context "#access_rule_to_use" do
+    it "should return the action's access rule if defined on action" do
+      action.dsl.access_rule :rule
+      expect(action.access_rule_to_use).to eq(:rule)
+    end
+
+    it "should return the controller's access rule if none on action" do
+      controller.access_rule = :crule
+      expect(action.access_rule_to_use).to eq(:crule)
+    end
+
+    it "should return the default access rule if none on action or controller" do
+      expect(action.access_rule_to_use).to eq(:default)
+    end
+  end
+
+  context "#authenticator_to_use" do
+    it "should return the action's authentication if defined on action" do
+      base.dsl.authenticator :something
+      action.dsl.authenticator :something
+      expect(action.authenticator_to_use).to be_a(Moonrope::Authenticator)
+      expect(action.authenticator_to_use.name).to eq(:something)
+    end
+
+    it "should return the controller's authenticator if none on action" do
+      base.dsl.authenticator :csomething
+      controller.dsl.authenticator :csomething
+      expect(action.authenticator_to_use).to be_a(Moonrope::Authenticator)
+      expect(action.authenticator_to_use.name).to eq(:csomething)
+    end
+
+    it "should return no authenticator if none on action or controller and none are defined" do
+      expect(action.authenticator_to_use).to eq :none
+    end
+
+    it "should return default authenticator if none on action or controller and there is a default" do
+      base.dsl.authenticator :default
+      expect(action.authenticator_to_use).to be_a(Moonrope::Authenticator)
+      expect(action.authenticator_to_use.name).to eq(:default)
+    end
+
+    it "should return not_found if the chosen authenticator isn't valid" do
+      action.dsl.authenticator :something
+      expect(action.authenticator_to_use).to eq :not_found
+    end
+  end
+
+  context "#convert_errors_to_action_result" do
+    it "should return the block result if no errors" do
+      result = action.convert_errors_to_action_result { 1234 }
+      expect(result).to eq(1234)
+    end
+
+    it "should return an ActionResult if a request error is encountered" do
+      result = action.convert_errors_to_action_result do
+        raise Moonrope::Errors::ParameterError, "Invalid param"
+      end
+      expect(result).to be_a(Moonrope::ActionResult)
+    end
+
+    it "should return an ActionResult if a registered external error is encountered" do
+      class SomeError < StandardError
+      end
+      base.register_external_error SomeError do |exception, result|
+        result.status = 'some-error'
+        result.data = {:hello => "world"}
+      end
+      result = action.convert_errors_to_action_result do
+        raise SomeError
+      end
+      expect(result).to be_a(Moonrope::ActionResult)
+      expect(result.status).to eq('some-error')
+      expect(result.data).to be_a(Hash)
+      expect(result.data[:hello]).to eq 'world'
+    end
+
+    it "should raise as normal for any non recognized error" do
+      expect { action.convert_errors_to_action_result{ raise StandardError }}.to raise_error(StandardError)
+    end
+  end
+
+  context "#check_access" do
+    it "should return true if no authenticator is available" do
+      expect(action.check_access(env)).to be true
+    end
+
+    it "should return an error if the given access rule is not defined on the authenticator" do
+      base.dsl.authenticator :default
+      action.dsl.access_rule :invalid_rule
+      expect { action.check_access(env) }.to raise_error(Moonrope::Errors::MissingAccessRule)
+    end
+
+    it "should return true if the authenticator has no default rule and the default has been requested" do
+      base.dsl.authenticator :default
+      expect(action.access_rule_to_use).to eq :default
+      expect(action.check_access(env)).to be true
+    end
+
+    it "should return the value of the authenticators access block" do
+      rule_has_executed = false
+      base.dsl.authenticator :default do
+        rule :default, "NotPermitted" do
+          rule_has_executed = true
+          false
+        end
+      end
+      expect(action.check_access(env)).to eq false
+      expect(rule_has_executed).to be true
+    end
+  end
+
+  context "#execute" do
+
+    it "should validate parameters are valid" do
+      allow(action).to receive(:validate_parameters).and_return true
+      action.dsl.action { true }
+      action.execute(env)
+      expect(action).to have_received(:validate_parameters).once
+    end
+
+    it "should execute before actions from the controller" do
+      before_action_run = false
+      controller.dsl.before { before_action_run = true }
+      action.dsl.action { true }
+      action.execute(env)
+      expect(before_action_run).to be true
+    end
+
+    it "should return an ActionResult instance" do
+      action.dsl.action { true }
+      result = action.execute(env)
+      expect(result).to be_a Moonrope::ActionResult
+    end
+
+    it "should have a status" do
+      action.dsl.action { true }
+      expect(action.execute(env).status).to eq 'success'
+    end
+
+    it "should return a time" do
+      action.dsl.action { true }
+      expect(action.execute(env).time).to be_a(Float)
+    end
+
+    it "should return the result" do
+      action.dsl.action { 1234 }
+      expect(action.execute(env).data).to eq 1234
+    end
+
+    it "should include flags from the eval environment" do
+      action.dsl.action do
+        set_flag 'hello', 'world'
+      end
+      result = action.execute(env)
+      expect(result.flags).to be_a(Hash)
+      expect(result.flags['hello']).to eq 'world'
+    end
+
+    it "should include headers from the eval environment" do
+      action.dsl.action do
+        set_header 'X-Something', 'Monkey'
+      end
+      result = action.execute(env)
+      expect(result.headers).to be_a(Hash)
+      expect(result.headers['X-Something']).to eq 'Monkey'
+    end
+  end
+
+  context "#can_change_full?" do
+    it "should return true if the action is fully paramable" do
+      action.dsl.returns :hash, :structure => :user, :structure_opts => {:paramable => true}
+      expect(action.can_change_full?).to be true
+    end
+
+    it "should return true if the action paramable allow full changes" do
+      action.dsl.returns :hash, :structure => :user, :structure_opts => {:paramable => {:full => true}}
+      expect(action.can_change_full?).to be true
+      action.dsl.returns :hash, :structure => :user, :structure_opts => {:paramable => {:full => false}}
+      expect(action.can_change_full?).to be true
+    end
+
+    it "should return false otherwise" do
+      action.dsl.returns :hash, :structure => :user, :structure_opts => {}
+      expect(action.can_change_full?).to be false
+      action.dsl.returns :hash, :structure => :user, :structure_opts => {:full => true}
+      expect(action.can_change_full?).to be false
+    end
+  end
+
+  context "#includes_full_attributes?" do
+    it "should return true if the action is paramable" do
+      action.dsl.returns :hash, :structure => :user, :structure_opts => {:paramable => {:full => true}}
+      expect(action.includes_full_attributes?).to be true
+      action.dsl.returns :hash, :structure => :user, :structure_opts => {:paramable => {:full => false}}
+      expect(action.includes_full_attributes?).to be false
+    end
+
+    it "should return true if it always returns full attributes" do
+      action.dsl.returns :hash, :structure => :user, :structure_opts => {:full => true}
+      expect(action.includes_full_attributes?).to be true
+    end
+
+    it "should be false if paramable is enabled" do
+      action.dsl.returns :hash, :structure => :user, :structure_opts => {:paramable => true}
+      expect(action.includes_full_attributes?).to be false
+    end
+
+    it "should return false otherwise" do
+      action.dsl.returns :hash, :structure => :user, :structure_opts => {:full => false}
+      expect(action.includes_full_attributes?).to be false
+      action.dsl.returns :hash, :structure => :user, :structure_opts => {}
+      expect(action.includes_full_attributes?).to be false
+    end
+  end
+
+  context "#can_change_expansions?" do
+    it "should return true if the action is fully paramable" do
+      action.dsl.returns :hash, :structure => :user, :structure_opts => {:paramable => true}
+      expect(action.can_change_expansions?).to be true
+    end
+    it "should return true if the action paramable allow expansion changes" do
+      action.dsl.returns :hash, :structure => :user, :structure_opts => {:paramable => {:expansions => true}}
+      expect(action.can_change_expansions?).to be true
+      action.dsl.returns :hash, :structure => :user, :structure_opts => {:paramable => {:expansions => false}}
+      expect(action.can_change_expansions?).to be true
+      action.dsl.returns :hash, :structure => :user, :structure_opts => {:paramable => {:expansions => []}}
+      expect(action.can_change_expansions?).to be true
+    end
+
+    it "should return false otherwise" do
+      action.dsl.returns :hash, :structure => :user, :structure_opts => {}
+      expect(action.can_change_expansions?).to be false
+    end
+  end
+
+  context "#includes_expansion?" do
+    it "should return false if the action's paramable expansions are true" do
+      action.dsl.returns :hash, :structure => :user, :structure_opts => {:paramable => true}
+      expect(action.includes_expansion?(:user)).to be false
+    end
+
+    it "should return true if the action always returns all expansions" do
+      action.dsl.returns :hash, :structure => :user, :structure_opts => {:expansions => true}
+      expect(action.includes_expansion?(:user)).to be true
+    end
+
+    it "should return true if the action's paramable expansions is an array and it includes the expansion" do
+      action.dsl.returns :hash, :structure => :user, :structure_opts => {:paramable => {:expansions => [:user]}}
+      expect(action.includes_expansion?(:user)).to be true
+      expect(action.includes_expansion?(:another)).to be false
+    end
+
+    it "should return true if the action expansions is an array and it includes the expansion" do
+      action.dsl.returns :hash, :structure => :user, :structure_opts => {:expansions => [:user]}
+      expect(action.includes_expansion?(:user)).to be true
+      expect(action.includes_expansion?(:another)).to be false
+    end
+
+    it "should return false otherwise" do
+      action.dsl.returns :hash, :structure => :user
+      expect(action.includes_expansion?(:user)).to be false
+    end
+  end
+
+  context "#available_expansions" do
+    it "should include all the structure's expansions if no array if expansions is provided" do
+      base.dsl.structure :user do
+        expansion :owner
+        expansion :admin
+      end
+      action.dsl.returns :hash, :structure => :user, :structure_opts => {:paramable => true}
+      expect(action.available_expansions).to eq([:owner, :admin])
+    end
+
+    it "should include only listed expansions if an array is set" do
+      action.dsl.returns :hash, :structure => :user, :structure_opts => {:paramable => {:expansions => [:owner]}}
+      expect(action.available_expansions).to eq([:owner])
+    end
+
+    it "should be empty if there's no structure" do
+      action.dsl.returns :hash
+      expect(action.available_expansions).to eq([])
+    end
+  end
+
+  context "dsl#filterable" do
+    before do
+      action.dsl.filterable do
+        attribute :name
+        attribute :user_id, :operators => [:eq, :not_eq, :in, :not_in] do |operator, value, scope|
+          scope.where(:user => User.find_by_id(value) || error('InvalidUser'))
+        end
+      end
+    end
+
+    it "should have an hash of fields" do
+      expect(action.filters).to be_a(Hash)
+      expect(action.filters[:name]).to be_a(Hash)
+      expect(action.filters[:user_id]).to be_a(Hash)
+      expect(action.filters[:user_id][:block]).to be_a(Proc)
+    end
+
+    it "should add a 'filters' param" do
+      expect(action.params[:filters]).to be_a Hash
+    end
+
+    it "should add an error for filter errors" do
+      expect(action.errors['FilterError']).to be_a Hash
+    end
+
+  end
+end

data/spec/specs/base_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'moonrope/base'
+
+describe Moonrope::Base do
+  subject(:base) { Moonrope::Base.new }
+
+  context "the base" do
+    it "should be able to define & return a controller" do
+      base.dsl.controller :users
+      expect(base.controller(:users)).to be_a(Moonrope::Controller)
+    end
+
+    it "should be able to define & return a structure" do
+      base.dsl.structure :user
+      expect(base.structure(:user)).to be_a(Moonrope::Structure)
+    end
+
+    it "should be able to define & return an authenticator" do
+      base.dsl.authenticator :admin
+      expect(base.authenticators[:admin]).to be_a(Moonrope::Authenticator)
+    end
+
+    it "should be able to define & return an authenticator" do
+      base.dsl.shared_action(:find_something) { 1234 }
+      expect(base.shared_actions[:find_something]).to be_a(Proc)
+    end
+
+  end
+end

data/spec/specs/controller_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'moonrope/controller'
+require 'moonrope/base'
+
+describe Moonrope::Controller do
+  context "a controller" do
+    it "should be able to define & return an action" do
+      controller = Moonrope::Controller.new(Moonrope::Base.new, :users) do
+        action :list
+      end
+      expect(controller.action(:list)).to be_a(Moonrope::Action)
+    end
+
+    it "should be able to define & return a before filter" do
+      controller = Moonrope::Controller.new(Moonrope::Base.new, :users) do
+        before {}
+      end
+      expect(controller.befores.size).to eq(1)
+      expect(controller.befores.first).to be_a(Moonrope::BeforeAction)
+    end
+
+    it "should be able to define & return a shared action" do
+      controller = Moonrope::Controller.new(Moonrope::Base.new, :users) do
+        shared_action :example do
+        end
+      end
+      expect(controller.shared_actions.size).to eq(1)
+      expect(controller.shared_actions[:example]).to be_a(Proc)
+    end
+  end
+end

data/spec/specs/param_set_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'moonrope/param_set'
+
+describe Moonrope::ParamSet do
+
+  context "a param set" do
+    subject(:param_set) { Moonrope::ParamSet.new('example' => 'Hello') }
+
+    it "should return values in hash format" do
+      expect(param_set[:example]).to eq('Hello')
+      expect(param_set['example']).to eq('Hello')
+    end
+
+    it "should return values in dot format" do
+      expect(param_set.example).to eq('Hello')
+    end
+
+    it "should be able to say if a param exists or not" do
+      expect(param_set.has?(:example)).to be true
+      expect(param_set.has?('example')).to be true
+      expect(param_set.has?(:unknown)).to be false
+    end
+
+    it "should return a default if one exists and there's no other value" do
+      param_set._defaults = {'fruit' =>'Apple'}
+      expect(param_set.has?(:fruit)).to be true
+      expect(param_set.fruit).to eq 'Apple'
+    end
+  end
+
+end

data/templates/basic/_action_form.erb

@@ -0,0 +1,77 @@
+<p class='tryFormActivate'><a class='tryFormActivate__button' href='#'>Try this request in your browser</a></p>
+<form class='tryForm'>
+  <input type='hidden' name='controller' value='<%= controller.name %>'>
+  <input type='hidden' name='action' value='<%= action.name %>'>
+  <div class='tryForm__header'>
+    <input type='text' id='host' name='host' value='<%= host %>'>
+    /api/
+    <input type='text' id='version' name='version' value='v1' class='v'>
+    /<%= controller.name %>/<%= action.name %>
+  </div>
+
+  <% if action.authenticator_to_use.is_a?(Moonrope::Authenticator) %>
+  <p class='tryForm__heading'>Headers</p>
+  <table class='tryForm__table'>
+    <% for name, options in action.authenticator_to_use.headers %>
+    <tr>
+      <td width="50%"><code><%= name %></code></td>
+      <td width="50%"><input type='text' class='tryForm__tableField headerField' name='<%= name %>'></td>
+    </tr>
+    <% end %>
+  </table>
+  <% end %>
+
+  <% unless action.params.empty? %>
+  <p class='tryForm__heading'>Parameters</p>
+  <table class='tryForm__table'>
+    <% for name, param in action.params %>
+    <tr>
+      <td width="30%"><code><%= name %></code></td>
+      <td width="20%"><%= friendly_type param[:type] %></td>
+      <td width="50%"><input type='text' class='tryForm__tableField paramField' name='<%= name %>' placeholder='<%= param[:default] %>' data-type='<%= param[:type] %>'></td>
+    </tr>
+    <% end %>
+  </table>
+  <% end %>
+
+  <% if action.can_change_full? || action.can_change_expansions? %>
+  <p class='tryForm__heading'>Structures</p>
+  <table class='tryForm__table'>
+    <% if action.can_change_full? %>
+    <tr>
+      <td width="50%">Include extended attributes?</td>
+      <td width="50%">
+        <div class='tryForm__checkbox'>
+          <input type='checkbox' class='tryForm__fullAttrs' name='full' id="full_attrs" <% if action.includes_full_attributes? %>checked='checked'<%end%>>
+          <label for="full_attrs">Yes - include extended attributes</label>
+        </div>
+      </td>
+    </tr>
+    <% end %>
+    <% if action.can_change_expansions? %>
+    <tr>
+      <td width="50%">Include expansions?</td>
+      <td width="50%">
+        <% for expansion in action.available_expansions %>
+          <div class='tryForm__checkbox'>
+            <input type='checkbox' class='tryForm__expansions' name='<%= expansion%>' id="expan_<%= expansion %>" <% if action.includes_expansion?(expansion) %>checked='checked'<%end%>>
+            <label for="expan_<%= expansion %>"><%= expansion %></label>
+          </div>
+        <% end %>
+      </td>
+    </tr>
+    <% end %>
+
+  </table>
+
+  <% end %>
+
+  <p class='tryForm__button'>
+    <button class='tryForm__buttonLink' type='submit'>Make this request</button>
+    <button class='tryForm__buttonLink tryFormCancel' type='button'>Cancel</button>
+  </p>
+
+  <pre class='tryForm__output'>The request output will be shown here...</pre>
+</form>
+
+

data/templates/basic/_errors_table.erb

@@ -0,0 +1,32 @@
+<table class='table errorsTable'>
+  <thead>
+    <tr>
+      <th width="60%">Error</th>
+      <th width="40%">Attributes</th>
+    </tr>
+  </thead>
+  <% for name, error in errors %>
+  <tr>
+    <td>
+      <p>
+        <span class='paramTable__name'><%= name %></span>
+        <% if error[:description] %>
+          <p class='paramTable__description'><%= error[:description] %></p>
+        <% end %>
+      </p>
+    </td>
+    <td>
+      <% if error[:attributes].is_a?(Hash) %>
+      <ul class='errorAttributeList'>
+        <% for name, description in error[:attributes] %>
+        <li>
+          <p class='errorAttributeList__name'><%= name %></p>
+          <p class='errorAttributeList__desc'><%= description %></p>
+        </li>
+        <% end %>
+      </ul>
+      <% end %>
+    </td>
+  </tr>
+  <% end %>
+</table>