sinatra-rabbit 1.0.6 → 1.0.7

data/lib/sinatra/rabbit/base.rb

@@ -371,22 +371,22 @@ module Sinatra
 
         def self.control(&block)
           params_def = @params
-          if not has_capability?
-            @control = Proc.new { [412, { 'Expect' => @options[:with_capability]}, "The required capability to execute this operation is missing"] }
-          else
-            @control ||= Proc.new do
-              begin
-                Rabbit::Validator.validate!(params, params_def)
-              rescue => e
-                if e.kind_of? Rabbit::Validator::ValidationError
-                  halt e.http_status_code, e.message
-                else
-                  raise e
-                end
+          klass = self
+          @control ||= Proc.new {
+            if settings.respond_to?(:capability) and !settings.capability(klass.required_capability)
+              halt([412, { 'Expect' => klass.required_capability.to_s }, "The required capability to execute this operation is missing"])
+            end
+            begin
+              Rabbit::Validator.validate!(params, params_def)
+            rescue => e
+              if e.kind_of? Rabbit::Validator::ValidationError
+                halt e.http_status_code, e.message
+              else
+                raise e
               end
-              instance_eval(&block)
             end
-          end
+            instance_eval(&block) if block_given?
+          }
         end
 
         def self.param(*args)

data/sinatra-rabbit.gemspec

@@ -29,15 +29,12 @@ Gem::Specification.new do |s|
     a simple REST API using easy to undestand DSL.
   EOF
 
-  s.version = '1.0.6'
+  s.version = '1.0.7'
   s.date = Time.now
   s.summary = %q{Sinatra REST API DSL}
   s.files = FileList[
     'lib/sinatra/*.rb',
     'lib/sinatra/rabbit/*.rb',
-    'lib/sinatra/docs/*.haml',
-    'tests/*.rb',
-    'Rakefile',
     'LICENSE',
     'README.md',
     'sinatra-rabbit.gemspec',

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sinatra-rabbit
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 1.0.7
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-04 00:00:00.000000000 Z
+date: 2012-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sinatra
-  requirement: &70152956767880 !ruby/object:Gem::Requirement
+  requirement: &70133234245000 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: 1.3.0
   type: :runtime
   prerelease: false
-  version_requirements: *70152956767880
+  version_requirements: *70133234245000
 description: ! "    Rabbit is a Sinatra extension which can help you writing\n    a
   simple REST API using easy to undestand DSL.\n"
 email: dev@deltacloud.apache.org
@@ -37,15 +37,6 @@ files:
 - lib/sinatra/rabbit/features.rb
 - lib/sinatra/rabbit/param.rb
 - lib/sinatra/rabbit/validator.rb
-- lib/sinatra/docs/api.haml
-- lib/sinatra/docs/collection.haml
-- lib/sinatra/docs/operation.haml
-- tests/app_test.rb
-- tests/docs_test.rb
-- tests/dsl_test.rb
-- tests/fixtures.rb
-- tests/params_test.rb
-- Rakefile
 - LICENSE
 - README.md
 - sinatra-rabbit.gemspec

data/Rakefile

@@ -1,44 +0,0 @@
-require 'rake/testtask'
-
-namespace :test do
-
-  desc 'Run all tests suites'
-  task :all do
-    Rake::Task['test:app'].invoke
-    Rake::Task['test:dsl'].invoke
-    Rake::Task['test:docs'].invoke
-    Rake::Task['test:param'].invoke
-  end
-
-  Rake::TestTask.new(:app) do |t|
-    t.test_files = FileList['tests/app_test.rb']
-    t.verbose = false
-    t.options = "-v"
-  end
-
-  Rake::TestTask.new(:dsl) do |t|
-    t.test_files = FileList['tests/dsl_test.rb']
-    t.verbose = false
-    #t.options = "-v"
-  end
-
-  Rake::TestTask.new(:docs) do |t|
-    t.test_files = FileList['tests/docs_test.rb']
-    t.verbose = false
-  end
-
-end
-
-desc "Run RSpec with code coverage"
-task :coverage do
-  ENV["COVERAGE"] = "true"
-  Rake::Task["test:all"].execute
-end
-
-desc "Reinstall gem"
-task :reinstall do
-  puts %x{rm -rf sinatra-rabbit-*.gem}
-  puts %x{gem uninstall sinatra-rabbit --all -I -x}
-  puts %x{gem build sinatra-rabbit.gemspec}
-  puts %x{gem install sinatra-rabbit-*.gem --local}
-end

data/lib/sinatra/docs/api.haml

@@ -1,8 +0,0 @@
-%html
-  %head
-  %body
-    %h1=self.class.name
-    %ul
-      - self.class.collections.each do |c|
-        %li
-          %a{:href => c.docs_url }=c.name

data/lib/sinatra/docs/collection.haml

@@ -1,24 +0,0 @@
-%html
-  %head
-  %body
-    %h1=@collection.name.gsub('Sinatra::Rabbit::', '')
-    %blockquote=@collection.description
-    .url=@collection.full_path
-    .features
-      - @collection.features.each do |f|
-        %p.feature=f.name
-    %table.operations
-      %thead
-        %tr
-          %th Name
-          %th Type
-          %th Valid values
-          %th Description
-      %tbody
-        - @collection.operations.each do |o|
-          %tr
-            %td.name
-              %a{:href => o.docs_url }
-            %td.method=o.http_method.to_s.upcase
-            %td.url
-              %a{:href=>o.full_path}=o.full_path

data/lib/sinatra/docs/operation.haml

@@ -1,26 +0,0 @@
-%html
-  %head
-  %body
-    %h1=@operation.name.gsub('Sinatra::Rabbit::', '')
-    %blockquote=@operation.description
-    .url=@operation.full_path
-    - if @operation.required_capability
-      %p{:class => :requires}=@operation.required_capability
-    - @operation.features.each do |f|
-      .feature
-        .name=f.name
-        %blockquote=f.description
-    %table.parameters
-      %thead
-        %tr
-          %th Name
-          %th Type
-          %th Valid values
-          %th Description
-      %tbody
-        - (@operation.params + @operation.features_params).each do |p|
-          %tr
-            %td{ :class => p.required? && 'required'}=p.name
-            %td=p.klass
-            %td=p.values
-            %td=p.description

data/tests/app_test.rb

@@ -1,72 +0,0 @@
-require 'rack/test'
-load File.join(File.dirname(__FILE__), 'fixtures.rb')
-
-include Rack::Test::Methods
-
-def app
-  Sample
-end
-
-def status
-  last_response.status
-end
-
-describe Sample do
-
-  it "should respond with status OK for root" do
-    get '/'
-    status.must_equal 200
-  end
-
-  it "should respond 400 to index operation for sample collection without param" do
-    get '/sample'
-    status.must_equal 400
-  end
-
-  it "should respond 200 to index operation for sample collection with param" do
-    get '/sample', { :id => :sample }
-    status.must_equal 200
-  end
-
-  it "should respond 200 to HEAD request for index operation in sample collection" do
-    head '/sample/index'
-    status.must_equal 200
-  end
-
-  it "should respond to OPTIONS request for index operation in sample collection" do
-    options '/sample/index'
-    status.must_equal 200
-    allow_header = last_response.headers['Allow'].split(',')
-    allow_header.wont_be_empty
-    allow_header.must_include 'feature_data:string:optional'
-    allow_header.must_include 'id:string:required'
-  end
-
-  it "should respond 200 to show operation for sample collection" do
-    get '/sample/100'
-    status.must_equal 200
-    last_response.body.must_equal '100'
-  end
-
-  it "should respond 201 to delete operation on sample collection" do
-    delete '/sample/100'
-    status.must_equal 201
-  end
-
-  it "should respond 200 to stop operation with condition routes" do
-    get '/sample/100/stop'
-    status.must_equal 200
-  end
-
-  it "should respond 200 to sample subcollection index operation" do
-    get '/sample/10/subsample/20'
-    status.must_equal 200
-  end
-
-  it "should raise an exception when posting data with unknown values" do
-    post '/sample', { :id => '1', :arch => '3'}
-    last_response.status.must_equal 400
-    last_response.body.must_equal "Parameter 'arch' value '3' not found in list of allowed values [1,2]"
-  end
-
-end

data/tests/docs_test.rb

@@ -1,75 +0,0 @@
-require 'rack/test'
-require 'nokogiri'
-
-load File.join(File.dirname(__FILE__), 'fixtures.rb')
-
-include Rack::Test::Methods
-
-def app
-  Sample
-end
-
-def status
-  last_response.status
-end
-
-def html
-  Nokogiri::HTML(last_response.body)
-end
-
-describe 'Documentation' do
-
-  it "should respond with status OK for root" do
-    get '/docs'
-    status.must_equal 200
-  end
-
-  it "should return list of collections in entrypoint" do
-    get '/docs'
-    html.css('html body > h1').text.must_equal 'Sample'
-    html.css('html body ul li').wont_be_empty
-    html.css('html body ul li a').wont_be_empty
-  end
-
-  it "should return valid collection name when query collection documentation" do
-    get '/docs/sample'
-    html.css('html body > h1').text.must_equal 'SampleCollection'
-  end
-
-  it "should return valid collection description when query collection documentation" do
-    get '/docs/sample'
-    html.css('html body > blockquote').text.must_equal 'Test'
-  end
-
-  it "should return valid collection url when query collection documentation" do
-    get '/docs/sample'
-    html.css('html body > .url').text.must_equal '/sample'
-  end
-
-  it "should return list of features when query collection documentation" do
-    get '/docs/sample'
-    html.css('html body .features .feature').map { |f| f.text}.must_include 'user_data', 'user_name'
-  end
-
-  it "should return complete list of operations when query collection documentation" do
-    get '/docs/sample'
-    html.css('html body .operations tr').size.must_equal 7
-  end
-
-  it "should provide valid links from entrypoint to collection" do
-    get '/docs'
-    html.css('html body ul li a').each do |a|
-      get a[:href]
-      last_response.status.must_equal 200
-    end
-  end
-
-  it "should provide valid links from collection to an operation" do
-    get '/docs/sample'
-    html.css('html body .operations tbody .name a').each do |a|
-      get a[:href]
-      last_response.status.must_equal 200
-    end
-  end
-
-end

data/tests/dsl_test.rb

@@ -1,262 +0,0 @@
-load File.join(File.dirname(__FILE__), 'fixtures.rb')
-
-describe Sinatra::Rabbit::DSL do
-
-  it "should allow to set configuration" do
-    Sinatra::Rabbit.configure do
-      enable :documentation
-      enable :head_routes
-      enable :options_routes
-      disable :sample_setting
-    end
-    Sinatra::Rabbit.enabled?(:documentation).must_equal true
-    Sinatra::Rabbit.disabled?(:documentation).must_equal false
-    Sinatra::Rabbit.enabled?(:sample_setting).must_equal false
-    Sinatra::Rabbit.disabled?(:sample_setting).must_equal true
-  end
-
-  it "should allow to set any property" do
-    Sinatra::Rabbit.set(:test_property, '1')
-    Sinatra::Rabbit.configuration[:test_property].must_equal '1'
-  end
-
-  it "should have collection method" do
-    Sample.respond_to?(:collection).must_equal true
-  end
-
-  it "should be Sinatra::Base class" do
-    Sample.respond_to?(:configure).must_equal true
-  end
-
-  it "should return list of all collections" do
-    Sample.collections.wont_be_empty
-    Sample.collections.size.must_equal 3
-  end
-
-end
-
-describe Sinatra::Rabbit::Collection do
-
-  it "should include SampleCollection and SecondSampleCollection" do
-    Sample.collections.wont_be_empty
-    Sample.collections.must_include Sinatra::Rabbit::SampleCollection
-    Sample.collections.must_include Sinatra::Rabbit::SecondSampleCollection
-  end
-
-  it "should return SampleCollection using .collection method" do
-    Sample.collection(:sample).must_equal Sinatra::Rabbit::SampleCollection
-    Sample.collection(:non_existing_sample).must_be_nil
-  end
-
-  it 'should return SampleCollection using [] method' do
-    Sample[:sample].must_equal Sinatra::Rabbit::SampleCollection
-    Sample[:non_existing_sample].must_be_nil
-  end
-
-  it "should allow to register new collection dynamically" do
-    Sample.collection(:dynamic) do
-      description 'DynamicTest'
-      operation :index do
-        control do
-          status 200
-        end
-      end
-    end
-    Sample.collection(:dynamic).must_equal Sinatra::Rabbit::DynamicCollection
-  end
-
-  it "should raise exception when contain control block" do
-    lambda {
-      Sample.collection(:raise) do
-        description 'RaiseTest'
-        control do
-          status 200
-        end
-      end
-    }.must_raise RuntimeError
-  end
-
-  it "should allow to return base class" do
-    Sample.collection(:second_sample).base_class.must_equal Sample
-    Sample.collection(:sample).collection(:subsample).base_class.must_equal Sample
-  end
-
-  it "should return correct collection name" do
-    Sample.collection(:sample).collection_name.must_equal :sample
-    Sample.collection(:second_sample).collection_name.must_equal :second_sample
-  end
-
-  it "should have correct URI set" do
-    Sample.collection(:sample).full_path.must_equal '/sample'
-  end
-
-  it "should return correct collection description" do
-    Sample.collection(:sample).description.must_equal 'Test'
-    Sample.collection(:second_sample).description.must_equal 'SecondTest'
-  end
-
-  it "should return operations and find index operation" do
-    Sample.collection(:sample).operations.wont_be_empty
-    Sample.collection(:sample).operations.must_include Sinatra::Rabbit::SampleCollection::IndexOperation
-  end
-
-  it "should return operation using [] syntax" do
-    Sample[:sample][:index].must_equal Sinatra::Rabbit::SampleCollection::IndexOperation 
-  end
-
-  it "should return subcollection using [] syntax" do
-    Sample[:sample][:subsample].must_equal Sinatra::Rabbit::SampleCollection::SubsampleCollection
-  end
-
-  it "should return operation from subcollection using the [] syntax" do
-    Sample[:sample][:subsample][:start].must_equal Sinatra::Rabbit::SampleCollection::SubsampleCollection::StartOperation
-  end
-
-  it "should allow to define subcollection" do
-    Sample.collection(:sample).collections.wont_be_empty
-    Sample.collection(:sample).collections.must_include Sinatra::Rabbit::SampleCollection::SubsampleCollection
-  end
-
-  it "should allow to retrieve subcollection from collection" do
-    Sample.collection(:sample).collection(:subsample).must_equal Sinatra::Rabbit::SampleCollection::SubsampleCollection
-  end
-
-  it "should allow to retrieve subcollection parent collection" do
-    Sample.collection(:sample).collection(:subsample).parent_collection.must_equal Sinatra::Rabbit::SampleCollection
-  end
-
-  it "should allow to get all operations defined for subcollection" do
-    Sample.collection(:sample).collection(:subsample).operations.must_include Sinatra::Rabbit::SampleCollection::SubsampleCollection::ShowOperation
-    Sample.collection(:sample).collection(:subsample).operations.must_include Sinatra::Rabbit::SampleCollection::SubsampleCollection::StartOperation
-  end
-
-  it "should have correct URI set for operations in subcollection" do
-    Sample.collection(:sample).collection(:subsample).operation(:show).full_path.must_equal '/sample/:id/subsample/:sub_id'
-    Sample.collection(:sample).collection(:subsample).operation(:start).full_path.must_equal '/sample/:id/subsample/:sub_id/start'
-  end
-
-  it "should have correct URI set for subcollection" do
-    Sample.collection(:sample).collection(:subsample).full_path.must_equal '/sample/:id/subsample'
-  end
-
-  it "should allow to have deeper subcollections" do
-    Sample.collection(:sample).collection(:subsample).collection(:secondsubsample).must_equal Sinatra::Rabbit::SampleCollection::SubsampleCollection::SecondsubsampleCollection
-  end
-
-end
-
-describe Sinatra::Rabbit::Collection::Operation do
-
-  it "should have the :restart action" do
-    Sample.collection(:second_sample).operation(:restart).must_equal Sinatra::Rabbit::SecondSampleCollection::RestartOperation
-    Sample.collection(:second_sample).operation(:restart).full_path.must_equal '/second_sample/:id/restart'
-    Sample.collection(:second_sample).operation(:restart).http_method.must_equal :post
-  end
-
-  it "should return :index operation" do
-    Sample.collection(:sample).operation(:index).must_equal Sinatra::Rabbit::SampleCollection::IndexOperation
-  end
-
-  it "should return correct name" do
-    Sample.collection(:sample).operation(:index).operation_name.must_equal :index
-  end
-
-  it "should return correct description" do
-    Sample.collection(:sample).operation(:index).description.must_equal 'TestIndex'
-  end
-
-  it "should have :id param defined" do
-    Sample.collection(:sample).operation(:index).param(:id).must_be_kind_of Sinatra::Rabbit::Param
-    Sample.collection(:sample).operation(:index).param(:id).name.must_equal :id
-  end
-
-  it "should not return non-existing param" do
-    Sample.collection(:sample).operation(:index).param(:non_existing).must_be_nil
-  end
-
-  it "should allow to add new param" do
-    Sample.collection(:sample).operation(:index).param(:next_id, :string)
-    Sample.collection(:sample).operation(:index).param(:next_id).must_be_kind_of Sinatra::Rabbit::Param
-  end
-
-  it "should return all params" do
-    Sample.collection(:sample).operation(:index).params.wont_be_empty
-  end
-
-  it "should have control block" do
-    Sample.collection(:sample).operation(:index).respond_to?(:control).must_equal true
-  end
-
-  it "should have correct path for index operation" do
-    Sample.collection(:sample).operation(:index).full_path.must_equal '/sample'
-  end
-
-  it "should have correct path for create operation" do
-    Sample.collection(:sample).operation(:create).full_path.must_equal '/sample'
-  end
-
-  it "should have correct path for show operation" do
-    Sample.collection(:sample).operation(:show).full_path.must_equal '/sample/:id'
-  end
-
-  it "should have correct path for destroy operation" do
-    Sample.collection(:sample).operation(:show).full_path.must_equal '/sample/:id'
-  end
-
-  it "should have correct path for stop operation" do
-    Sample.collection(:sample).operation(:stop).full_path.must_equal '/sample/:id/stop'
-  end
-
-end
-
-describe Sinatra::Rabbit::Features do
-  
-  it "should allow to be defined for Sample collection" do
-    Sample.features.wont_be_empty
-    Sample.features.size.must_equal 3
-  end
-
-  it "should allow to be retrieved by name" do
-    Sample.feature(:user_data).wont_be_nil
-    Sample.feature(:user_data).name.must_equal :user_data
-  end
-
-  it "should allow to be defined more times" do
-    Sample.feature(:user_name).wont_be_nil
-    Sample.feature(:user_data).wont_be_nil
-    Sample.feature(:non_existing_one).must_be_nil
-  end
-
-  it "should contain reference to collection" do
-    Sample.feature(:user_data).collection.wont_be_nil
-    Sample.feature(:user_data).collection.must_equal :sample
-  end
-
-  it "should contain array of operations" do
-    Sample.feature(:user_data).operations.wont_be_empty
-    Sample.feature(:user_data).operations.map {|o| o.class }.must_include Sinatra::Rabbit::Feature::Operation
-  end
-
-  it "should allow to return single operation by name" do
-    Sample.feature(:user_data).operation(:index).wont_be_nil
-    Sample.feature(:user_data).operation(:non_existing_one).must_be_nil
-    Sample.feature(:user_data).operation(:index).name.must_equal :index
-  end
-
-  it "should be retrieved from collection" do
-    Sample.collection(:sample).features.wont_be_nil
-    Sample.collection(:sample).features.size.must_equal 2
-    Sample.collection(:second_sample).features.size.must_equal 1
-  end
-
-  it "should add additionals parameters to given operations" do
-    Sample.collection(:sample).operation(:index).params.map { |p| p.name }.must_include :feature_name
-    Sample.collection(:sample).operation(:index).params.map { |p| p.name }.must_include :feature_data
-    Sample.collection(:second_sample).operation(:index).params.map { |p| p.name }.must_include :feature_second
-  end
-
-  it "should not add additional parameters to other operations" do
-    Sample.collection(:sample).operation(:show).params.map { |p| p.name }.wont_include :feature_name
-  end
-
-end

data/tests/fixtures.rb

@@ -1,149 +0,0 @@
-require 'rubygems'
-begin
-  require 'simplecov'
-  if ENV['COVERAGE']
-    SimpleCov.start
-    SimpleCov.command_name 'Minitest Tests'
-  end
-rescue LoadError
-end
-
-require 'minitest/autorun'
-
-require 'sinatra/base'
-$:.unshift File.join(File::dirname(__FILE__), '..')
-require 'lib/sinatra/rabbit'
-
-class Sample < Sinatra::Base
-  include Sinatra::Rabbit
-  include Sinatra::Rabbit::Features
-
-  get '/' do
-    halt 200
-  end
-
-  features do
-    feature :user_data, :for => :sample do
-      operation :index do
-        param :feature_data, :string
-      end
-    end
-    feature :user_name, :for => :sample do
-      operation :index do
-        param :feature_name, :string
-      end
-    end
-    feature :profile_sample, :for => :second_sample do
-      operation :index do
-        param :feature_second, :string
-      end
-    end
-  end
-
-  collection :sample do
-
-    collection :subsample, :with_id => :sub_id do
-
-      collection :secondsubsample do
-        description "SecondSubCollection"
-        operation :index do
-          control do
-            status 200
-          end
-        end
-
-      end
-
-      description "Subcollection"
-
-      operation :start do
-        param :id, :required
-        control do
-          status 200
-        end
-      end
-      operation :show do
-        control do
-          params[:id]
-        end
-      end
-    end
-
-    description "Test"
-
-    operation :index do
-      description "TestIndex"
-      param :id, :string, :required, "TestParam"
-      control do
-        status 200
-      end
-    end
-
-    operation :rindex do
-      description "TestIndex"
-      param :r_string, :string, :required, "TestParam"
-      param :o_string, :string, :optional, "TestParam"
-      param :r_number, :number, :required, "TestParam"
-      param :o_number, :number, :optional, "TestParam"
-      param :free_param, :string
-      param :enum_param, :enum, [1,2,3]
-      param :r_enum_param, :enum, :required, [1,2,3]
-      control {}
-    end
-
-    operation :show do
-      description "TestIndex"
-      control do
-        [200, {}, params[:id]]
-      end
-    end
-
-    operation :create do
-      description "TestIndex"
-      param :id, :string, :required, "TestParam"
-      param :arch, :enum, [1, 2]
-      control do
-        status 200
-      end
-    end
-
-    operation :destroy do
-      description "TestIndex"
-      control do
-        status 201
-      end
-    end
-
-    operation :stop, :if => (1==1) do
-      description "TestIndex"
-      param :id, :string, :required, "TestParam"
-      control do
-        status 200
-      end
-    end
-
-  end
-
-  collection :second_sample do
-    description "SecondTest"
-
-    action :restart do
-      description "Action operation"
-      param :id, :string, :required, "Test"
-      control do
-        status 200
-      end
-    end
-
-    operation :index do
-      description "SecondTestIndex"
-      param :second_id, :string, :required, "TestSecondParam"
-      control do
-        status 200
-      end
-    end
-  end
-
-end
-
-

data/tests/params_test.rb

@@ -1,98 +0,0 @@
-load File.join(File.dirname(__FILE__), 'fixtures.rb')
-
-describe Sinatra::Rabbit::Param do
-
-  def index_operation
-    Sample.collection(:sample).operation(:rindex)
-  end
-
-  it "should return string representation of param" do
-    "#{index_operation.param(:r_string)}".must_equal 'r_string:string:required'
-  end
-
-  it "should allow define required string param with description" do
-    index_operation.param(:r_string).wont_be_nil
-    index_operation.param(:r_string).description.must_equal 'TestParam'
-    index_operation.param(:r_string).klass.must_equal :string
-    index_operation.param(:r_string).values
-    index_operation.param(:r_string).required?.must_equal true
-    index_operation.param(:r_string).string?.must_equal true
-    index_operation.param(:r_string).optional?.must_equal false
-    index_operation.param(:r_string).enum?.must_equal false
-    index_operation.param(:r_string).number?.must_equal false
-  end
-
-  it "should allow define optional string param with description" do
-    index_operation.param(:o_string).wont_be_nil
-    index_operation.param(:o_string).description.must_equal 'TestParam'
-    index_operation.param(:o_string).klass.must_equal :string
-    index_operation.param(:o_string).values
-    index_operation.param(:o_string).required?.must_equal false
-    index_operation.param(:o_string).string?.must_equal true
-    index_operation.param(:o_string).optional?.must_equal true
-    index_operation.param(:o_string).enum?.must_equal false
-    index_operation.param(:o_string).number?.must_equal false
-  end
-
-  it "should allow define required number param with description" do
-    index_operation.param(:r_number).wont_be_nil
-    index_operation.param(:r_number).description.must_equal 'TestParam'
-    index_operation.param(:r_number).klass.must_equal :number
-    index_operation.param(:r_number).values
-    index_operation.param(:r_number).required?.must_equal true
-    index_operation.param(:r_number).string?.must_equal false
-    index_operation.param(:r_number).optional?.must_equal false
-    index_operation.param(:r_number).enum?.must_equal false
-    index_operation.param(:r_number).number?.must_equal true
-  end
-
-  it "should allow define optional number param with description" do
-    index_operation.param(:o_number).wont_be_nil
-    index_operation.param(:o_number).description.must_equal 'TestParam'
-    index_operation.param(:o_number).klass.must_equal :number
-    index_operation.param(:o_number).required?.must_equal false
-    index_operation.param(:o_number).string?.must_equal false
-    index_operation.param(:o_number).optional?.must_equal true
-    index_operation.param(:o_number).enum?.must_equal false
-    index_operation.param(:o_number).number?.must_equal true
-  end
-
-  it "should allow define param just by name and type" do
-    index_operation.param(:free_param).wont_be_nil
-    index_operation.param(:free_param).description.must_equal 'Description not available'
-    index_operation.param(:free_param).klass.must_equal :string
-    index_operation.param(:free_param).values.must_be_nil
-    index_operation.param(:free_param).required?.must_equal false
-    index_operation.param(:free_param).string?.must_equal true
-    index_operation.param(:free_param).optional?.must_equal true
-    index_operation.param(:free_param).enum?.must_equal false
-    index_operation.param(:free_param).number?.must_equal false
-  end
-
-  it "should allow to define optional enum param" do
-    index_operation.param(:enum_param).wont_be_nil
-    index_operation.param(:enum_param).description.must_equal 'Description not available'
-    index_operation.param(:enum_param).klass.must_equal :enum
-    index_operation.param(:enum_param).values.wont_be_empty
-    index_operation.param(:enum_param).values.must_include 2
-    index_operation.param(:enum_param).required?.must_equal false
-    index_operation.param(:enum_param).string?.must_equal false
-    index_operation.param(:enum_param).optional?.must_equal true
-    index_operation.param(:enum_param).enum?.must_equal true
-    index_operation.param(:enum_param).number?.must_equal false
-  end
-
-  it "should allow to define required enum param" do
-    index_operation.param(:r_enum_param).wont_be_nil
-    #index_operation.param(:r_enum_param).description.must_equal 'Description not available'
-    index_operation.param(:r_enum_param).klass.must_equal :enum
-    #index_operation.param(:r_enum_param).values.wont_be_empty
-    #index_operation.param(:r_enum_param).values.must_include 2
-    index_operation.param(:r_enum_param).required?.must_equal true
-    index_operation.param(:r_enum_param).string?.must_equal false
-    index_operation.param(:r_enum_param).optional?.must_equal false
-    #index_operation.param(:r_enum_param).enum?.must_equal true
-    index_operation.param(:r_enum_param).number?.must_equal false
-  end
-
-end