moonrope 1.3.3 → 2.0.2

data/lib/moonrope/structure.rb

@@ -1,3 +1,5 @@
+require 'moonrope/dsl/structure_dsl'
+
 module Moonrope
   class Structure
 
@@ -22,6 +24,9 @@ module Moonrope
     # @return [Hash] attributes which should be included in this structure
     attr_reader :attributes
 
+    # @return [Bool] should this structure be documented
+    attr_accessor :doc
+
     #
     # Initialize a new structure
     #
@@ -37,6 +42,15 @@ module Moonrope
       @dsl.instance_eval(&block) if block_given?
     end
 
+    #
+    # Return details for the given attribute
+    #
+    def attribute(name)
+      @attributes[:basic].select { |p| p.name == name }.first ||
+      @attributes[:full].select { |p| p.name == name }.first ||
+      @attributes[:expansion].select { |p| p.name == name }.first
+    end
+
     #
     # Return a hash for this struture
     #
@@ -46,7 +60,7 @@ module Moonrope
     #
     def hash(object, options = {})
       # Set up an environment
-      environment = EvalEnvironment.new(base, options[:request], :o => object)
+      environment = EvalEnvironment.new(base, options[:request], options[:request] ? options[:request].action : nil, :o => object)
 
       # Set a new hash
       hash = Hash.new
@@ -71,19 +85,36 @@ module Moonrope
         end
       end
 
+      if options[:attributes]
+        hash.reject! { |k,v| !options[:attributes].include?(k.to_sym) }
+      end
+
       # Add expansions
       if options[:expansions]
 
+        if options[:expansions].is_a?(Array)
+          expansions_to_include = options[:expansions].each_with_object({}) do |expan, hash|
+            if expan.is_a?(Symbol) || expan.is_a?(String)
+              hash[expan.to_sym] = nil
+            elsif expan.is_a?(Hash)
+              hash[expan.first.first.to_sym] = expan.first.last
+            end
+          end
+        else
+          expansions_to_include = true
+        end
+
         # Add structured expansions
         @attributes[:expansion].each do |attribute|
-          next if options[:expansions].is_a?(Array) && !options[:expansions].include?(attribute.name.to_sym)
-          DeepMerge.deep_merge! hash_for_attributes([attribute], object, environment), hash
+          next if expansions_to_include.is_a?(Hash) && !expansions_to_include.keys.include?(attribute.name.to_sym)
+          DeepMerge.deep_merge! hash_for_attributes([attribute], object, environment, :structure_opts => expansions_to_include.is_a?(Hash) && expansions_to_include[attribute.name.to_sym]), hash
         end
 
         # Add the expansions
         expansions.each do |name, expansion|
           next if options[:expansions].is_a?(Array) && !options[:expansions].include?(name.to_sym)
-          DeepMerge.deep_merge!({name.to_sym => environment.instance_eval(&expansion)}, hash)
+          next unless check_conditions(environment, expansion[:conditions])
+          DeepMerge.deep_merge!({name.to_sym => environment.instance_eval(&expansion[:block])}, hash)
         end
       end
 
@@ -91,25 +122,69 @@ module Moonrope
       hash
     end
 
+    #
+    # Return an array of all expansions which are available on this structure
+    #
+    def all_expansions
+      @attributes[:expansion].map(&:name) + expansions.keys
+    end
+
+    #
+    # Return the description for a given condition hash
+    #
+    def description_for_condition(condition)
+      if condition[:authenticator] && condition[:access_rule]
+        if authenticator = base.authenticators[condition[:authenticator]]
+          if access_rule = authenticator.rules[condition[:access_rule]]
+            access_rule[:description]
+          end
+        end
+      else
+        condition[:description]
+      end
+    end
+
     private
 
+    #
+    # Call all conditions provided and return whether they pass or not
+    #
+    def check_conditions(environment, conditions)
+      conditions.each do |condition|
+        if condition[:block]
+          unless environment.instance_eval(&condition[:block])
+            return false
+          end
+        elsif condition[:authenticator] && condition[:access_rule]
+          if authenticator = base.authenticators[condition[:authenticator]]
+            if access_rule = authenticator.rules[condition[:access_rule]]
+              # If we have an authenticator and access rule, use the access rule
+              # block with this environment to determine if we should include the
+              # given block or not.
+              unless environment.instance_exec(self, &access_rule[:block])
+                return false
+              end
+            else
+              raise Moonrope::Errors::MissingAccessRule, "The rule '#{condition[:access_rule]}' was not found on '#{authenticator.name}' authenticator"
+            end
+          else
+            raise Moonrope::Errors::MissingAuthenticator, "The authentication '#{condition[:authenticator]}' was not found"
+          end
+        end
+      end
+      true
+    end
+
     #
     # Return a returnable hash for a given set of structured fields.
     #
-    def hash_for_attributes(attributes, object, environment)
+    def hash_for_attributes(attributes, object, environment, value_options = {})
       return {} unless attributes.is_a?(Array)
       Hash.new.tap do |hash|
         attributes.each do |attribute|
 
           unless attribute.conditions.empty?
-            matched = false
-            attribute.conditions.each do |condition|
-              if !environment.instance_eval(&condition)
-                matched = true
-                break
-              end
-            end
-            if matched
+            unless check_conditions(environment, attribute.conditions)
               # Skip this item because a condition didn't evaluate
               # to true.
               next
@@ -121,9 +196,11 @@ module Moonrope
           elsif attribute.value
             value = attribute.value
           else
-            value = value_for_attribute(object, environment, attribute)
+            value = value_for_attribute(object, environment, attribute, value_options)
           end
 
+          value = attribute.mutate(value)
+
           if attribute.groups.empty?
             hash[attribute.name] = value
           else
@@ -144,14 +221,19 @@ module Moonrope
     #
     # Return a value for a structured field.
     #
-    def value_for_attribute(object, environment,  attribute)
-      value = object.send(attribute.source_attribute)
+    def value_for_attribute(object, environment, attribute, options = {})
+      if attribute.source_attribute.is_a?(Proc)
+        value = environment.instance_eval(&attribute.source_attribute)
+      else
+        value = object.send(attribute.source_attribute)
+      end
+
       if value && attribute.structure
         # If a structure is required, lookup the desired structure and set the
         # hash value as appropriate.
         if structure = self.base.structure(attribute.structure)
-          structure_opts = attribute.structure_opts || {}
-          if value.respond_to?(:map)
+          structure_opts = options[:structure_opts] || attribute.structure_opts || {}
+          if value.is_a?(Enumerable) && value.respond_to?(:map)
             value.map do |v|
               structure.hash(v, structure_opts.merge(:request => environment.request))
             end

data/lib/moonrope/structure_attribute.rb

@@ -11,6 +11,8 @@ module Moonrope
     attr_accessor :structure_opts
     attr_accessor :value
     attr_accessor :example
+    attr_accessor :doc
+    attr_accessor :mutation
 
     def initialize(type, name)
       @type = type
@@ -23,5 +25,42 @@ module Moonrope
       @source_attribute || @name
     end
 
+    def name_with_groups
+      ([groups] + [name]).flatten.compact.join('.')
+    end
+
+    def mutate(value)
+      if mutation
+        value ? value.public_send(mutation) : nil
+      else
+        auto_mutate(value)
+      end
+    end
+
+    def auto_mutate(value)
+      case value_type
+      when :timestamp
+        value.is_a?(Time) ? value.to_s : value
+      when :unix_timestamp
+        value.nil? ? nil : value.to_i
+      else
+        value
+      end
+    end
+
+    def example
+      @example ||= begin
+        if value_type == :timestamp
+          "2016-12-25 09:42:00 +0000"
+        elsif value_type == :unix_timestamp
+          "1491070507"
+        elsif value_type == :boolean
+          "false"
+        elsif value_type == :uuid
+          "017dabc1-3f4f-47ab-ab7d-86e2ed0de679"
+        end
+      end
+    end
+
   end
 end

data/lib/moonrope/version.rb

@@ -1,3 +1,3 @@
 module Moonrope
-  VERSION = '1.3.3'
+  VERSION = '2.0.2'
 end

data/moonrope.gemspec

@@ -0,0 +1,21 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+require "moonrope/version"
+
+Gem::Specification.new do |s|
+  s.name        = "moonrope"
+  s.version     = Moonrope::VERSION
+  s.authors     = ["Adam Cooke"]
+  s.email       = ["adam@atechmedia.com"]
+  s.homepage    = "http://adamcooke.io"
+  s.licenses    = ['MIT']
+  s.summary     = "An API server DSL."
+  s.description = "A full library allowing you to create sexy DSLs to define your RPC-like APIs."
+  s.files = Dir["**/*"]
+  s.bindir = "bin"
+  s.executables << 'moonrope'
+  s.add_dependency "json"
+  s.add_dependency "rack", ">= 1.4"
+  s.add_dependency "deep_merge", "~> 1.0"
+  s.add_development_dependency "rake"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,32 @@
+$:.unshift(File.expand_path(File.join('..', 'lib')))
+
+RSpec.configure do |config|
+  config.color = true
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+end
+
+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

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