drillbit 2.11.0 → 3.0.0

data/spec/drillbit/matchers/subdomain_spec.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-require 'rspeckled/spec_helpers/rspeckled'
-require 'drillbit/requests/base'
-require 'drillbit/matchers/subdomain'
-require 'drillbit/configuration'
-
-module    Drillbit
-module    Matchers
-describe  Subdomain do
-  before(:each) do
-    Drillbit.configuration.allowed_subdomains     = %w{api}
-    Drillbit.configuration.allowed_api_subdomains = %w{api}
-  end
-
-  it 'matches if the subdomain is API' do
-    env     = { 'HTTP_HOST' => 'api.example.com' }
-    request = Requests::Base.resolve(env)
-    matcher = Subdomain.new
-
-    expect(matcher.matches?(request)).to be_a TrueClass
-  end
-
-  it 'matches if the first subdomain is API' do
-    env     = { 'HTTP_HOST' => 'api.westeros.example.com' }
-    request = Requests::Base.resolve(env)
-    matcher = Subdomain.new
-
-    expect(matcher.matches?(request)).to be_a TrueClass
-  end
-
-  it 'does not match if the first subdomain is not API' do
-    env     = { 'HTTP_HOST' => 'westeros.example.com' }
-    request = Requests::Base.resolve(env)
-    matcher = Subdomain.new
-
-    expect(matcher.matches?(request)).to be_a FalseClass
-  end
-
-  it 'allows the matched subdomain to be specified' do
-    env     = { 'HTTP_HOST' => 'westeros.example.com' }
-    request = Requests::Base.resolve(env)
-    matcher = Subdomain.new(allowed_subdomains: 'westeros')
-
-    expect(matcher.matches?(request)).to be_a TrueClass
-  end
-
-  it 'allows more than one subdomain to be matched' do
-    env     = { 'HTTP_HOST' => 'westeros.example.com' }
-    request = Requests::Base.resolve(env)
-    matcher = Subdomain.new(allowed_subdomains: %w{api westeros})
-
-    expect(matcher.matches?(request)).to be_a TrueClass
-
-    env     = { 'HTTP_HOST' => 'api.example.com' }
-    request = Requests::Base.resolve(env)
-    matcher = Subdomain.new(allowed_subdomains: %w{api westeros})
-
-    expect(matcher.matches?(request)).to be_a TrueClass
-  end
-
-  it 'can match only the api subdomain' do
-    env     = { 'HTTP_HOST' => 'westeros.example.com' }
-    request = Requests::Base.resolve(env)
-    matcher = Subdomain.new(allowed_api_subdomains: %w{westeros})
-
-    expect(matcher.matches_api_subdomain?(request)).to be_a TrueClass
-  end
-
-  it 'matches "api" as an api subdomain by default' do
-    env     = { 'HTTP_HOST' => 'api.example.com' }
-    request = Requests::Base.resolve(env)
-    matcher = Subdomain.new
-
-    expect(matcher.matches_api_subdomain?(request)).to be_a TrueClass
-  end
-end
-end
-end

data/spec/drillbit/matchers/version_spec.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-require 'rspeckled/spec_helpers/rspeckled'
-require 'drillbit/requests/base'
-require 'drillbit/matchers/version'
-
-module    Drillbit
-module    Matchers
-describe  Version do
-  context 'when the version is passed in the accept header' do
-    it 'does not match if the subdomain is API but the requested version does not ' \
-       'equal the version constraint' do
-
-      env = {
-        'HTTP_X_APPLICATION_NAME' => 'westeros',
-        'HTTP_ACCEPT'             => 'application/vnd.westeros+redkeep;version=10.0',
-      }
-      request = Requests::Base.resolve(env)
-
-      matcher = Version.new(version_constraint: '10.1')
-
-      expect(matcher.matches?(request)).to be_a FalseClass
-    end
-
-    it 'does match if the subdomain is API and the requested version equals the ' \
-       'version constraint' do
-
-      env = {
-        'HTTP_X_APPLICATION_NAME' => 'westeros',
-        'HTTP_ACCEPT'             => 'application/vnd.westeros+redkeep;version=10.0',
-      }
-      request = Requests::Base.resolve(env)
-
-      matcher = Version.new(version_constraint: '10.0')
-
-      expect(matcher.matches?(request)).to be_a TrueClass
-    end
-  end
-
-  context 'when the version is not passed in the accept header' do
-    it 'does not match if the subdomain is API but the requested version does not ' \
-       'equal the version constraint' do
-
-      env = {
-        'HTTP_X_APPLICATION_NAME' => 'westeros',
-        'HTTP_ACCEPT'             => 'application/vnd.westeros+redkeep',
-      }
-      request = Requests::Base.resolve(env)
-
-      matcher = Version.new(version_constraint: '10.1',
-                            default_version:    '10.0')
-
-      expect(matcher.matches?(request)).to be_a FalseClass
-    end
-
-    it 'does match if the subdomain is API and the requested version equals the ' \
-       'version constraint' do
-
-      env = {
-        'HTTP_X_APPLICATION_NAME' => 'westeros',
-        'HTTP_ACCEPT'             => 'application/vnd.westeros+redkeep',
-      }
-      request = Requests::Base.resolve(env)
-
-      matcher = Version.new(version_constraint: '10.0',
-                            default_version:    '10.0')
-
-      expect(matcher.matches?(request)).to be_a TrueClass
-    end
-  end
-
-  it 'matches the default version in the configuration if none is passed in' do
-    Drillbit.configuration.default_api_version = '100.0'
-
-    env = {
-      'HTTP_X_APPLICATION_NAME' => 'westeros',
-      'HTTP_ACCEPT'             => 'application/vnd.westeros+redkeep',
-    }
-    request = Requests::Base.resolve(env)
-
-    matcher = Version.new(version_constraint: '100.0')
-
-    expect(matcher.matches?(request)).to be_a TrueClass
-  end
-end
-end
-end

data/spec/drillbit/middleware/api_request_validator_spec.rb

@@ -1,185 +0,0 @@
-# frozen_string_literal: true
-require 'rspeckled/spec_helpers/rspeckled'
-require 'drillbit/middleware/api_request_validator'
-
-# rubocop:disable Metrics/LineLength
-module    Drillbit
-module    Middleware
-describe  ApiRequestValidator, singletons: Erratum::Configuration do
-  let(:app) { ->(_env) { [200, {}, 'response'] } }
-
-  before(:each) do
-    Erratum.configuration.url_mappings = {
-      'external_documentation_urls'  => {
-        'errors.responses.invalid_subdomain' => 'http://example.com/foo',
-      },
-      'developer_documentation_urls' => {
-        'errors.responses.invalid_subdomain' => 'http://example.com/foo',
-      },
-    }
-
-    Drillbit.configure do |config|
-      config.allowed_subdomains     = %w{api westeros}
-      config.allowed_api_subdomains = %w{api}
-      config.application_name       = 'westeros'
-    end
-  end
-
-  it 'allows requests for allowed subdomains without accept headers' do
-    api_request_middleware = ApiRequestValidator.new(app)
-
-    request = {
-      'HTTP_HOST'    => 'westeros.example.com',
-      'HTTP_ACCEPT'  => '',
-      'QUERY_STRING' => '',
-    }
-
-    status, headers, response = api_request_middleware.call(request)
-
-    expect(status).to   eql 200
-    expect(headers).to  eql({})
-    expect(response).to eql 'response'
-  end
-
-  it 'does not allow requests if they are not for an allowed subdomain' do
-    api_request_middleware = ApiRequestValidator.new(app)
-
-    request = {
-      'HTTP_HOST'    => 'notvalid.example.com',
-      'HTTP_ACCEPT'  => '',
-      'QUERY_STRING' => 'first=my_param&accept=application/vnd.silent+redkeep;version=1.0.0',
-    }
-
-    status, headers, response = api_request_middleware.call(request)
-
-    expect(status).to                 eql 404
-    expect(headers).to                eql({})
-    expect(JSON.load(response[0])).to include(
-      'errors' => [
-                    {
-                      'id'     => match(/[a-z0-9\-]+/),
-                      'links'  => {
-                        'about'         => nil,
-                        'documentation' => nil,
-                      },
-                      'status' => 404,
-                      'code'   => 'errors.invalid_subdomain',
-                      'title'  => 'Invalid Subdomain',
-                      'detail' => 'The subdomain you attempted to access is not valid.' \
-                                  '  Please try again.',
-                      'source' => {
-                        'http_host' => 'notvalid.example.com',
-                      },
-                    },
-                  ],
-    )
-  end
-
-  it 'does not allow requests if they are for an allowed subdomain but does ' \
-     'not have a valid accept header' do
-
-    api_request_middleware = ApiRequestValidator.new(app)
-
-    request = {
-      'HTTP_HOST'    => 'api.example.com',
-      'HTTP_ACCEPT'  => '',
-      'QUERY_STRING' => 'first=my_param&accept=application/vnd.silent+redkeep;version=1.0.0',
-    }
-
-    status, headers, response = api_request_middleware.call(request)
-
-    expect(status).to                 eql 400
-    expect(headers).to                eql({})
-    expect(JSON.load(response[0])).to include(
-      'errors' => [
-                    {
-                      'id'     => match(/[a-z0-9\-]+/),
-                      'links'  => {
-                        'about'         => nil,
-                        'documentation' => nil,
-                      },
-                      'status' => 400,
-                      'code'   => 'errors.invalid_api_request',
-                      'title'  => 'Invalid API Request',
-                      'detail' => 'The accept header that you passed in the request cannot be ' \
-                                  'parsed, please refer to the documentation to verify.',
-                      'source' => {
-                        'accept_header' => '',
-                      },
-                    },
-                  ],
-    )
-  end
-
-  it 'does allow requests if both the subdomain and the accept header are valid' do
-    api_request_middleware = ApiRequestValidator.new(app)
-
-    request = {
-      'HTTP_HOST'    => 'api.example.com',
-      'HTTP_ACCEPT'  => 'application/vnd.westeros+redkeep;version=1.0.0',
-      'QUERY_STRING' => 'first=my_param&accept=application/vnd.westeros+redkeep;version=1.0.0',
-    }
-
-    status, headers, response = api_request_middleware.call(request)
-
-    expect(status).to   eql 200
-    expect(headers).to  eql({})
-    expect(response).to eql 'response'
-  end
-
-  it 'does allow requests if the subdomain, the accept header and the token are valid' do
-    Drillbit.configuration.token_private_key = test_private_key
-    api_request_middleware = ApiRequestValidator.new(app)
-
-    request = {
-      'HTTP_HOST'          => 'api.example.com',
-      'HTTP_ACCEPT'        => 'application/vnd.westeros+redkeep;version=1.0.0',
-      'HTTP_AUTHORIZATION' => "Token #{valid_jwe_token}",
-      'QUERY_STRING'       => 'accept=application/vnd.westeros+redkeep;version=1.0.0',
-    }
-
-    status, headers, response = api_request_middleware.call(request)
-
-    expect(status).to   eql 200
-    expect(headers).to  eql({})
-    expect(response).to eql 'response'
-  end
-
-  it 'properly converts the content type for Rails when it is the only one' do
-    api_request_middleware = ApiRequestValidator.new(app)
-
-    request = {
-      'CONTENT_TYPE' => 'application/vnd.api+json',
-      'HTTP_HOST'    => 'westeros.example.com',
-      'HTTP_ACCEPT'  => '',
-      'QUERY_STRING' => '',
-    }
-
-    allow(app).to receive(:call)
-
-    _response = api_request_middleware.call(request)
-
-    expect(app).to have_received(:call).
-    with(a_hash_including('CONTENT_TYPE' => 'application/json'))
-  end
-
-  it 'properly converts the content type for Rails when it is not the only one' do
-    api_request_middleware = ApiRequestValidator.new(app)
-
-    request = {
-      'CONTENT_TYPE' => 'application/vnd.api+json;other',
-      'HTTP_HOST'    => 'westeros.example.com',
-      'HTTP_ACCEPT'  => '',
-      'QUERY_STRING' => '',
-    }
-
-    allow(app).to receive(:call)
-
-    _response = api_request_middleware.call(request)
-
-    expect(app).to have_received(:call).
-    with(a_hash_including('CONTENT_TYPE' => 'application/json;other'))
-  end
-end
-end
-end

data/spec/drillbit/middleware/parameter_parser_spec.rb

@@ -1,200 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-require 'drillbit/middleware/parameter_parser'
-
-module    Drillbit
-module    Middleware
-describe  ParameterParser do
-  let(:app) { ->(_env) { [200, {}, 'response'] } }
-
-  it 'converts JSON API compliant dasherized query params to underscored' do
-    app        = ->(env) { [200, env, 'response'] }
-    middleware = ParameterParser.new(app)
-
-    request = {
-      'QUERY_STRING' => 'hello-there=bob-jones&'     \
-                        'nice-to-meet=you-bob&'      \
-                        'hows-the-weather=today-bob',
-    }
-
-    _status, headers, _response = middleware.call(request)
-
-    expect(headers['QUERY_STRING']).to eql 'hello_there=bob-jones&' \
-                                           'nice_to_meet=you-bob&'  \
-                                           'hows_the_weather=today-bob'
-  end
-
-  it 'does not touch query params with no dashes' do
-    app        = ->(env) { [200, env, 'response'] }
-    middleware = ParameterParser.new(app)
-
-    request = {
-      'QUERY_STRING' => 'hello_there=bob-jones',
-    }
-
-    _status, headers, _response = middleware.call(request)
-
-    expect(headers['QUERY_STRING']).to eql 'hello_there=bob-jones'
-  end
-
-  it 'can handle weirdly formatted query string parameters' do
-    app        = ->(env) { [200, env, 'response'] }
-    middleware = ParameterParser.new(app)
-
-    request = {
-      'QUERY_STRING' => 'hello-there=bob-jones&' \
-                        'nice-to-meet=you-bob&=',
-    }
-
-    _status, headers, _response = middleware.call(request)
-
-    expect(headers['QUERY_STRING']).to eql 'hello_there=bob-jones&' \
-                                           'nice_to_meet=you-bob&='
-  end
-
-  it 'can handle query string parameters with no values' do
-    app        = ->(env) { [200, env, 'response'] }
-    middleware = ParameterParser.new(app)
-
-    request = {
-      'QUERY_STRING' => 'hello-there&nice-to-meet=you-bob&=',
-    }
-
-    _status, headers, _response = middleware.call(request)
-
-    expect(headers['QUERY_STRING']).to eql 'hello_there&nice_to_meet=you-bob&='
-  end
-
-  it 'can handle query string parameters with parameter name' do
-    app        = ->(env) { [200, env, 'response'] }
-    middleware = ParameterParser.new(app)
-
-    request = {
-      'QUERY_STRING' => 'hello-there=bob-jones&=you-bob&nice-to-meet=you-bob&=',
-    }
-
-    _status, headers, _response = middleware.call(request)
-
-    expect(headers['QUERY_STRING']).to eql 'hello_there=bob-jones&' \
-                                           '=you-bob&' \
-                                           'nice_to_meet=you-bob&='
-  end
-
-  it 'converts JSON API compliant dasherized request params to underscored' do
-    app        = ->(env) { [200, env, 'response'] }
-    middleware = ParameterParser.new(app)
-
-    request = {
-      'CONTENT_LENGTH' => '1',
-      'CONTENT_TYPE'   => 'application/json',
-      'RACK_INPUT'     => <<-HEREDOC
-        {
-          "single":      "word",
-          "double-word": "double double",
-          "triple":      {
-                           "trippple-tripple": "mcdipple",
-                           "quad":             {
-                             "another-level":    "whoa inception"
-                           }
-                         },
-          "quint":       [
-                           {
-                             "quint-it-quit": "mc-dipple"
-                           },
-                           {
-                             "quint-it-quit": "big-maccle"
-                           }
-                         ]
-        }
-      HEREDOC
-    }
-
-    _status, headers, _response = middleware.call(request)
-
-    expect(JSON.load(headers['RACK_INPUT'])).to eql(
-      'single'      => 'word',
-      'double_word' => 'double double',
-      'triple'      => {
-        'trippple_tripple' => 'mcdipple',
-        'quad'             => {
-          'another_level' => 'whoa inception',
-        },
-      },
-      'quint'       => [
-                         {
-                           'quint_it_quit' => 'mc-dipple',
-                         },
-                         {
-                           'quint_it_quit' => 'big-maccle',
-                         },
-                       ],
-    )
-  end
-
-  it 'does not convert to JSON if the content type is not JSON' do
-    app        = ->(env) { [200, env, 'response'] }
-    middleware = ParameterParser.new(app)
-
-    request = {
-      'CONTENT_LENGTH' => '1',
-      'CONTENT_TYPE'   => 'not_j_s_o_n',
-      'RACK_INPUT'     => 'This is not JSON',
-    }
-
-    _status, headers, _response = middleware.call(request)
-
-    expect(headers['RACK_INPUT']).to eql 'This is not JSON'
-  end
-
-  it 'does not convert to JSON if there is no content' do
-    app        = ->(env) { [200, env, 'response'] }
-    middleware = ParameterParser.new(app)
-
-    request = {
-      'CONTENT_LENGTH' => '0',
-      'CONTENT_TYPE'   => 'application/json',
-      'RACK_INPUT'     => 'empty',
-    }
-
-    _status, headers, _response = middleware.call(request)
-
-    expect(headers['RACK_INPUT']).to eql 'empty'
-  end
-
-  it 'can handle incorrectly formatted JSON' do
-    app        = ->(env) { [200, env, 'response'] }
-    middleware = ParameterParser.new(app)
-
-    request = {
-      'CONTENT_LENGTH' => '1',
-      'CONTENT_TYPE'   => 'application/json',
-      'RACK_INPUT'     => 'something blah',
-    }
-
-    status, headers, response = middleware.call(request)
-
-    expect(status).to                 eql 400
-    expect(headers).to                eql({})
-    expect(JSON.load(response[0])).to include(
-      'errors' => [
-                    {
-                      'id'     => match(/[a-z0-9\-]+/),
-                      'links'  => {
-                        'about'         => nil,
-                        'documentation' => nil,
-                      },
-                      'status' => 400,
-                      'code'   => 'errors.invalid_request_body',
-                      'title'  => 'Invalid Request Body',
-                      'detail' => 'The information you attempted to send in the ' \
-                                  'request cannot be parsed as a valid JSON document.',
-                      'source' => {
-                        'request_body' => 'something blah',
-                      },
-                    },
-                  ],
-    )
-  end
-end
-end
-end