apipie-rails 0.5.7 → 0.5.8

data/lib/apipie/response_description_adapter.rb

@@ -0,0 +1,199 @@
+module Apipie
+
+  def self.prop(name, expected_type, options={}, sub_properties=[])
+    Apipie::ResponseDescriptionAdapter::PropDesc.new(name, expected_type, options, sub_properties)
+  end
+
+  def self.additional_properties(yesno)
+    Apipie::ResponseDescriptionAdapter::AdditionalPropertiesModifier.new(yesno)
+  end
+
+  class ResponseDescriptionAdapter
+    class Modifier
+      def apply(adapter)
+        raise "Modifer subclass must implement 'apply' method"
+      end
+    end
+
+    class AdditionalPropertiesModifier < Modifier
+      def initialize(additional_properties_allowed)
+        @additional_properties_allowed = additional_properties_allowed
+      end
+
+      def apply(adapter)
+        adapter.additional_properties =  @additional_properties_allowed
+      end
+    end
+  end
+
+
+  class ResponseDescriptionAdapter
+
+    #
+    # A ResponseDescriptionAdapter::PropDesc object pretends to be an Apipie::Param in a ResponseDescription
+    #
+    # To successfully masquerade as such, it needs to:
+    #    respond_to?('name') and/or ['name'] returning the name of the parameter
+    #    respond_to?('required') and/or ['required'] returning boolean
+    #    respond_to?('additional_properties') and/or ['additional_properties'] returning boolean
+    #    respond_to?('validator') and/or ['validator'] returning 'nil' (so type is 'string'), or an object that:
+    #           1) describes a type.  currently type is inferred as follows:
+    #                 if validator.is_a? Apipie::Validator::EnumValidator -->  respond_to? 'values' (returns array).  Type is enum or boolean
+    #                 else: use v.expected_type().  This is expected to be the swagger type, or:
+    #                     numeric ==> swagger type is 'number'
+    #                     hash ==> swagger type is 'object' and validator should respond_to? 'params_ordered'
+    #                     array ==> swagger type is array and validator (FUTURE) should indicate type of element
+
+    class PropDesc
+
+      def to_s
+        "PropDesc -- name: #{@name}  type: #{@expected_type} required: #{@required} options: #{@options} subprop count: #{@sub_properties.length} additional properties: #{@additional_properties}"
+      end
+
+      #
+      # a ResponseDescriptionAdapter::PropDesc::Validator pretends to be an Apipie::Validator
+      #
+      class Validator
+        attr_reader :expected_type
+
+        def [](key)
+          return self.send(key) if self.respond_to?(key.to_s)
+        end
+
+        def initialize(expected_type, enum_values=nil, sub_properties=nil)
+          @expected_type = expected_type
+          @enum_values = enum_values
+          @is_enum = !!enum_values
+          @sub_properties = sub_properties
+        end
+
+        def is_enum?
+          !!@is_enum
+        end
+
+        def values
+          @enum_values
+        end
+
+        def params_ordered
+          raise "Only validators with expected_type 'object' can have sub-properties" unless @expected_type == 'object'
+          @sub_properties
+        end
+      end
+
+      #======================================================================
+
+
+      def initialize(name, expected_type, options={}, sub_properties=[])
+        @name = name
+        @required = true
+        @required = false if options[:required] == false
+        @expected_type = expected_type
+        @additional_properties = false
+
+        options[:desc] ||= options[:description]
+        @description = options[:desc]
+        @options = options
+        @is_array = options[:is_array] || false
+        @sub_properties = []
+        for prop in sub_properties do
+          add_sub_property(prop)
+        end
+      end
+
+      def [](key)
+        return self.send(key) if self.respond_to?(key.to_s)
+      end
+
+      def add_sub_property(prop_desc)
+        raise "Only properties with expected_type 'object' can have sub-properties" unless @expected_type == 'object'
+        if prop_desc.is_a? PropDesc
+          @sub_properties << prop_desc
+        elsif prop_desc.is_a? Modifier
+          prop_desc.apply(self)
+        else
+          raise "Unrecognized prop_desc type (#{prop_desc.class})"
+        end
+      end
+
+      def to_json(lang)
+        {
+            name: name,
+            required: required,
+            validator: validator,
+            description: description,
+            additional_properties: additional_properties,
+            is_array: is_array?,
+            options: options
+        }
+      end
+      attr_reader :name, :required, :expected_type, :options, :description
+      attr_accessor :additional_properties
+
+      alias_method :desc, :description
+
+      def is_array?
+        @is_array
+      end
+
+      def validator
+        Validator.new(@expected_type, options[:values], @sub_properties)
+      end
+    end
+  end
+
+  #======================================================================
+
+  class ResponseDescriptionAdapter
+
+    def self.from_self_describing_class(cls)
+      adapter = ResponseDescriptionAdapter.new
+      props = cls.describe_own_properties
+      adapter.add_property_descriptions(props)
+      adapter
+    end
+
+    def initialize
+      @property_descs = []
+      @additional_properties = false
+    end
+
+    attr_accessor :additional_properties
+
+    def allow_additional_properties
+      additional_properties
+    end
+
+    def to_json
+      params_ordered.to_json
+    end
+
+    def add(prop_desc)
+      if prop_desc.is_a? PropDesc
+        @property_descs << prop_desc
+      elsif prop_desc.is_a? Modifier
+        prop_desc.apply(self)
+      else
+        raise "Unrecognized prop_desc type (#{prop_desc.class})"
+      end
+    end
+
+    def add_property_descriptions(prop_descs)
+      for prop_desc in prop_descs
+        add(prop_desc)
+      end
+    end
+
+    def property(name, expected_type, options)
+      @property_descs << PropDesc.new(name, expected_type, options)
+    end
+
+    def params_ordered
+      @property_descs
+    end
+
+    def is_array?
+      false
+    end
+  end
+end

data/lib/apipie/swagger_generator.rb

@@ -13,6 +13,7 @@ module Apipie
 
     def initialize(apipie)
       @apipie = apipie
+      @issued_warnings = []
     end
 
     def params_in_body?
@@ -220,10 +221,12 @@ module Apipie
 
         methods[method_key] = {
             tags: [tag_name_for_resource(ruby_method.resource)] + warning_tags,
+            consumes: params_in_body? ? ['application/json'] : ['application/x-www-form-urlencoded', 'multipart/form-data'],
             operationId: op_id,
             summary: Apipie.app.translate(api.short_description, @current_lang),
             parameters: swagger_params_array_for_method(ruby_method, api.path),
-            responses: responses
+            responses: responses,
+            description: ruby_method.full_description
         }
 
         if methods[method_key][:summary].nil?
@@ -262,6 +265,45 @@ module Apipie
       http_method.downcase + path.gsub(/\//,'_').gsub(/:(\w+)/, '\1').gsub(/_$/,'')
     end
 
+    class SwaggerTypeWithFormat
+      attr_reader :str_format
+      def initialize(type, str_format)
+        @type = type
+        @str_format = str_format
+      end
+
+      def to_s
+        @type
+      end
+
+      def ==(other)
+        other.to_s == self.to_s
+      end
+    end
+
+    def lookup
+      @lookup ||= {
+        numeric: "number",
+        hash: "object",
+        array: "array",
+
+        # see https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md#data-types
+        integer: SwaggerTypeWithFormat.new("integer", "int32"),
+        long: SwaggerTypeWithFormat.new("integer", "int64"),
+        number: SwaggerTypeWithFormat.new("number", nil),  # here just for completeness
+        float: SwaggerTypeWithFormat.new("number", "float"),
+        double: SwaggerTypeWithFormat.new("number", "double"),
+        string: SwaggerTypeWithFormat.new("string", nil),  # here just for completeness
+        byte: SwaggerTypeWithFormat.new("string", "byte"),
+        binary: SwaggerTypeWithFormat.new("string", "binary"),
+        boolean: SwaggerTypeWithFormat.new("boolean", nil),  # here just for completeness
+        date: SwaggerTypeWithFormat.new("string", "date"),
+        dateTime: SwaggerTypeWithFormat.new("string", "date-time"),
+        password: SwaggerTypeWithFormat.new("string", "password"),
+      }
+    end
+
+
     def swagger_param_type(param_desc)
       if param_desc.nil?
         raise("problem")
@@ -272,7 +314,7 @@ module Apipie
         return "string"
       end
 
-      if v.class == Apipie::Validator::EnumValidator
+      if v.class == Apipie::Validator::EnumValidator || (v.respond_to?(:is_enum?) && v.is_enum?)
         if v.values - [true, false] == [] && [true, false] - v.values == []
           warn_inferring_boolean(param_desc.name)
           return "boolean"
@@ -283,11 +325,6 @@ module Apipie
         # pp v
       end
 
-      lookup = {
-          numeric: "number",
-          hash: "object",
-          array: "array"
-      }
 
       return lookup[v.expected_type.to_sym] || v.expected_type
     end
@@ -297,6 +334,30 @@ module Apipie
     # Responses
     #--------------------------------------------------------------------------
 
+    def response_schema(response)
+      begin
+        # no need to warn about "missing default value for optional param" when processing response definitions
+        prev_value = @disable_default_value_warning
+        @disable_default_value_warning = true
+        schema = json_schema_obj_from_params_array(response.params_ordered)
+      ensure
+        @disable_default_value_warning = prev_value
+      end
+
+      if response.is_array? && schema
+        schema = {
+            type: "array",
+            items: schema
+        }
+      end
+
+      if response.allow_additional_properties
+        schema[:additionalProperties] = true
+      end
+
+      schema
+    end
+
     def swagger_responses_hash_for_method(method)
       result = {}
 
@@ -305,6 +366,17 @@ module Apipie
         result[error.code] = error_block
       end
 
+      for response in method.returns
+        swagger_response_block = {
+            description: response.description
+        }
+
+        schema = response_schema(response)
+        swagger_response_block[:schema] = schema if schema
+
+        result[response.code] = swagger_response_block
+      end
+
       if result.length == 0
         warn_no_return_codes_specified
         result[200] = {description: 'ok'}
@@ -351,7 +423,7 @@ module Apipie
     # The core routine for creating a swagger parameter definition block.
     # The output is slightly different when the parameter is inside a schema block.
     #--------------------------------------------------------------------------
-    def swagger_atomic_param(param_desc, in_schema, name=nil)
+    def swagger_atomic_param(param_desc, in_schema, name)
       def save_field(entry, openapi_key, v, apipie_key=openapi_key, translate=false)
         if v.key?(apipie_key)
           if translate
@@ -364,7 +436,12 @@ module Apipie
 
       swagger_def = {}
       swagger_def[:name] = name if !name.nil?
-      swagger_def[:type] = swagger_param_type(param_desc)
+
+      swg_param_type = swagger_param_type(param_desc)
+      swagger_def[:type] = swg_param_type.to_s
+      if (swg_param_type.is_a? SwaggerTypeWithFormat) && !swg_param_type.str_format.nil?
+        swagger_def[:format] = swg_param_type.str_format
+      end
 
       if swagger_def[:type] == "array"
         swagger_def[:items] = {type: "string"} # TODO: add support for arrays of non-string items
@@ -385,7 +462,7 @@ module Apipie
         swagger_def[:required] = param_desc.required if param_desc.required
       end
 
-      save_field(swagger_def, :description, param_desc.options, :desc, true)
+      save_field(swagger_def, :description, param_desc.options, :desc, true) unless param_desc.options[:desc].nil?
       save_field(swagger_def, :default, param_desc.options, :default_value)
 
       if param_desc.respond_to?(:_gen_added_from_path) && !param_desc.required
@@ -394,7 +471,7 @@ module Apipie
       end
 
       if !swagger_def[:required] && !swagger_def.key?(:default)
-        warn_optional_without_default_value(param_desc.name)
+        warn_optional_without_default_value(param_desc.name) unless @disable_default_value_warning
       end
 
       swagger_def
@@ -415,6 +492,7 @@ module Apipie
 
       result = {type: "object"}
       result[:properties] = param_defs
+      result[:additionalProperties] = false unless Apipie.configuration.swagger_allow_additional_properties_in_response
       result[:required] = required_params if required_params.length > 0
 
       param_defs.length > 0 ? result : nil
@@ -426,8 +504,8 @@ module Apipie
       schema_obj = json_schema_obj_from_params_array(params_array)
       return nil if schema_obj.nil?
 
-      @definitions[name] = schema_obj
-      ref_to(name)
+      @definitions[name.to_sym] = schema_obj
+      ref_to(name.to_sym)
     end
 
     def json_schema_param_defs_from_params_array(params_array)
@@ -443,15 +521,27 @@ module Apipie
           raise ("unexpected param_desc format")
         end
 
-        required_params.push(param_desc.name) if param_desc.required
+        required_params.push(param_desc.name.to_sym) if param_desc.required
 
         param_type = swagger_param_type(param_desc)
 
         if param_type == "object" && param_desc.validator.params_ordered
           schema = json_schema_obj_from_params_array(param_desc.validator.params_ordered)
-          param_defs[param_desc.name] = schema if !schema.nil?
+          if param_desc.additional_properties
+            schema[:additionalProperties] = true
+          end
+
+          if param_desc.is_array?
+            new_schema = {
+                type: 'array',
+                items: schema
+            }
+            schema = new_schema
+          end
+
+          param_defs[param_desc.name.to_sym] = schema if !schema.nil?
         else
-          param_defs[param_desc.name] = swagger_atomic_param(param_desc, true)
+          param_defs[param_desc.name.to_sym] = swagger_atomic_param(param_desc, true, nil)
         end
       end
 

data/lib/apipie/version.rb

@@ -1,3 +1,3 @@
 module Apipie
-  VERSION = '0.5.7'
+  VERSION = '0.5.8'
 end

data/spec/controllers/apipies_controller_spec.rb

@@ -142,6 +142,7 @@ describe Apipie::ApipiesController do
 
       assert_response :success
       expect(response.body).to match(/"swagger":"2.0"/)
+      # puts response.body
       expect(JSON::Validator.validate(swagger_schema, response.body)).to be_truthy
     end
 

data/spec/dummy/app/controllers/application_controller.rb

@@ -3,6 +3,10 @@ class ApplicationController < ActionController::Base
   
   resource_description do
     param :oauth, String, :desc => "Authorization", :required => false
+
+    returns :code => 401 do
+      property :reason, String, "Why authorization was denied"
+    end
   end
 
   def run_validations

data/spec/dummy/app/controllers/pets_controller.rb

@@ -0,0 +1,391 @@
+#
+# The PetsController defined here provides examples for different ways
+# in which the 'returns' DSL directive can be used with the existing
+# Apipie DSL elements 'param' and 'param_group'
+#
+
+class PetsController < ApplicationController
+  resource_description do
+    description 'A controller to test "returns"'
+    short 'Pets'
+    path '/pets'
+
+    param :common_param, Integer, :desc => "A param that can optionally be passed to all Pet methods", :required => false
+
+    returns :code => 404 do
+      property :error_message, String, "description of the error"
+    end
+
+  end
+
+  #-----------------------------------------------------------
+  # simple 'returns' example: a method that returns a pet record
+  #-----------------------------------------------------------
+  api :GET, "/pets/:id/as_properties", "Get a pet record"
+  returns :code => 200 do
+    property :pet_name, String, :desc => "Name of pet", :required => false
+    property :animal_type, ['dog','cat','iguana','kangaroo'], :desc => "Type of pet"   # required by default, because this is a 'property'
+  end
+  returns :code => 404 do
+    property :another_error_message, String, :desc => "Overriding the response description from the Pets resource"
+  end
+  def show_as_properties
+    render :plain => "showing pet properties"
+  end
+
+
+  #-----------------------------------------------------------
+  # same example as above, but this time the properties are defined
+  # in a param group
+  #-----------------------------------------------------------
+  def_param_group :pet do
+    property :pet_name, String, :desc => "Name of pet", :required => false
+    property :animal_type, ['dog','cat','iguana','kangaroo'], :desc => "Type of pet"   # required by default, because this is a 'property'
+  end
+
+  api :GET, "/pets/:id/as_param_group_of_properties", "Get a pet record"
+  returns :pet, :code => 200, :desc => "The pet"
+  def show_as_param_group_of_properties
+    render :plain => "showing pet properties defined as param groups"
+  end
+
+  #-----------------------------------------------------------
+  #  Method returning an array of the :pet param_group
+  #-----------------------------------------------------------
+  api :GET, "/pets", "Get all pets"
+  returns :array_of => :pet, :desc => "list of pets"
+  def index
+    render :plain => "all pets"
+  end
+
+
+  #-----------------------------------------------------------
+  # mixing request/response and response-only parameters
+  #
+  # the param_group :pet_with_id has several parameters which are
+  # not expectd in the request, but would show up in the response
+  # and vice versa
+  #-----------------------------------------------------------
+  def_param_group :pet_with_id do
+    param :pet_id, Integer, :desc => "id of pet", :required => true
+    param :pet_name, String, :desc => "Name of pet", :required => false, :only_in => :response
+    param :partial_match_allowed, [true, false], :desc => "Partial match allowed?", :required => false, :only_in => :request
+    property :animal_type, ['dog','cat','iguana','kangaroo'], :desc => "Type of pet"   # this is implicitly :only_in => :response
+  end
+
+  api :GET, "/pets/pet_by_id", "Get a pet record with the pet id in the body of the request"
+  param_group :pet_with_id # only the pet_id is expected to be in here
+  returns :param_group => :pet_with_id, :code => 200
+  def show_pet_by_id
+    render :plain => "returning a record with 3 fields"
+  end
+
+
+
+  #-----------------------------------------------------------
+  # example with multiple param groups
+  #-----------------------------------------------------------
+  def_param_group :owner do   # a param group that can be used to describe inputs as well as outputs
+    param :owner_name, String
+  end
+  def_param_group :user_response do # a param group that can be used to describe outputs only
+    property :vote, [true,false]
+  end
+
+  api :GET, "/pets/by_owner_name/did_vote", "did any of the pets owned by the given user vote?"
+  param_group :owner, :desc => "look up the user by name"
+  returns :code => 200 do
+    param_group :owner
+    param_group :user_response
+  end
+  returns :code => 404  # no body
+  def get_vote_by_owner_name
+    render :plain => "no pets have voted"
+  end
+
+
+  #-----------------------------------------------------------
+  # a method returning multiple codes,
+  # some of which have a complex data structure
+  #-----------------------------------------------------------
+  def_param_group :pet_measurements do
+    property :pet_measurements, Hash do
+      property :weight, Integer, :desc => "Weight in pounds"
+      property :height, Integer, :desc => "Height in inches"
+      property :num_legs, Integer, :desc => "Number of legs", :required => false
+    end
+  end
+
+  def_param_group :pet_history do
+    property :did_visit_vet, [true,false], :desc => "Did the pet visit the veterinarian"
+    property :avg_meals_per_day, Float, :desc => "Average number of meals per day"
+  end
+
+  api :GET, "/pets/:id/extra_info", "Get extra information about a pet"
+  returns :code => 201, :desc => "Found a pet" do
+    param_group :pet
+  end
+  returns :code => 202 do
+    param_group :pet
+    param_group :pet_measurements
+  end
+  returns :code => 203 do
+    param_group :pet
+    param_group :pet_measurements
+    property 'pet_history', Hash do  # the pet_history param_group does not contain a wrapping object,
+                                     # so create one manually
+      param_group :pet_history
+    end
+    property 'additional_histories', :array_of => Hash do
+      param_group :pet_history
+    end
+  end
+  returns :code => :unprocessable_entity, :desc => "Fleas were discovered on the pet" do
+    param_group :pet
+    property :num_fleas, Integer, :desc => "Number of fleas on this pet"
+  end
+  def show_extra_info
+    render :plain => "please disinfect your pet"
+  end
+
+
+  #=======================================================================
+  # Methods for testing response validation
+  #=======================================================================
+
+
+  #-----------------------------------------------------------
+  # A method which returns the response as described
+  #-----------------------------------------------------------
+  api!
+  returns :code => 200 do
+    property :a_number, Integer
+    property :an_optional_number, Integer, :required=>false
+  end
+  def return_and_validate_expected_response
+    result =  {
+        a_number: 3
+    }
+    render :json => result
+  end
+
+  #-----------------------------------------------------------
+  # A method which returns a null value in the response
+  #-----------------------------------------------------------
+  api!
+  returns :code => 200 do
+    property :a_number, Integer
+    property :an_optional_number, Integer, :required=>false
+  end
+  def return_and_validate_expected_response_with_null
+    result =  {
+        a_number: nil
+    }
+    render :json => result
+  end
+
+  #-----------------------------------------------------------
+  # A method which returns a null value in the response instead of an object
+  #-----------------------------------------------------------
+  api!
+  returns :code => 200 do
+    property :an_object, Hash do
+      property :an_optional_number, Integer, :required=>false
+    end
+  end
+  def return_and_validate_expected_response_with_null_object
+    result =  {
+        an_object: nil
+    }
+    render :json => result
+  end
+
+  #-----------------------------------------------------------
+  # A method which returns an array response as described
+  #-----------------------------------------------------------
+  def_param_group :two_numbers do
+    property :a_number, Integer
+    property :an_optional_number, Integer, :required=>false
+  end
+
+  api!
+  returns :code => 200, :array_of => :two_numbers
+  def return_and_validate_expected_array_response
+    result =  [{
+                   a_number: 3
+               }]
+    render :json => result
+  end
+
+  #-----------------------------------------------------------
+  # A method which returns an array response when it is expected to return an object
+  # (note that response code is set here to 201)
+  #-----------------------------------------------------------
+  api!
+  returns :two_numbers, :code => 201
+  def return_and_validate_unexpected_array_response
+    result =  [{
+                   a_number: 3
+               }]
+    render :status => 201, :json => result
+  end
+
+  #-----------------------------------------------------------
+  # A method which has a response that does not match the output type
+  #-----------------------------------------------------------
+  api!
+  returns :code => 200 do
+    property :a_number, String
+  end
+  def return_and_validate_type_mismatch
+    result =  {
+        a_number: 3
+    }
+    render :json => result
+  end
+
+
+  #-----------------------------------------------------------
+  # A method which has a response with a missing field
+  #-----------------------------------------------------------
+  api!
+  returns :code => 200 do
+    property :a_number, Integer
+    property :another_number, Integer
+  end
+  def return_and_validate_missing_field
+    result =  {
+        a_number: 3
+    }
+    render :json => result
+  end
+
+
+  #-----------------------------------------------------------
+  # A method which has a response with an extra property
+  # (should raise a validation error by default)
+  #-----------------------------------------------------------
+  api!
+  returns :code => 200 do
+    property :a_number, Integer
+  end
+  def return_and_validate_extra_property
+    result =  {
+        a_number: 3,
+        another_number: 4
+    }
+    render :json => result
+  end
+
+
+  #-----------------------------------------------------------
+  # A method which has a response with an extra property, but 'additional_properties' is specified
+  # (should not raise a validation error by default)
+  #-----------------------------------------------------------
+  api!
+  returns :code => 200, :additional_properties => true do
+    property :a_number, Integer
+  end
+  def return_and_validate_allowed_extra_property
+    result =  {
+        a_number: 3,
+        another_number: 4
+    }
+    render :json => result
+  end
+
+  #-----------------------------------------------------------
+  # Sub-object in response has an extra property. 'additional_properties' is specified on the response, but not on the object
+  # (should raise a validation error by default)
+  #-----------------------------------------------------------
+  api!
+  returns :code => 200, :additional_properties => true do
+    property :an_object, Hash do
+      property :a_number, Integer
+    end
+  end
+  def sub_object_invalid_extra_property
+    result =  {
+        an_object: {
+            a_number: 2,
+            an_extra_number: 3
+        }
+    }
+    render :json => result
+  end
+
+
+  #-----------------------------------------------------------
+  # Sub-object in response has an extra property. 'additional_properties' is specified on the object, but not on the response
+  # (should not raise a validation error by default)
+  #-----------------------------------------------------------
+  api!
+  returns :code => 200, :additional_properties => false do
+    property :an_object, Hash, :additional_properties => true do
+      property :a_number, Integer
+    end
+  end
+  def sub_object_allowed_extra_property
+    result =  {
+        an_object: {
+            a_number: 2,
+            an_extra_number: 3
+        }
+    }
+    render :json => result
+  end
+
+
+  #=======================================================================
+  # Methods for testing array field responses
+  #=======================================================================
+
+  #-----------------------------------------------------------
+  # A method which returns the response as described (one field is an array of objects)
+  #-----------------------------------------------------------
+  api!
+  returns :code => 200 do
+    property :a_number, Integer
+    property :array_of_objects, :array_of => Hash do
+      property :number1, Integer, :required=>true
+      property :number2, Integer, :required=>true
+    end
+  end
+  def returns_response_with_valid_array
+    result =  {
+        a_number: 3,
+        array_of_objects: [
+            {number1: 1, number2: 2},
+            {number1: 10, number2: 20}
+        ]
+    }
+    render :json => result
+  end
+
+
+  #-----------------------------------------------------------
+  # A method which returns an incorrect response (wrong field type inside array)
+  #-----------------------------------------------------------
+  api!
+  returns :code => 200 do
+    property :a_number, Integer
+    property :array_of_objects, :array_of => Hash do
+      property :number1, Integer, :required=>true
+      property :number2, Integer, :required=>true
+    end
+  end
+  def returns_response_with_invalid_array
+    result =  {
+        a_number: 3,
+        array_of_objects: [
+            {number1: 1, number2: 2},
+            {number1: 10, number2: "this should have been a number"}
+        ]
+    }
+    render :json => result
+  end
+
+
+
+end
+