swaggable 0.6.0 → 0.7.0

data/spec/integration/rack_app_spec.rb

@@ -0,0 +1,44 @@
+require_relative '../spec_helper'
+require 'rack/test'
+require 'grape'
+
+RSpec.describe 'Integration' do
+  context 'RackApp' do
+    include Rack::Test::Methods
+
+    def app
+      subject
+    end
+
+    subject { rack_app }
+    let(:rack_app) { Swaggable::RackApp.new(api_definition: api_def) }
+    let(:api_def) { Swaggable::ApiDefinition.from_grape_api(grape_api) }
+
+    let(:grape_api) do
+      Class.new(Grape::API).tap do |g|
+        g.params do
+          requires :user_uuid
+        end
+
+        g.get '/' do
+          status 200
+          body({some: 'body'})
+        end
+
+      end.tap do |grape|
+        stub_const('MyGrapeApi', grape)
+      end
+    end
+
+    it 'has status 200 OK' do
+      get '/'
+      expect(last_response.status).to eq 200
+      expect(last_response.headers['Content-Type']).to eq 'application/json'
+    end
+
+    it 'validates' do
+      expect(subject.validate!).to be true
+    end
+  end
+end
+

data/spec/integration/validating_rack_app_spec.rb

@@ -0,0 +1,50 @@
+require_relative '../spec_helper'
+require 'rack/test'
+require 'grape'
+
+RSpec.describe 'Integration' do
+  describe 'ValidatorRackApp' do
+    include Rack::Test::Methods
+
+    def app_to_validate
+      @app_to_validate ||= -> env { [200, {}, []] }
+    end
+
+    def app
+      Swaggable::ValidatingRackApp.new app: app_to_validate, definition: definition
+    end
+
+    let :definition do
+      Swaggable::ApiDefinition.new do
+        endpoints.add_new do
+          path '/existing_endpoint'
+          verb :get
+
+          responses.add_new do
+            status 200
+            description 'Success'
+          end
+
+          consumes << :json
+          produces << :json
+        end
+      end
+    end
+
+    it 'does nothing if the validations pass' do
+      expect{ get '/existing_endpoint', {}, 'CONTENT_TYPE' => 'application/json' }.
+        not_to raise_error
+    end
+
+    it 'raises an exception if request validation doesn\'t pass' do
+      expect{ get '/existing_endpoint', {}, 'CONTENT_TYPE' => 'application/xml' }.
+        to raise_error Swaggable::Errors::Validation
+    end
+
+    it 'raises an exception if response validation doesn\'t pass' do
+      @app_to_validate = -> env { [418, {'Content-Type' => 'application/xml'}, ['']] }
+      expect{ get '/existing_endpoint' }.to raise_error Swaggable::Errors::Validation
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -4,11 +4,15 @@ require 'pry'
 require 'webmock/rspec'
 
 RSpec.configure do |config|
-   config.color = true
-   config.tty = true
-   config.disable_monkey_patching!
-   # config.full_backtrace = true
-   # config.formatter = :documentation # :documentation, :progress, :html, :textmate
+  config.color = true
+  config.tty = true
+  config.disable_monkey_patching!
+  # config.full_backtrace = true
+  # config.formatter = :documentation # :documentation, :progress, :html, :textmate
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
 end
 
 WebMock.disable_net_connect!(:allow => "codeclimate.com")

data/spec/swaggable/api_validator_spec.rb

@@ -0,0 +1,61 @@
+require_relative '../spec_helper'
+require 'rack'
+
+RSpec.describe 'Swaggable::ApiValidator' do
+  subject { subject_instance }
+  let(:subject_instance) { subject_class.new definition: api_definition, request: api_request }
+  let(:subject_class) { Swaggable::ApiValidator }
+  let(:api_request) { request :get, '/existing_endpoint' }
+  let(:api_response) { [200, {}, []] }
+
+  let :api_definition do
+    Swaggable::ApiDefinition.new do
+      endpoints.add_new do
+        path '/existing_endpoint'
+        verb :get
+      end
+    end
+  end
+
+  def request verb, path
+    Rack::MockRequest.env_for path, 'REQUEST_METHOD' => verb
+  end
+
+  describe '#endpoint_validator' do
+    it 'has the right endpoint' do
+      expect(subject.endpoint_validator.endpoint).to be subject.endpoint
+    end
+
+    it 'raises an exception if no endpoint was found' do
+      api_definition.endpoints.first.path '/another_path'
+      expect{ subject.endpoint_validator }.
+        to raise_error(Swaggable::Errors::EndpointNotFound)
+    end
+  end
+
+  describe '#errors_for_request()' do
+    it 'delegates to the endpoint_validator' do
+      errors = double('errors')
+
+      allow(subject.endpoint_validator).
+        to receive(:errors_for_request).
+        with(api_request).
+        and_return(errors)
+
+      expect(subject.errors_for_request).to be errors
+    end
+  end
+
+  describe '#errors_for_response(response)' do
+    it 'delegates to the endpoint_validator' do
+      errors = double('errors')
+
+      allow(subject.endpoint_validator).
+        to receive(:errors_for_response).
+        with(api_response).
+        and_return(errors)
+
+      expect(subject.errors_for_response api_response).to be errors
+    end
+  end
+end

data/spec/swaggable/check_body_schema_spec.rb

@@ -0,0 +1,94 @@
+require_relative '../spec_helper'
+require 'rack'
+
+RSpec.describe 'Swaggable::CheckBodySchema' do
+  subject { subject_instance }
+  let(:subject_instance) { subject_class.new }
+  let(:subject_class) { Swaggable::CheckBodySchema }
+
+
+  let(:request) do
+    Swaggable::RackRequestAdapter.new Rack::MockRequest.env_for('/', {
+      'REQUEST_METHOD' =>  'POST',
+      'CONTENT_TYPE' => content_type,
+      :input => body,
+    })
+  end
+
+  let(:verb) { 'POST' }
+  let(:content_type) { nil }
+  let(:body) { nil }
+
+  let(:endpoint) { Swaggable::EndpointDefinition.new }
+  let(:body_definition) { endpoint.parameters.add_new { location :body } }
+
+  def do_run
+    subject_class.call endpoint: endpoint, request: request
+  end
+
+  describe '.call' do
+    context 'present and there is no schema' do
+      let(:body) { '{}' }
+      before { body_definition.required true }
+
+      it 'returns no error' do
+        expect(do_run).to be_empty
+      end
+    end
+
+    context 'present and matches schema' do
+      let(:content_type) { 'application/json' }
+      let(:body) { '{"name":"John"}' }
+
+      before do
+        body_definition.schema.attributes.add_new { name 'name'; type :string }
+      end
+
+      it 'returns no error' do
+        expect(do_run).to be_empty
+      end
+    end
+
+    context 'when required but not present' do
+      before { body_definition.required true }
+
+      it 'returns error' do
+        errors = do_run
+        expect(errors.count).to eq 1
+        expect(errors.first.message).to match /body/
+      end
+    end
+
+    context 'when present but missing required attribute' do
+      let(:content_type) { 'application/json' }
+      let(:body) { '{}' }
+
+      before do
+        body_definition.required true
+        body_definition.schema.attributes.add_new { name 'name'; type :string; required true }
+      end
+
+      it 'returns error' do
+        errors = do_run
+        expect(errors.count).to eq 1
+        expect(errors.first.message).to match /body/
+      end
+    end
+
+    context 'when present but missing unexpected attribute' do
+      let(:content_type) { 'application/json' }
+      let(:body) { '{"made_up_attribute":42}' }
+
+      before do
+        body_definition.required true
+        body_definition.schema.attributes.add_new { name 'name'; type :string }
+      end
+
+      it 'returns error' do
+        errors = do_run
+        expect(errors.count).to eq 1
+        expect(errors.first.message).to match /body/
+      end
+    end
+  end
+end

data/spec/swaggable/check_expected_parameters_spec.rb

@@ -0,0 +1,110 @@
+require_relative '../spec_helper'
+require 'rack'
+
+RSpec.describe 'Swaggable::CheckExpectedParameters' do
+  subject { subject_instance }
+  let(:subject_instance) { subject_class.new }
+  let(:subject_class) { Swaggable::CheckExpectedParameters }
+
+  let(:parameters) { endpoint.parameters }
+  let(:endpoint) { Swaggable::EndpointDefinition.new { path '/' } }
+  let(:request) { Swaggable::RackRequestAdapter.new Rack::MockRequest.env_for("#{path}?#{query_string}") }
+  let(:path) { '/' }
+  let(:query_string) { '' }
+
+  def do_run
+    subject_class.call endpoint: endpoint, request: request
+  end
+
+  describe '.call' do
+    context 'present parameter is expected' do
+      it 'returns an empty errors list' do
+        expect(do_run).to be_empty
+      end
+    end
+
+    context 'present parameter is unexpected' do
+      let(:query_string) { 'name=John' }
+
+      it 'returns an empty errors list' do
+        errors = do_run
+        expect(errors.count).to eq 1
+        expect(errors.first.message).to match /name/
+      end
+    end
+
+  #   context 'all mandatory parameters are present' do
+  #     before do
+  #       parameters.add_new { name :email; required true }
+  #       request.query_parameters[:email] = 'user@example.com'
+  #     end
+
+  #     it 'returns no errors' do
+  #       expect(do_run).to be_empty
+  #     end
+  #   end
+
+  #   context 'missing mandatory parameters undefined location' do
+  #     before do
+  #       parameters.add_new { name :email; required true }
+  #     end
+
+  #     it 'returns an error per missing parameter' do
+  #       errors = do_run
+  #       expect(errors.count).to eq 1
+  #       expect(errors.first.message).to match /email/
+  #     end
+  #   end
+
+  #   context 'missing mandatory query param' do
+  #     before do
+  #       parameters.add_new { name :email; required true; location :query }
+  #     end
+
+  #     it 'returns an error per missing parameter' do
+  #       errors = do_run
+  #       expect(errors.count).to eq 1
+  #       expect(errors.first.message).to match /email/
+  #     end
+  #   end
+
+  #   context 'missing mandatory path param' do
+  #     before do
+  #       parameters.add_new { name 'user_id'; required true; location :path }
+  #     end
+
+  #     it 'returns an error per missing parameter' do
+  #       errors = do_run
+  #       expect(errors.count).to eq 1
+  #       expect(errors.first.message).to match /user_id/
+  #     end
+  #   end
+
+  #   context 'present mandatory path param' do
+  #     let(:path) { '/users/37.json' }
+
+  #     before do
+  #       endpoint.path '/users/{user_id}.json'
+  #       parameters.add_new { name 'user_id'; required true; location :path }
+  #     end
+
+  #     it 'no errors' do
+  #       expect(do_run).to be_empty
+  #     end
+  #   end
+
+  #   context 'missing non-mandatory parameters' do
+  #     before do
+  #       parameters.add_new { name :email; required false }
+  #     end
+
+  #     it 'returns no errors' do
+  #       expect(do_run).to be_empty
+  #     end
+  #   end
+
+  #   # TODO
+  #   describe 'header parameter'
+  #   describe 'form parameter'
+  end
+end

data/spec/swaggable/check_mandatory_parameters_spec.rb

@@ -0,0 +1,110 @@
+require_relative '../spec_helper'
+require 'rack'
+
+RSpec.describe 'Swaggable::CheckMandatoryParameters' do
+  subject { subject_instance }
+  let(:subject_instance) { subject_class.new }
+  let(:subject_class) { Swaggable::CheckMandatoryParameters }
+
+  let(:parameters) { endpoint.parameters }
+  let(:endpoint) { Swaggable::EndpointDefinition.new { path '/' } }
+
+  let(:request) do
+    Swaggable::RackRequestAdapter.new Rack::MockRequest.env_for(path, {
+      'REQUEST_METHOD' =>  verb,
+      'CONTENT_TYPE' => content_type,
+      :input => body,
+    })
+  end
+
+  let(:path) { '/' }
+  let(:verb) { 'GET' }
+  let(:content_type) { nil }
+  let(:body) { nil }
+
+  def do_run
+    subject_class.call endpoint: endpoint, request: request
+  end
+
+  describe '.call' do
+    context 'no mandatory parameters' do
+      it 'returns an empty errors list' do
+        expect(do_run).to be_empty
+      end
+    end
+
+    context 'all mandatory parameters are present' do
+      before do
+        parameters.add_new { name :email; required true; location :query }
+        request.query_parameters[:email] = 'user@example.com'
+      end
+
+      it 'returns no errors' do
+        expect(do_run).to be_empty
+      end
+    end
+
+    context 'missing mandatory parameters undefined location' do
+      before do
+        parameters.add_new { name :email; required true }
+      end
+
+      it 'returns an error per missing parameter' do
+        errors = do_run
+        expect(errors.count).to eq 1
+        expect(errors.first.message).to match /email/
+      end
+    end
+
+    context 'missing mandatory query param' do
+      before do
+        parameters.add_new { name :email; required true; location :query }
+      end
+
+      it 'returns an error per missing parameter' do
+        errors = do_run
+        expect(errors.count).to eq 1
+        expect(errors.first.message).to match /email/
+      end
+    end
+
+    context 'missing mandatory path param' do
+      before do
+        parameters.add_new { name 'user_id'; required true; location :path }
+      end
+
+      it 'returns an error per missing parameter' do
+        errors = do_run
+        expect(errors.count).to eq 1
+        expect(errors.first.message).to match /user_id/
+      end
+    end
+
+    context 'present mandatory path param' do
+      let(:path) { '/users/37.json' }
+
+      before do
+        endpoint.path '/users/{user_id}.json'
+        parameters.add_new { name 'user_id'; required true; location :path }
+      end
+
+      it 'no errors' do
+        expect(do_run).to be_empty
+      end
+    end
+
+    context 'missing non-mandatory parameters' do
+      before do
+        parameters.add_new { name :email; required false }
+      end
+
+      it 'returns no errors' do
+        expect(do_run).to be_empty
+      end
+    end
+
+    # TODO
+    describe 'header parameter'
+    describe 'form parameter'
+  end
+end