moonrope 1.3.3 → 2.0.2

data/templates/basic/authenticator.erb

@@ -0,0 +1,52 @@
+
+<% if authenticator.name == :default %>
+<% set_page_title "Authentication" %>
+<% set_active_nav "authenticator-default" %>
+<h1>Authentication</h1>
+<% else %>
+<% set_page_title "#{humanize(authenticator.name.to_s.capitalize)} Authenticator" %>
+<h1><%= humanize(authenticator.name.to_s.capitalize) %> Authenticator</h1>
+<% set_active_nav "authenticator-#{authenticator.name.to_s}" %>
+<% end %>
+
+<p class='text'>
+  <%= authenticator.description %>
+</p>
+
+<h2>Authentication Headers</h2>
+<p class='text'>
+  The following headers are used to identify yourself to the API client. These should be
+  sent as standard HTTP headers with any API request.
+</p>
+<table class='table paramTable'>
+  <thead>
+    <tr>
+      <th width="60%">Header</th>
+      <th width="40%">Example</th>
+    </tr>
+  </thead>
+  <% for name, options in authenticator.headers %>
+  <tr>
+    <td>
+      <p>
+        <span class='paramTable__name'><%= name %></span>
+      </p>
+      <% if options[:description] %>
+        <p class='paramTable__description'><%= options[:description] %></p>
+      <% end %>
+    </td>
+    <td><%= options[:eg] || options[:example] %> </td>
+  </tr>
+  <% end %>
+</table>
+
+<h2>Errors</h2>
+<p class='text'>
+  The errors listed below may be raised if any issues occur when verifying your
+  identity with the API.
+</p>
+<% if authenticator.errors.empty? %>
+  <p><em>There are no errors which can be raised.</em></p>
+<% else %>
+  <%= partial "errors_table", :errors => authenticator.errors %>
+<% end %>

data/templates/basic/controller.erb

@@ -0,0 +1,20 @@
+<% set_page_title controller.friendly_name || controller.name %>
+<% set_active_nav "controller-#{controller.name}" %>
+<h1><%= controller.friendly_name || controller.name %></h1>
+<% if controller.description %>
+  <p class='text'><%= controller.description %></p>
+<% end %>
+<h2>Action</h2>
+<p class='text'>
+  The following actions are available. Choose from the list below
+  to view full details of how to access them.
+</p>
+<ul class='standardList'>
+  <% for action in controller.actions.values.select { |a| a.doc != false } %>
+  <li>
+    <a class='link' href='<%= path("controllers/#{action.controller.name}/#{action.name}") %>'><%= action.title || action.name %></a>
+    <p class='apiURL'><span><%= full_prefix %>/</span><b><%= action.controller.name %>/<%= action.name %></b></p>
+    <% if action.description %><p class='meta'><%= action.description %></p><% end %>
+  </li>
+  <% end %>
+</ul>

data/templates/basic/index.erb

@@ -0,0 +1,114 @@
+<% set_page_title "Welcome" %>
+<% set_active_nav "home" %>
+<h1>Welcome to our API documentation</h1>
+<p class='text'>
+  From here you can browse the full documentation for our HTTP
+  API. Our API is split into sections which you can browse using
+  the menu on the right. If you have any questions, you can
+  <a href='#'>contact our team</a> and we'll be happy to help out.
+</p>
+<p class='text'>
+  Before you get started, take a few minutes to review the
+  information below about how to interact with our API. It includes
+  information about how to send requests, what response data is
+  sent in and how to handle errors.
+</p>
+
+<h2>Making requests</h2>
+<p class='text'>
+  Our API works over the HTTP protocol with JSON. It is implemented
+  in an RPC-like manner and everything you can do with the API has
+  its own <em>action</em>.
+</p>
+<p class='text'>
+  All HTTP requests must be made over HTTPS to the URL shown on the
+  action's page in this documentation. All responses you receive from
+  the API will be returned in JSON. Requests should be made using the
+  <code>POST</code> method with any parameters encoded as JSON in the
+  body of the request.
+</p>
+
+<h2>Receiving responses</h2>
+<p class='text'>
+  All responses will be returned to you encoded as JSON. You will always
+  receive a hash as the response which will look like the JSON below:
+</p>
+<pre class='code'>
+{
+  <span class='jsonKey'>"status"</span>:<span class='jsonString'>"success"</span>,
+  <span class='jsonKey'>"time"</span>:<span class='jsonString'>0.123</span>,
+  <span class='jsonKey'>"flags"</span>:{
+    <span class='jsonComment'>... additional information about the request ...</span>
+  },
+  <span class='jsonKey'>"data"</span>:{
+    <span class='jsonComment'>... the data returned from the action ...</span>
+  }
+}
+</pre>
+<p class='text'>
+  The <b>status</b> attribute will give you can indication about whether the
+  request was performed successfully or whether an error occurred. Values which
+  may be returned are shown below:
+</p>
+<ul class='standardList'>
+  <li>
+    <code>success</code> - this means that the request completed successfully
+    and returned the data that was expected.
+  </li>
+  <li>
+    <code>parameter-error</code> - the parameters provided for the action are
+    not valid and should be revised.
+  </li>
+  <li>
+    <code>error</code> - an error occurred that didn't fit into the above categories.
+    This will be accompanied with an error code, a descriptive message and further
+    attributes which may be useful. The actual potential errors for each action are
+    shown in the documentation.
+  </li>
+</ul>
+<p class='text'>
+  The <b>time</b> attribute shows how long the request took to complete on the
+  server side.
+</p>
+<p class='text'>
+  The <b>flags</b> attribute contains a hash of additional attributes
+  which are relevant to your request. For example, if you receive an array of data
+  it may be paginated and this pagination data will be returned in this
+  hash.
+</p>
+<p class='text'>
+  The <b>data</b> attribute contains the result of your request. Depending on the
+  status, this will either contain the data requested or details of any
+  error which has occurred.
+</p>
+<h3>A note about HTTP status code</h3>
+<p class='text'>
+  The API does not generally use HTTP status codes to return information
+  about the outcome of a request. There are two supported statuses with
+  the API:
+</p>
+<ul class='standardList'>
+  <li>
+    <code>200 OK</code> - This is the code you'll usually receive.
+    It indicates that the response was successfully delivered and
+    returned to our service (although does not nessesary mean that
+    the action you were expecting was successful). Further status
+    information will be provided in the <code>status</code> attribute
+    on your response body.
+  </li>
+  <li>
+    <code>301 Moved Permanently</code> or <code>308 Permanent Redirect</code> -
+    This means that the API request should be sent to an alternative
+    URL. This may just mean you need to send your request using <code>https</code>
+    rather than <code>http</code> as the protocol.
+  </li>
+  <li>
+    <code>500 Internal Server Error</code> - This will be returned
+    when an error occurred within the API itself. This was not
+    anticipated by us and should be reported to us.
+  </li>
+  <li>
+    <code>503 Service Unavailable</code> - This will be returned if
+    API is currently unavailable for maintenance or other issue.
+  </li>
+</ul>

data/templates/basic/layout.erb

@@ -0,0 +1,46 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title><%= page_title %> - API Documentation</title>
+    <link href='https://fonts.googleapis.com/css?family=Lato:400,700,900' rel='stylesheet' type='text/css'>
+    <link href='https://fonts.googleapis.com/css?family=Droid+Sans+Mono' rel='stylesheet' type='text/css'>
+    <link rel="stylesheet" href="<%= asset_path('reset.css') %>">
+    <link rel="stylesheet" href="<%= asset_path('style.css') %>">
+  </head>
+  <body>
+    <section class='sidebarBackground'></section>
+    <section class="sidebar">
+      <nav>
+        <ul>
+          <li>
+            <a href='<%= path(:root) %>' class="<%= active_nav == 'home' ? 'active' : '' %>">
+              Home
+            </a>
+          </li>
+          <% base.authenticators.select { |k,v| v.friendly_name }.each do |id, authenticator| %>
+          <li>
+            <a href='<%= path('authenticators/' + id.to_s) %>' class="<%= active_nav == "authenticator-" + id.to_s ? 'active' : '' %>">
+              <%= authenticator.friendly_name %>
+            </a>
+          </li>
+          <% end %>
+          <% for controller in base.controllers.select { |c| c.doc != false }.sort_by { |c| c.name.to_s } %>
+          <li>
+            <a href='<%= path("controllers/#{controller.name}") %>' class="<%= active_nav == "controller-#{controller.name}" ? 'active' : '' %>">
+              <%= controller.friendly_name || controller.name %>
+            </a>
+          </li>
+          <% end %>
+        </ul>
+      </nav>
+    </section>
+    <section class='content'>
+      <%= body %>
+    </section>
+    <footer class='footer'>
+      <p>Generated by Moonrope at <%= Time.now.strftime("%H:%M on %A %e %B %Y") %> for <%= git_version[0,6] %></p>
+    </footer>
+    <script src='https://code.jquery.com/jquery-1.12.0.min.js'></script>
+    <script src='<%= asset_path('try.js') %>'></script>
+  </body>
+</html>

data/templates/basic/structure.erb

@@ -0,0 +1,23 @@
+<% set_page_title "#{humanize(structure.name.capitalize)} Structure" %>
+
+<h1><%= humanize(structure.name.capitalize) %> Structure</h1>
+
+<h2>Base Attributes</h2>
+<%= partial 'structure_attributes_list', :structure => structure, :attributes => structure.attributes[:basic].select { |a| a.doc != false } %>
+
+<% full_attrs = structure.attributes[:full].select { |a| a.doc != false } %>
+<% unless full_attrs.empty? %>
+<h2>Extended Attributes</h2>
+<%= partial 'structure_attributes_list', :structure => structure, :attributes => full_attrs %>
+<% end %>
+
+<% if !structure.attributes[:expansion].empty? || !structure.expansions.empty? %>
+<h2>Expansions</h2>
+<p class='text'>
+  Expansions are embedded structures of other objects that are related to the structure
+  that you're viewing. Which expansions are returned by a specific action are shown on that
+  action's documentation however some actions allow you to choose which expansions are
+  returned.
+</p>
+<%= partial 'structure_attributes_list', :structure => structure, :attributes => structure.attributes[:expansion], :expansions => structure.expansions.select { |k,v| v[:doc] != false} %>
+<% end %>

data/test/test_helper.rb

@@ -0,0 +1,81 @@
+require 'test/unit'
+require 'rack/test'
+require 'moonrope'
+
+class Test::Unit::TestCase
+
+  private
+
+  def make_rack_env_hash(path, params = {}, other_env = {})
+    request = Rack::Test::Session.new(nil)
+    request.send :env_for, path, {:params => params, :method => 'POST'}.merge(other_env)
+  end
+
+end
+
+#
+# A fake base object for models
+#
+class ModelBase
+  def initialize(attributes = {})
+    attributes.each do |key, value|
+      instance_variable_set("@#{key}", value)
+    end
+  end
+end
+
+class Animal < ModelBase
+  attr_accessor :id, :name, :color, :user
+end
+
+class User < ModelBase
+  attr_accessor :id, :username, :private_code, :admin
+  def animals
+    @animals ||= []
+  end
+end
+
+class UserWithUnderscore < User
+  class << self
+    def name
+      s = Struct.new(:underscore, :to_s).new
+      s.to_s = 'User'
+      s.underscore = 'user'
+      s
+    end
+  end
+end
+
+#
+# A fake request class for use in some tests
+#
+class FakeRequest
+
+  def initialize(options = {})
+    @options = options
+  end
+
+  def params
+    @params ||= Moonrope::ParamSet.new(@options[:params] || {})
+  end
+
+  def version
+    @options[:version]
+  end
+
+  def identity
+    @options[:identity]
+  end
+
+  def action
+    nil
+  end
+
+end
+
+#
+# Require all tests
+#
+Dir[File.expand_path("../tests/**/*.rb", __FILE__)].each do |filename|
+  require filename
+end

data/test/tests/action_access_test.rb

@@ -0,0 +1,63 @@
+class ActionAccessTest < Test::Unit::TestCase
+
+  def setup
+    @base = Moonrope::Base.new do
+      authenticator :default do
+        rule :default, "AccessDenied" do
+          identity == :admin
+        end
+
+        rule :anonymous, "MustBeAnonymous" do
+          identity.nil?
+        end
+      end
+    end
+    @controller = Moonrope::Controller.new(@base, :users)
+  end
+
+  def test_action_uses_default_access_rule_by_default
+    action = Moonrope::Action.new(@controller, :list)
+    # no authentication has been provided
+    assert_equal false, action.check_access
+    # authentication which is not correct
+    authenticated_request = FakeRequest.new(:identity => :dave)
+    assert_equal false, action.check_access(authenticated_request)
+    # authentication which is correct
+    authenticated_request = FakeRequest.new(:identity => :admin)
+    assert_equal true, action.check_access(authenticated_request)
+  end
+
+  def test_action_can_use_controller_rule
+    controller = Moonrope::Controller.new(@base, :users) do
+      access_rule :anonymous
+    end
+    action = Moonrope::Action.new(controller, :list)
+    # anonymous is ok
+    assert_equal true, action.check_access
+    # with a user is not
+    authenticated_request = FakeRequest.new(:identity => :dave)
+    assert_equal false, action.check_access(authenticated_request)
+  end
+
+  def test_action_can_use_action_rule
+    action = Moonrope::Action.new(@controller, :list) do
+      access_rule :anonymous
+    end
+    # anonymous is ok
+    assert_equal true, action.check_access
+    # with a user is not
+    authenticated_request = FakeRequest.new(:identity => :dave)
+    assert_equal false, action.check_access(authenticated_request)
+  end
+
+  def test_that_invalid_rule_names_raise_errors
+    action = Moonrope::Action.new(@controller, :list) do
+      access_rule :missing
+    end
+    # anonymous is ok
+    assert_raises Moonrope::Errors::MissingAccessRule do
+      action.check_access
+    end
+  end
+
+end

data/test/tests/actions_test.rb

@@ -0,0 +1,524 @@
+class ActionsTest < Test::Unit::TestCase
+
+  def setup
+    @base = Moonrope::Base.new
+    @controller = Moonrope::Controller.new(@base, :users)
+  end
+
+  def test_basic_definition
+    action = Moonrope::Action.new(@controller, :list) do
+      description "An example action with a description"
+    end
+    assert action.is_a?(Moonrope::Action)
+    assert_equal :list, action.name
+    assert action.description.is_a?(String)
+    assert action.description.length > 0
+  end
+
+  def test_defining_params
+    action = Moonrope::Action.new(@controller, :list) do
+      param :page
+      param :limit
+    end
+    assert action.params.is_a?(Hash)
+    assert_equal [:page, :limit], action.params.keys
+    assert action.params.values.all? { |p| p.is_a?(Hash) }
+  end
+
+  def test_using_shares
+    controller = Moonrope::Controller.new(@base, :users) do
+      shared_action :user_properties do
+        error 'InvalidUsername', "Some description"
+        param :username, "Blah"
+        param :first_name
+      end
+
+      action :create do
+        use :user_properties
+        param :last_name
+      end
+    end
+
+    action = controller / :create
+    assert_equal(Hash, action.params.class)
+    assert_equal(Hash, action.params[:username].class)
+    assert_equal("Blah", action.params[:username][:description])
+    assert_equal(Hash, action.errors['InvalidUsername'].class)
+  end
+
+  def test_action
+    action = Moonrope::Action.new(@controller, :list) do
+      action { true }
+    end
+    assert action.actions.is_a?(Array)
+    assert action.actions.first.is_a?(Proc)
+    assert_equal true, action.actions.first.call
+  end
+
+  def test_calling_actions
+    action = Moonrope::Action.new(@controller, :list) do
+      action { [1,2,3,4] }
+    end
+    assert result = action.execute
+    assert result.is_a?(Moonrope::ActionResult)
+    assert_equal 'success', result.status
+    assert_equal [1,2,3,4], result.data
+    assert_equal Float, result.time.class
+    assert_equal({}, result.flags)
+    assert_equal({}, result.headers)
+  end
+
+  def test_structure_method_can_be_called
+    # Create a new structure to test with
+    user_structure = Moonrope::Structure.new(@base, :user) do
+      basic { {:id => o.id, :username => o.username}}
+    end
+
+    # Create an action which uses this structure
+    action = Moonrope::Action.new(@controller, :list) do
+      action do
+        user = User.new(:id => 1, :username => 'adamcooke')
+        structure user_structure, user
+      end
+    end
+
+    # Test the structure was returned
+    assert result = action.execute
+    assert result.is_a?(Moonrope::ActionResult), "result is not a ActionResult"
+    assert_equal 1, result.data[:id]
+    assert_equal 'adamcooke', result.data[:username]
+  end
+
+  def test_structure_methods_can_be_called_with_opts_from_dsl
+    # Create a new structure to test with
+    user_structure = Moonrope::Structure.new(@base, :user) do
+      basic :id
+      full :username
+    end
+
+    # Create an action which uses this structure
+    action = Moonrope::Action.new(@controller, :list) do
+      returns :hash, :structure => :user, :structure_opts => {:full => true}
+      action do
+        user = User.new(:id => 1, :username => 'adamcooke')
+        structure user_structure, user, :return => true
+      end
+    end
+
+    # Test the structure was returned
+    assert result = action.execute
+    assert_equal 1, result.data[:id]
+    assert_equal 'adamcooke', result.data[:username]
+  end
+
+  def test_default_params
+    action = Moonrope::Action.new(@controller, :default_params_test) do
+      param :page, :default => 1234
+      param :limit
+      action { {:page => params.page, :limit => params.limit} }
+    end
+    result = action.execute
+    assert_equal({'page' => 1234}, action.default_params)
+    assert_equal 1234, result.data[:page]
+    assert_equal nil, result.data[:limit]
+  end
+
+  def test_before_filters_are_executed
+    controller = Moonrope::Controller.new(@base, :users) do
+      before { set_flag :before_all, true }
+      before(:other) { set_flag :before_other, true }
+      before(:list) { set_flag :before_list, true }
+      before(:list, :potato) { set_flag :before_list_and_potato, true }
+    end
+
+    action = Moonrope::Action.new(controller, :list) do
+      action { true }
+    end
+
+    assert result = action.execute
+    assert_equal true, result.flags[:before_all]
+    assert_equal true, result.flags[:before_list]
+    assert_equal true, result.flags[:before_list_and_potato]
+    assert_equal nil, result.flags[:before_other]
+  end
+
+  def test_result_can_be_expressed_as_a_hash
+    action = Moonrope::Action.new(@controller, :list) do
+      action { [1,2,3] }
+    end
+    assert result = action.execute
+    assert hash = result.to_hash
+    assert hash.is_a?(Hash), "result.to_hash does not return a hash"
+    assert_equal 'success', hash[:status]
+    assert hash[:time].is_a?(Float)
+    assert hash[:flags].is_a?(Hash)
+  end
+
+  def test_result_can_be_expressed_as_json
+    action = Moonrope::Action.new(@controller, :list) do
+      action { [1,2,3] }
+    end
+    assert result = action.execute
+    assert json = result.to_json
+    assert json.is_a?(String)
+  end
+
+  def test_that_param_validation_happens_on_executin
+    action = Moonrope::Action.new(@controller, :list) do
+      param :page, "Page number", :required => true
+      action { [1,2,3] }
+    end
+    assert result = action.execute
+    assert_equal 'parameter-error', result.status
+  end
+
+  def test_actions_params_can_be_validated_for_presence
+    action = Moonrope::Action.new(@controller, :list) do
+      param :page, "Page number", :required => true
+    end
+
+    # request without the param
+    assert_raises Moonrope::Errors::ParameterError do
+      action.validate_parameters(Moonrope::ParamSet.new)
+    end
+
+    # request with the param
+    assert_equal true, action.validate_parameters(Moonrope::ParamSet.new('page' => 1))
+  end
+
+  def test_actions_params_can_be_validated_for_type
+    action = Moonrope::Action.new(@controller, :list) do
+      param :page, "Page number", :type => Integer
+    end
+
+    # request with a string valuee
+    assert_raises Moonrope::Errors::ParameterError do
+      action.validate_parameters(Moonrope::ParamSet.new('page' => 'stringy'))
+    end
+
+    # request with an integer value
+    assert_equal true, action.validate_parameters(Moonrope::ParamSet.new('page' => 1))
+
+    # request with an nil value
+    assert_equal true, action.validate_parameters(Moonrope::ParamSet.new('page' => nil))
+  end
+
+  def test_actions_params_can_be_validated_for_boolean_types
+    action = Moonrope::Action.new(@controller, :list) do
+      param :hungry, "Are you hungry", :type => :boolean
+    end
+
+    # request with a string valuee
+    assert_raises Moonrope::Errors::ParameterError do
+      action.validate_parameters(Moonrope::ParamSet.new('hungry' => 'randomstring'))
+    end
+
+    assert_raises Moonrope::Errors::ParameterError do
+      action.validate_parameters(Moonrope::ParamSet.new('hungry' => 2))
+    end
+
+    assert_raises Moonrope::Errors::ParameterError do
+      action.validate_parameters(Moonrope::ParamSet.new('hungry' => 123))
+    end
+
+    # request with an boolean value
+    assert_equal true, action.validate_parameters(Moonrope::ParamSet.new('hungry' => true))
+    assert_equal true, action.validate_parameters(Moonrope::ParamSet.new('hungry' => false))
+
+    # request with string values
+    set = Moonrope::ParamSet.new('hungry' => 'true')
+    assert_equal true, action.validate_parameters(set)
+    assert_equal true, set.hungry
+
+    set = Moonrope::ParamSet.new('hungry' => 'false')
+    assert_equal true, action.validate_parameters(set)
+    assert_equal false, set.hungry
+
+    # request with an numeric values
+    assert_equal true, action.validate_parameters(Moonrope::ParamSet.new('hungry' => 1))
+    assert_equal true, action.validate_parameters(Moonrope::ParamSet.new('hungry' => 0))
+
+    # request with nil vlaues
+    assert_equal true, action.validate_parameters(Moonrope::ParamSet.new('hungry' => nil))
+  end
+
+  def test_actions_params_can_have_symbols_as_types_which_do_nothing
+    action = Moonrope::Action.new(@controller, :list) do
+      param :created_at, "Timestamp", :type => :timestamp
+    end
+    assert_equal true, action.validate_parameters(Moonrope::ParamSet.new('created_at' => 'something'))
+    assert_equal true, action.validate_parameters(Moonrope::ParamSet.new('created_at' => nil))
+  end
+
+  def test_actions_params_can_be_validated_for_regex_matches
+    action = Moonrope::Action.new(@controller, :list) do
+      param :username, "Username", :regex => /\A[a-z]+\z/
+    end
+    # request with a nil value
+    assert_equal true, action.validate_parameters(Moonrope::ParamSet.new)
+
+    # request with a matching value
+    assert_equal true, action.validate_parameters(Moonrope::ParamSet.new('username' => 'adam'))
+
+    # request with a string valuee
+    assert_raises Moonrope::Errors::ParameterError do
+      action.validate_parameters(Moonrope::ParamSet.new('username' => 'invalid-username1234'))
+    end
+  end
+
+  def test_actions_params_can_be_validated_for_option_matches
+    action = Moonrope::Action.new(@controller, :list) do
+      param :sort_by, :options => ["name", "age"]
+    end
+    # request with a nil value
+    assert_equal true, action.validate_parameters(Moonrope::ParamSet.new)
+
+    # request with a matching value
+    assert_equal true, action.validate_parameters(Moonrope::ParamSet.new('sort_by' => 'name'))
+
+    # request with a string valuee
+    assert_raises Moonrope::Errors::ParameterError do
+      action.validate_parameters(Moonrope::ParamSet.new('sort_by' => 'somethingelse'))
+    end
+  end
+
+
+  def test_actions_can_raise_errors
+    action = Moonrope::Action.new(@controller, :list) do
+      action do
+        error :not_found, "Something wasn't found"
+      end
+    end
+    assert result = action.execute
+    assert_equal "not-found", result.status
+    assert_equal({:message => "Something wasn't found"}, result.data)
+  end
+
+  def test_actions_can_raise_structured_errors
+    action = Moonrope::Action.new(@controller, :list) do
+      action do
+        structured_error 'feature-disabled', "The feature you have requested is not currently available for this resource.", :number => 1000
+      end
+    end
+    assert result = action.execute
+    assert_equal "error", result.status
+    assert_equal("feature-disabled", result.data[:code])
+    assert_equal("The feature you have requested is not currently available for this resource.", result.data[:message])
+    assert_equal(1000, result.data[:number])
+  end
+
+  def test_actions_can_raise_structured_errors_through_the_error_method
+    action = Moonrope::Action.new(@controller, :list) do
+      action do
+        error :structured_error, 'feature-disabled', "The feature you have requested is not currently available for this resource."
+      end
+    end
+    assert result = action.execute
+    assert_equal "error", result.status
+    assert_equal("feature-disabled", result.data[:code])
+    assert_equal("The feature you have requested is not currently available for this resource.", result.data[:message])
+  end
+
+  def test_actions_can_raise_structured_errors_through_the_error_method_using_a_string
+    action = Moonrope::Action.new(@controller, :list) do
+      action do
+        error 'feature-disabled', "The feature you have requested is not currently available for this resource."
+      end
+    end
+    assert result = action.execute
+    assert_equal "error", result.status
+    assert_equal("feature-disabled", result.data[:code])
+    assert_equal("The feature you have requested is not currently available for this resource.", result.data[:message])
+  end
+
+  def test_actions_can_raise_structured_errors_referencing_action_errors
+    action = Moonrope::Action.new(@controller, :list) do
+      error "NoWidgetsFound", "No widgets were found with level {widget_level}"
+      action do
+        error 'NoWidgetsFound', :widget_level => 42
+      end
+    end
+    assert result = action.execute
+    assert_equal "error", result.status
+    assert_equal "NoWidgetsFound", result.data[:code]
+    assert_equal "No widgets were found with level 42", result.data[:message]
+    assert_equal 42, result.data[:widget_level]
+  end
+
+  class DummyError < StandardError; end
+
+  def test_catching_external_errors
+    @controller.base.register_external_error DummyError do |exp, res|
+      res.status = 'dummy-error'
+      res.data = {:message => exp.message}
+    end
+
+    action = Moonrope::Action.new(@controller, :list) do
+      action do
+        raise DummyError, "Something happened"
+      end
+    end
+
+    assert result = action.execute
+    assert_equal 'dummy-error', result.status
+    assert_equal({:message => 'Something happened'}, result.data)
+  end
+
+  class DummyError2 < StandardError; end
+
+  def test_non_defined_errors_are_raised
+    action = Moonrope::Action.new(@controller, :list) do
+      action do
+        raise DummyError2, "Something happened"
+      end
+    end
+    assert_raises(DummyError2) { action.execute }
+  end
+
+  def test_can_change_full_attribute
+    # can't change when no ops
+    action = Moonrope::Action.new(@controller, :list) do
+      returns :hash, :structure => :animal
+    end
+    assert_equal(false, action.can_change_full?)
+
+    # can change when paramable is true
+    action = Moonrope::Action.new(@controller, :list) do
+      returns :hash, :structure => :animal, :structure_opts => {:paramable => true}
+    end
+    assert_equal(true, action.can_change_full?)
+
+    # can change when specified
+    action = Moonrope::Action.new(@controller, :list) do
+      returns :hash, :structure => :animal, :structure_opts => {:paramable => {:full => true}}
+    end
+    assert_equal(true, action.can_change_full?)
+
+    # can't change when not specified
+    action = Moonrope::Action.new(@controller, :list) do
+      returns :hash, :structure => :animal, :structure_opts => {:paramable => {}}
+    end
+    assert_equal(false, action.can_change_full?)
+  end
+
+  def test_includes_full_attributes
+    #not included by default
+    action = Moonrope::Action.new(@controller, :list) do
+      returns :hash, :structure => :animal
+    end
+    assert_equal(false, action.includes_full_attributes?)
+
+    # not included when paramable is just true
+    action = Moonrope::Action.new(@controller, :list) do
+      returns :hash, :structure => :animal, :structure_opts => {:paramable => true}
+    end
+    assert_equal(false, action.includes_full_attributes?)
+
+    # included when paramable sets the default to true
+    action = Moonrope::Action.new(@controller, :list) do
+      returns :hash, :structure => :animal, :structure_opts => {:paramable => {:full => true}}
+    end
+    assert_equal(true, action.includes_full_attributes?)
+
+    # included when it's full anyway
+    action = Moonrope::Action.new(@controller, :list) do
+      returns :hash, :structure => :animal, :structure_opts => {:full => true}
+    end
+    assert_equal(true, action.includes_full_attributes?)
+  end
+
+
+  def test_can_change_expansions_attribute
+    # can't change when no ops
+    action = Moonrope::Action.new(@controller, :list) do
+      returns :hash, :structure => :animal
+    end
+    assert_equal(false, action.can_change_expansions?)
+
+    # can change when paramable is true
+    action = Moonrope::Action.new(@controller, :list) do
+      returns :hash, :structure => :animal, :structure_opts => {:paramable => true}
+    end
+    assert_equal(true, action.can_change_expansions?)
+
+    # can change when specified
+    action = Moonrope::Action.new(@controller, :list) do
+      returns :hash, :structure => :animal, :structure_opts => {:paramable => {:expansions => true}}
+    end
+    assert_equal(true, action.can_change_expansions?)
+
+    # can't change when not specified
+    action = Moonrope::Action.new(@controller, :list) do
+      returns :hash, :structure => :animal, :structure_opts => {:paramable => {}}
+    end
+    assert_equal(false, action.can_change_expansions?)
+  end
+
+  def test_includes_expansion
+    #not included by default
+    action = Moonrope::Action.new(@controller, :list) do
+      returns :hash, :structure => :animal
+    end
+    assert_equal(false, action.includes_expansion?(:blah))
+
+    # not included when paramable is just true
+    action = Moonrope::Action.new(@controller, :list) do
+      returns :hash, :structure => :animal, :structure_opts => {:paramable => true}
+    end
+    assert_equal(false, action.includes_expansion?(:blah))
+
+    # included when paramable sets the default to true
+    action = Moonrope::Action.new(@controller, :list) do
+      returns :hash, :structure => :animal, :structure_opts => {:paramable => {:expansions => true}}
+    end
+    assert_equal(true, action.includes_expansion?(:blah))
+
+    # included when it's expansions anyway
+    action = Moonrope::Action.new(@controller, :list) do
+      returns :hash, :structure => :animal, :structure_opts => {:expansions => true}
+    end
+    assert_equal(true, action.includes_expansion?(:blah))
+
+    # included when expansions is an array
+    action = Moonrope::Action.new(@controller, :list) do
+      returns :hash, :structure => :animal, :structure_opts => {:expansions => [:blah]}
+    end
+    assert_equal(true, action.includes_expansion?(:blah))
+    assert_equal(false, action.includes_expansion?(:another))
+
+    # included when paramable expansions is an array
+    action = Moonrope::Action.new(@controller, :list) do
+      returns :hash, :structure => :animal, :structure_opts => {:paramable => {:expansions => [:blah]}}
+    end
+    assert_equal(true, action.includes_expansion?(:blah))
+    assert_equal(false, action.includes_expansion?(:another))
+  end
+
+  def test_available_expansions_array_on_actions
+    # if an array is provided, it should return the items in the array
+    action = Moonrope::Action.new(@controller, :list) do
+      returns :hash, :structure => :animal, :structure_opts => {:paramable => {:expansions => [:user]}}
+    end
+    assert_equal([:user], action.available_expansions)
+  end
+
+  def test_that_param_can_copy_data_from_structures
+    base = Moonrope::Base.new do
+      structure :user do
+        basic :username, "The username for the user", :type => String, :eg => 123
+      end
+
+      controller :users do
+        action :save do
+          param :username, :from_structure => :user
+        end
+      end
+    end
+
+    action = base/:users/:save
+    assert_equal "The username for the user", action.params[:username][:description]
+    assert_equal String, action.params[:username][:type]
+  end
+
+
+end