grape-swagger 0.7.2 → 0.8.0

data/spec/default_api_spec.rb

@@ -1,10 +1,9 @@
 require 'spec_helper'
 
-describe "Default API" do
-
+describe 'Default API' do
   context 'with no additional options' do
-    before :all do
-      class NotAMountedApi < Grape::API
+    def app
+      Class.new(Grape::API) do
         format :json
         desc 'This gets something.'
         get '/something' do
@@ -14,37 +13,36 @@ describe "Default API" do
       end
     end
 
-    def app; NotAMountedApi; end
-
-    it "should document something" do
+    subject do
       get '/swagger_doc'
-      JSON.parse(last_response.body).should == {
-        "apiVersion" => "0.1",
-        "swaggerVersion" => "1.2",
-        "basePath" => "http://example.org",
-        "info" => {},
-        "produces" => ["application/json"],
-        "operations" => [],
-        "apis" => [
-          { "path" => "/swagger_doc/something.{format}" },
-          { "path" => "/swagger_doc/swagger_doc.{format}" }
+      JSON.parse(last_response.body)
+    end
+
+    it 'documents api' do
+      expect(subject).to eq(
+        'apiVersion' => '0.1',
+        'swaggerVersion' => '1.2',
+        'info' => {},
+        'produces' => ['application/json'],
+        'apis' => [
+          { 'path' => '/something.{format}', 'description' => 'Operations about somethings' },
+          { 'path' => '/swagger_doc.{format}', 'description' => 'Operations about swagger_docs' }
         ]
-      }
+      )
     end
-    
-    context "path inside the apis array" do
-      it "should start with a forward slash" do
-        get '/swagger_doc'
-        JSON.parse(last_response.body)['apis'].each do |api|
-          api['path'].should start_with "/"
+
+    context 'path inside the apis array' do
+      it 'starts with a forward slash' do
+        subject['apis'].each do |api|
+          expect(api['path']).to start_with '/'
         end
       end
     end
   end
 
-  context 'with API info' do
-    before :all do
-      class ApiInfoTest < Grape::API
+  context 'with additional info' do
+    def app
+      Class.new(Grape::API) do
         format :json
         add_swagger_documentation info: {
           title: 'My API Title',
@@ -55,20 +53,18 @@ describe "Default API" do
           contact: 'support@test.com'
         }
       end
-      get '/swagger_doc'
     end
 
-    def app; ApiInfoTest; end
-
     subject do
+      get '/swagger_doc'
       JSON.parse(last_response.body)['info']
     end
 
-    it 'should document API title' do
+    it 'documents API title' do
       expect(subject['title']).to eql('My API Title')
     end
 
-    it 'should document API description' do
+    it 'documents API description' do
       expect(subject['description']).to eql('A description of my API')
     end
 
@@ -76,17 +72,16 @@ describe "Default API" do
       expect(subject['license']).to eql('Apache 2')
     end
 
-    it 'should document the license url' do
+    it 'documents the license url' do
       expect(subject['licenseUrl']).to eql('http://test.com')
     end
 
-    it 'should document the terms of service url' do
+    it 'documents the terms of service url' do
       expect(subject['termsOfServiceUrl']).to eql('http://terms.com')
     end
 
-    it 'should document the contact email' do
+    it 'documents the contact email' do
       expect(subject['contact']).to eql('support@test.com')
     end
   end
-
 end

data/spec/form_params_spec.rb

@@ -1,29 +1,30 @@
 require 'spec_helper'
 
-describe "Form Params" do
-
-  before :all do
-    class FormParamApi < Grape::API
+describe 'Form Params' do
+  def app
+    Class.new(Grape::API) do
       format :json
 
       params do
-        requires :name, type: String, desc: "name of item"
+        requires :name, type: String, desc: 'name of item'
       end
       post '/items' do
         {}
       end
 
       params do
-        requires :id, type: Integer, desc: "id of item"
-        requires :name, type: String, desc: "name of item"
+        requires :id, type: Integer, desc: 'id of item'
+        requires :name, type: String, desc: 'name of item'
+        requires :conditions, type: Integer, desc: 'conditions of item', values: [1, 2, 3]
       end
       put '/items/:id' do
         {}
       end
 
       params do
-        requires :id, type: Integer, desc: "id of item"
-        requires :name, type: String, desc: "name of item"
+        requires :id, type: Integer, desc: 'id of item'
+        requires :name, type: String, desc: 'name of item'
+        optional :conditions, type: String, desc: 'conditions of item', values: proc { %w(1 2) }
       end
       patch '/items/:id' do
         {}
@@ -33,51 +34,53 @@ describe "Form Params" do
     end
   end
 
-  def app; FormParamApi; end
-
-  it "retrieves the documentation form params" do
+  subject do
     get '/swagger_doc/items.json'
+    JSON.parse(last_response.body)
+  end
 
-    JSON.parse(last_response.body).should == {
-      "apiVersion" => "0.1",
-      "swaggerVersion" => "1.2",
-      "resourcePath" => "",
-      "basePath"=>"http://example.org",
-      "apis" => [
-        {
-          "path" => "/items.{format}",
-          "operations" => [
-            {
-              "produces" => ["application/json"],
-              "notes" => "",
-              "summary" => "",
-              "nickname" => "POST-items---format-",
-              "httpMethod" => "POST",
-              "parameters" => [ { "paramType" => "form", "name" => "name", "description" => "name of item", "type" => "String", "dataType" => "String", "required" => true } ]
-            }
-          ]
-        }, {
-          "path" => "/items/{id}.{format}",
-          "operations" => [
-            {
-              "produces" => ["application/json"],
-              "notes" => "",
-              "summary" => "",
-              "nickname" => "PUT-items--id---format-",
-              "httpMethod" => "PUT",
-              "parameters" => [ { "paramType" => "path", "name" => "id", "description" => "id of item", "type" => "Integer", "dataType" => "Integer", "required" => true }, { "paramType" => "form", "name" => "name", "description" => "name of item", "type" => "String", "dataType" => "String", "required" => true } ]
-            },
-            {
-              "produces" => ["application/json"],
-              "notes" => "",
-              "summary" => "",
-              "nickname" => "PATCH-items--id---format-",
-              "httpMethod" => "PATCH",
-              "parameters" => [ { "paramType" => "path", "name" => "id", "description" => "id of item", "type" => "Integer", "dataType" => "Integer", "required" => true }, { "paramType" => "form", "name" => "name", "description" => "name of item", "type" => "String", "dataType" => "String", "required" => true } ]
-            }
-          ]
-        }
-      ]
-    }
+  it 'retrieves the documentation form params' do
+    expect(subject['apis']).to eq([
+      {
+        'path' => '/items.{format}',
+        'operations' => [
+          {
+            'notes' => '',
+            'summary' => '',
+            'nickname' => 'POST-items---format-',
+            'method' => 'POST',
+            'parameters' => [{ 'paramType' => 'form', 'name' => 'name', 'description' => 'name of item', 'type' => 'string', 'required' => true, 'allowMultiple' => false }],
+            'type' => 'void'
+          }
+        ]
+      }, {
+        'path' => '/items/{id}.{format}',
+        'operations' => [
+          {
+            'notes' => '',
+            'summary' => '',
+            'nickname' => 'PUT-items--id---format-',
+            'method' => 'PUT',
+            'parameters' => [
+              { 'paramType' => 'path', 'name' => 'id', 'description' => 'id of item', 'type' => 'integer', 'required' => true, 'allowMultiple' => false, 'format' => 'int32' },
+              { 'paramType' => 'form', 'name' => 'name', 'description' => 'name of item', 'type' => 'string', 'required' => true, 'allowMultiple' => false },
+              { 'paramType' => 'form', 'name' => 'conditions', 'description' => 'conditions of item', 'type' => 'integer', 'required' => true, 'allowMultiple' => false, 'format' => 'int32', 'enum' => [1, 2, 3] }
+            ],
+            'type' => 'void'
+          },
+          {
+            'notes' => '',
+            'summary' => '',
+            'nickname' => 'PATCH-items--id---format-',
+            'method' => 'PATCH',
+            'parameters' => [
+              { 'paramType' => 'path', 'name' => 'id', 'description' => 'id of item', 'type' => 'integer', 'required' => true, 'allowMultiple' => false, 'format' => 'int32' },
+              { 'paramType' => 'form', 'name' => 'name', 'description' => 'name of item', 'type' => 'string', 'required' => true, 'allowMultiple' => false },
+              { 'paramType' => 'form', 'name' => 'conditions', 'description' => 'conditions of item', 'type' => 'string', 'required' => false, 'allowMultiple' => false, 'enum' => %w(1 2) }
+            ],
+            'type' => 'void'
+          }
+        ]
+      }])
   end
 end

data/spec/grape-swagger_helper_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe "helpers" do
+describe 'helpers' do
 
   before :all do
     class HelperTestAPI < Grape::API
@@ -8,98 +8,137 @@ describe "helpers" do
     end
   end
 
-  before :each do
-    @api = Object.new
+  subject do
+    api = Object.new
 
     # after injecting grape-swagger into the Test API we get the helper methods
     # back from the first endpoint's class (the API mounted by grape-swagger
     # to serve the swagger_doc
 
-    @api.extend HelperTestAPI.endpoints.first.options[:app].helpers
+    api.extend HelperTestAPI.endpoints.first.options[:app].helpers
+    api
   end
 
-  context "parsing parameters" do
-    it "parses params as query strings for a GET" do
+  context 'parsing parameters' do
+    it 'parses params as query strings for a GET' do
       params = {
-        name: { type: 'String', desc: "A name", required: true, defaultValue: 'default' },
+        name: { type: 'String', desc: 'A name', required: true, default: 'default' },
         level: 'max'
       }
-      path = "/coolness"
-      method = "GET"
-      @api.parse_params(params, path, method).should == [
-        { paramType: "query", name: :name, description: "A name", type: "String", dataType: "String", required: true, defaultValue: 'default' },
-        { paramType: "query", name: :level, description: "", type: "String", dataType: "String", required: false }
+      path = '/coolness'
+      method = 'GET'
+      expect(subject.parse_params(params, path, method)).to eq [
+        { paramType: 'query', name: :name, description: 'A name', type: 'string', required: true, allowMultiple: false, defaultValue: 'default' },
+        { paramType: 'query', name: :level, description: '', type: 'string', required: false, allowMultiple: false }
       ]
     end
 
-    it "parses params as form for a POST" do
+    it 'parses params as form for a POST' do
       params = {
-        name: { type: 'String', :desc => "A name", required: true },
+        name: { type: 'String', desc: 'A name', required: true },
         level: 'max'
       }
-      path = "/coolness"
-      method = "POST"
-      @api.parse_params(params, path, method).should == [
-        { paramType: "form", name: :name, description: "A name", type: "String", dataType: "String", required: true },
-        { paramType: "form", name: :level, description: "", type: "String", dataType: "String", required: false }
+      path = '/coolness'
+      method = 'POST'
+      expect(subject.parse_params(params, path, method)).to eq [
+        { paramType: 'form', name: :name, description: 'A name', type: 'string', required: true, allowMultiple: false },
+        { paramType: 'form', name: :level, description: '', type: 'string', required: false, allowMultiple: false }
       ]
     end
 
-    context "custom type" do
+    it 'parses file param' do
+      params = {
+        rack: {
+          type: 'Rack::Multipart::UploadedFile',
+          desc: 'rack file',
+          datafile: 'content',
+          required: true
+        },
+        rails: {
+          type: 'Hash',
+          desc: 'rails file',
+          datafile: 'content',
+          required: true
+        }
+      }
+      path = '/coolness'
+      method = 'POST'
+      expect(subject.parse_params(params, path, method)).to eq [
+        {
+          paramType: 'body',
+          name: :rack,
+          description: 'rack file',
+          type: 'File',
+          required: true,
+          allowMultiple: false
+        },
+        {
+          paramType: 'body',
+          name: :rails,
+          description: 'rails file',
+          type: 'File',
+          required: true,
+          allowMultiple: false
+        }
+      ]
+
+    end
+
+    context 'custom type' do
       before :all do
         class CustomType
         end
       end
-      it "parses a custom parameters" do
+      it 'parses a custom parameters' do
         params = {
-          option: { type: CustomType, desc: "Custom option" }
+          option: { type: CustomType, desc: 'Custom option' }
         }
-        path = "/coolness"
-        method = "GET"
-        @api.parse_params(params, path, method).should == [
-          { paramType: "query", name: :option, description: "Custom option", type: "CustomType", dataType: "CustomType", required: false }
+        path = '/coolness'
+        method = 'GET'
+        expect(subject.parse_params(params, path, method)).to eq [
+          { paramType: 'query', name: :option, description: 'Custom option', type: 'CustomType', required: false, allowMultiple: false }
         ]
       end
     end
 
   end
 
-  context "parsing the path" do
-    it "parses the path" do
-      path = ":abc/def(.:format)"
-      @api.parse_path(path, nil).should == "{abc}/def.{format}"
+  context 'parsing the path' do
+    it 'parses the path' do
+      path = ':abc/def(.:format)'
+      expect(subject.parse_path(path, nil)).to eq '{abc}/def.{format}'
     end
 
-    it "parses a path that has vars with underscores in the name" do
-      path = "abc/:def_g(.:format)"
-      @api.parse_path(path, nil).should == "abc/{def_g}.{format}"
+    it 'parses a path that has vars with underscores in the name' do
+      path = 'abc/:def_g(.:format)'
+      expect(subject.parse_path(path, nil)).to eq 'abc/{def_g}.{format}'
     end
 
-    it "parses a path that has vars with numbers in the name" do
-      path = "abc/:sha1(.:format)"
-      @api.parse_path(path, nil).should == "abc/{sha1}.{format}"
+    it 'parses a path that has vars with numbers in the name' do
+      path = 'abc/:sha1(.:format)'
+      expect(subject.parse_path(path, nil)).to eq 'abc/{sha1}.{format}'
     end
 
-    it "parses a path that has multiple variables" do
-      path1 = "abc/:def/:geh(.:format)"
-      path2 = "abc/:def:geh(.:format)"
-      @api.parse_path(path1, nil).should == "abc/{def}/{geh}.{format}"
-      @api.parse_path(path2, nil).should == "abc/{def}{geh}.{format}"
+    it 'parses a path that has multiple variables' do
+      path1 = 'abc/:def/:geh(.:format)'
+      path2 = 'abc/:def:geh(.:format)'
+      expect(subject.parse_path(path1, nil)).to eq 'abc/{def}/{geh}.{format}'
+      expect(subject.parse_path(path2, nil)).to eq 'abc/{def}{geh}.{format}'
     end
 
-    it "parses the path with a specified version" do
-      path = ":abc/{version}/def(.:format)"
-      @api.parse_path(path, 'v1').should == "{abc}/v1/def.{format}"
+    it 'parses the path with a specified version' do
+      path = ':abc/{version}/def(.:format)'
+      expect(subject.parse_path(path, 'v1')).to eq '{abc}/v1/def.{format}'
     end
   end
 
-  context "parsing header parameters" do
-    it "parses params for the header" do
+  context 'parsing header parameters' do
+    it 'parses params for the header' do
       params = {
-        "XAuthToken" => { description: "A required header.", required: true, defaultValue: 'default' }
+        'XAuthToken' => { description: 'A required header.', required: true, default: 'default' }
       }
-      @api.parse_header_params(params).should == [
-        { paramType: "header", name: "XAuthToken", description: "A required header.", type: "String", dataType: "String", required: true, defaultValue: 'default' }
+      expect(subject.parse_header_params(params)).to eq [
+        { paramType: 'header', name: 'XAuthToken', description: 'A required header.', type: 'String', required: true, defaultValue: 'default' }
       ]
     end
   end

data/spec/grape-swagger_spec.rb

@@ -1,13 +1,15 @@
 require 'spec_helper'
 
 describe Grape::API do
-
-  it "added combined-routes" do
-    Grape::API.should respond_to :combined_routes
+  it 'added combined-routes' do
+    expect(Grape::API).to respond_to :combined_routes
   end
 
-  it "added add_swagger_documentation" do
-    Grape::API.should respond_to :add_swagger_documentation
+  it 'added add_swagger_documentation' do
+    expect(Grape::API).to respond_to :add_swagger_documentation
   end
 
+  it 'added combined-namespaces' do
+    expect(Grape::API).to respond_to :combined_namespaces
+  end
 end