swaggable 0.6.0 → 0.7.0

data/spec/swaggable/check_request_content_type_spec.rb

@@ -0,0 +1,51 @@
+require_relative '../spec_helper'
+
+RSpec.describe 'Swaggable::CheckRequestContentType' do
+  subject { subject_instance }
+  let(:subject_instance) { subject_class.new endpoint: endpoint, request: request }
+  let(:subject_class) { Swaggable::CheckRequestContentType }
+
+  let(:content_types) { endpoint.consumes }
+  let(:endpoint) { Swaggable::EndpointDefinition.new }
+  let(:request) { Swaggable::RackRequestAdapter.new({}) }
+
+  describe '.call' do
+    def do_run
+      subject_class.call endpoint: endpoint, request: request
+    end
+
+    context 'no request content_type' do
+      it 'returns an empty errors collection' do
+        expect(do_run).to be_empty
+      end
+    end
+
+    context 'unsupported request content_type' do
+      before { request.content_type = 'application/json' }
+      before { content_types << :xml }
+
+      it 'returns errors collection' do
+        errors = do_run
+
+        expect(errors.count).to eq 1
+        expect(errors.first).to be_a Swaggable::Errors::Validation
+      end
+    end
+
+    context 'supported request content_type' do
+      before { content_types << :json }
+
+      it 'returns empty errors collection' do
+        errors = do_run
+        expect(errors.count).to eq 0
+      end
+
+      it 'still works with charset=utf-8' do
+        request.content_type = 'application/json; charset=utf-8'
+
+        errors = do_run
+        expect(errors.count).to eq 0
+      end
+    end
+  end
+end

data/spec/swaggable/check_response_code_spec.rb

@@ -0,0 +1,37 @@
+require_relative '../spec_helper'
+
+RSpec.describe 'Swaggable::CheckResponseCode' do
+  subject { subject_instance }
+  let(:subject_instance) { subject_class.new endpoint: endpoint, response: response }
+  let(:subject_class) { Swaggable::CheckResponseCode }
+
+  let(:endpoint) { Swaggable::EndpointDefinition.new }
+  let(:response) { Swaggable::RackResponseAdapter.new }
+
+  describe '.call' do
+    def do_run
+      subject_class.call endpoint: endpoint, response: response
+    end
+
+    context 'supported status code' do
+      it 'returns an empty errors collection' do
+        endpoint.responses.add_new{ status 200 }
+        response.code = 200
+
+        expect(do_run).to be_empty
+      end
+    end
+
+    context 'non supported status code' do
+      it 'returns an empty errors collection' do
+        endpoint.responses.add_new{ status 200 }
+        response.code = 418
+        errors = do_run
+
+        expect(errors.count).to eq 1
+        expect(errors.first).to be_a Swaggable::Errors::Validation
+        expect(errors.message).to match /code/
+      end
+    end
+  end
+end

data/spec/swaggable/check_response_content_type_spec.rb

@@ -0,0 +1,51 @@
+require_relative '../spec_helper'
+
+RSpec.describe 'Swaggable::CheckResponseContentType' do
+  subject { subject_instance }
+  let(:subject_instance) { subject_class.new endpoint: endpoint, response: response }
+  let(:subject_class) { Swaggable::CheckResponseContentType }
+
+  let(:content_types) { endpoint.produces }
+  let(:endpoint) { Swaggable::EndpointDefinition.new }
+  let(:response) { Swaggable::RackResponseAdapter.new }
+
+  describe '.call' do
+    def do_run
+      subject_class.call endpoint: endpoint, response: response
+    end
+
+    context 'no response content_type' do
+      it 'returns an empty errors collection' do
+        expect(do_run).to be_empty
+      end
+    end
+
+    context 'unsupported reponse content_type' do
+      before { response.content_type = 'application/json' }
+      before { content_types << :xml }
+
+      it 'returns errors collection' do
+        errors = do_run
+
+        expect(errors.count).to eq 1
+        expect(errors.first).to be_a Swaggable::Errors::Validation
+      end
+    end
+
+    context 'supported response content_type' do
+      before { content_types << :json }
+
+      it 'returns empty errors collection' do
+        errors = do_run
+        expect(errors.count).to eq 0
+      end
+
+      it 'still works with charset=utf-8' do
+        response.content_type = 'application/json; charset=utf-8'
+
+        errors = do_run
+        expect(errors.count).to eq 0
+      end
+    end
+  end
+end

data/spec/swaggable/endpoint_definition_spec.rb

@@ -15,6 +15,15 @@ RSpec.describe 'Swaggable::EndpointDefinition' do
     expect(subject.verb).to eq  'POST'
   end
 
+  it 'verb is normalized' do
+    subject.verb = :post
+    expect(subject.verb).to eq 'POST'
+  end
+
+  it 'verb is GET by default' do
+    expect(subject_class.new.verb).to eq 'GET'
+  end
+
   it 'has a description' do
     subject.description = 'a new desc'
     expect(subject.description).to eq  'a new desc'
@@ -74,4 +83,42 @@ RSpec.describe 'Swaggable::EndpointDefinition' do
 
     expect(subject.responses[418].description).to eq 'Teapot'
   end
+
+  describe 'match?' do
+    it 'matches if verb and path are valid' do
+      endpoint = subject_class.new path: '/users/{id}/avatar', verb: 'GET'
+      expect(endpoint.match? :get, '/users/37/avatar').to be true
+    end
+
+    it 'doesn\'t match if verb is invalid' do
+      endpoint = subject_class.new path: '/users/{id}/avatar', verb: 'GET'
+      expect(endpoint.match? :put, '/users/37/avatar').to be false
+    end
+
+    it 'doesn\'t match if path is invalid' do
+      endpoint = subject_class.new path: '/users/{id}/quota', verb: 'GET'
+      expect(endpoint.match? :get, '/users/37/avatar').to be false
+    end
+  end
+
+  describe 'path_parameters_for' do
+    it 'returns path matches' do
+      endpoint = subject_class.new path: '/users/{id}/avatar', verb: 'GET'
+      match = endpoint.path_parameters_for '/users/37/avatar'
+      expect(match['id']).to eq '37'
+    end
+
+    it 'returns {} when no matches' do
+      endpoint = subject_class.new path: '/', verb: 'GET'
+      match = endpoint.path_parameters_for '/'
+      expect(match).to eq Hash.new
+    end
+  end
+
+  describe 'body' do
+    it 'returns the body param' do
+      body = subject.parameters.add_new { location :body }
+      expect(subject.body).to be body
+    end
+  end
 end

data/spec/swaggable/endpoint_validator_spec.rb

@@ -0,0 +1,102 @@
+require_relative '../spec_helper'
+require 'rack'
+
+RSpec.describe 'Swaggable::EndpointValidator' do
+  subject { subject_instance }
+  let(:subject_instance) { subject_class.new endpoint: endpoint_definition, request: request }
+  let(:subject_class) { Swaggable::EndpointValidator }
+  let(:request) { request_for :get, '/existing_endpoint' }
+  let(:response) { Swaggable::RackResponseAdapter.new [200, {}, []] }
+  let(:endpoint_definition) { api_definition.endpoints.first }
+  let(:some_error) { double('some_error') }
+  let(:endpoint) { api_definition.endpoints.first }
+
+  let :api_definition do
+    Swaggable::ApiDefinition.new do
+      endpoints.add_new do
+        path '/existing_endpoint'
+        verb :get
+      end
+    end
+  end
+
+  def request_for verb, path
+    Swaggable::RackRequestAdapter.new Rack::MockRequest.env_for path, 'REQUEST_METHOD' => verb
+  end
+
+  describe '#errors_for_request(request)' do
+    def returns_some_error check
+      allow(check).to receive(:call).
+        with(endpoint: endpoint, request: request).
+        and_return([some_error])
+    end
+
+    def returns_no_error check
+      allow(check).to receive(:call).
+        with(endpoint: endpoint, request: request).
+        and_return([])
+    end
+
+    before do
+      returns_no_error Swaggable::CheckMandatoryParameters
+      returns_no_error Swaggable::CheckExpectedParameters
+      returns_no_error Swaggable::CheckRequestContentType
+    end
+
+    it 'is empty when all is correct' do
+      expect(subject.errors_for_request(request)).to be_empty
+    end
+
+    it 'validates the content type' do
+      returns_some_error Swaggable::CheckRequestContentType
+      expect(subject.errors_for_request(request)).to include(some_error)
+    end
+
+    it 'validates all mandatory parameters are present' do
+      returns_some_error Swaggable::CheckMandatoryParameters
+      expect(subject.errors_for_request(request)).to include(some_error)
+    end
+
+    it 'validates expected parameters' do
+      returns_some_error Swaggable::CheckExpectedParameters
+      expect(subject.errors_for_request(request)).to include(some_error)
+    end
+
+    it 'validates body schema' do
+      body = endpoint.parameters.add_new { location :body }
+      returns_some_error Swaggable::CheckBodySchema
+      expect(subject.errors_for_request(request)).to include(some_error)
+    end
+  end
+
+  describe '#errors_for_response(response)' do
+    def returns_some_error check
+      allow(check).to receive(:call).
+        with(endpoint: endpoint, response: response).
+        and_return([some_error])
+    end
+
+    def returns_no_error check
+      allow(check).to receive(:call).
+        with(endpoint: endpoint, response: response).
+        and_return([])
+    end
+
+    before do
+      returns_no_error Swaggable::CheckResponseContentType
+    end
+
+    it 'validates content type' do
+      returns_some_error Swaggable::CheckResponseContentType
+      expect(subject.errors_for_response(response)).to include(some_error)
+    end
+
+    it 'validates status code' do
+      returns_some_error Swaggable::CheckResponseCode
+      expect(subject.errors_for_response(response)).to include(some_error)
+    end
+
+    # TODO:
+    # it 'validates response body'
+  end
+end

data/spec/swaggable/errors/validations_collection_spec.rb

@@ -0,0 +1,78 @@
+require_relative '../../spec_helper'
+
+RSpec.describe 'Swaggable::Errors::ValidationsCollection' do
+  let(:subject_class) { Swaggable::Errors::ValidationsCollection }
+  let(:subject_instance) { subject_class.new }
+  subject { subject_instance }
+  let(:error) { new_error }
+
+  def new_error *args
+    Swaggable::Errors::Validation.new  *args
+  end
+
+  it 'can be instantiated' do
+    subject
+  end
+
+  describe '#<<' do
+    it 'adds Errors::Validation as is' do
+      subject << error
+      expect(subject.last).to be error
+    end
+  end
+
+  describe '#each' do
+    it 'iterates through the list' do
+      subject << error
+
+      list = []
+      subject.each {|e| list << e }
+
+      expect(list.last).to be error
+    end
+  end
+
+  describe '#inspect' do
+    it 'is readable' do
+      subject << new_error('Problem 1')
+      subject << new_error('Problem 2')
+      expect(subject.inspect).to eq "#<Swaggable::Errors::ValidationsCollection: Problem 1. Problem 2.>"
+    end
+  end
+
+  describe '#merge!' do
+    it 'joins arrays' do
+      other = subject_class.new
+
+      error_1 = new_error
+      error_2 = new_error
+
+      subject << new_error
+
+      subject.merge!([error_2])
+
+      expect(subject.to_a).to eq [error_1, error_2]
+    end
+  end
+
+  describe '#raise' do
+    it 'raises itself' do
+      expect{ raise subject }.to raise_error(subject_class)
+    end
+
+    it 'has a composite message' do
+      subject << new_error('Problem 1')
+      subject << new_error('Problem 2')
+
+      expect(subject.message).to eq 'Problem 1. Problem 2.'
+    end
+  end
+
+  describe '#empty' do
+    it 'is true when no errors are inside' do
+      expect(subject).to be_empty
+      subject << new_error('An error')
+      expect(subject).not_to be_empty
+    end
+  end
+end

data/spec/swaggable/grape_adapter_spec.rb

@@ -41,7 +41,7 @@ RSpec.describe 'Swaggable::GrapeAdapter' do
       it 'sets verb' do
         grape.post { }
         do_import
-        expect(api.endpoints.first.verb).to eq 'post'
+        expect(api.endpoints.first.verb).to eq 'POST'
       end
 
       it 'sets description as summary' do
@@ -220,7 +220,7 @@ RSpec.describe 'Swaggable::GrapeAdapter' do
 
           do_import
 
-          parameter = api.endpoints['POST /'].parameters[:first_name]
+          parameter = api.endpoints['POST /'].parameters['first_name']
           expect(parameter).to be parameter_definition
         end
       end

data/spec/swaggable/mime_type_definition_spec.rb

@@ -0,0 +1,96 @@
+require_relative '../spec_helper'
+
+RSpec.describe 'Swaggable::MimeTypeDefinition' do
+  let(:subject_class) { Swaggable::MimeTypeDefinition }
+  let(:subject_instance) { subject_class.new :json }
+  subject { subject_instance }
+
+  describe '.new' do
+    it 'accepts a symbol with the subtype' do
+      expect(subject.name).to eq('application/json')
+    end
+
+    it 'accepts a symbol with the subtype with underescores' do
+      subject = subject_class.new :octet_stream
+      expect(subject.name).to eq('application/octet-stream')
+    end
+
+    it 'accepts a name' do
+      expect(subject.name).to eq('application/json')
+    end
+
+    it 'accepts options' do
+      subject = subject_class.new 'application/json; charset=utf-8'
+      expect(subject.name).to eq('application/json')
+    end
+  end
+
+  describe '#name' do
+    it 'is type/subtype' do
+      expect(subject.name).to eq('application/json')
+    end
+  end
+
+  describe '#to_s' do
+    it 'is the name' do
+      expect(subject.to_s).to eq(subject.name)
+    end
+  end
+
+  describe '#http_string' do
+    it 'is "type/subtype; parameters"' do
+      expect(subject.http_string).to match(/^application\/json.*$/)
+    end
+
+    it 'contains options' do
+      subject = subject_class.new 'application/json; charset=utf-8'
+      expect(subject.http_string).to eq('application/json; charset=utf-8')
+    end
+  end
+
+  describe '#to_sym' do
+    describe 'when type is application' do
+      it 'is the subtype with underescores' do
+        subject = subject_class.new 'application/octet-stream'
+        expect(subject.to_sym).to eq(:octet_stream)
+      end
+    end
+
+    describe 'when type is NOT application' do
+      it 'is the name with underescores' do
+        subject = subject_class.new 'random/sub-type.with.dots'
+        expect(subject.to_sym).to eq(:random_sub_type_with_dots)
+      end
+    end
+  end
+
+  describe '#inspect' do
+    it 'is #<Swaggable::ContentTypeDefinition: type/subtype>' do
+      expect(subject.inspect).to eq('#<Swaggable::ContentTypeDefinition: application/json>')
+    end
+  end
+
+  describe '#==' do
+    it 'equals by name' do
+      type_1 = subject_class.new :json
+      type_1_again = subject_class.new :json
+      type_2 = subject_class.new :xml
+
+      expect(type_1).to eq type_1_again
+      expect([type_1, type_1_again].uniq.length).to eq 1
+      expect(type_1).not_to eq type_2
+    end
+
+    it 'equals by symbol' do
+      expect(subject == :json).to be true
+    end
+
+    it 'equals string' do
+      expect(subject == 'application/json').to be true
+    end
+
+    it 'doesn\'t throw error if comparing with any random object' do
+      expect{ subject == double }.not_to raise_error
+    end
+  end
+end