drillbit 2.11.0 → 3.0.0

data/spec/drillbit/middleware/token_processor_spec.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-require 'rspeckled/spec_helpers/rspeckled'
-require 'drillbit/middleware/token_processor'
-
-module    Drillbit
-module    Middleware
-describe  TokenProcessor do
-  let(:app) { ->(_env) { [200, {}, 'response'] } }
-
-  it 'returns the proper response if the token is invalid' do
-    Drillbit.configuration.token_private_key = test_private_key
-    middleware = TokenProcessor.new(app)
-
-    request = {
-      'HTTP_HOST'          => 'api.example.com',
-      'HTTP_ACCEPT'        => 'application/vnd.westeros+redkeep;version=1.0.0',
-      'HTTP_AUTHORIZATION' => "Token #{invalid_jwe_token}",
-      'QUERY_STRING'       => 'accept=application/vnd.westeros+redkeep;version=1.0.0',
-    }
-
-    _status, _headers, response = middleware.call(request)
-
-    expect(response.first).to include 'errors.invalid_token'
-  end
-end
-end
-end

data/spec/drillbit/requests/base_spec.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-require 'ostruct'
-require 'rspeckled/spec_helpers/rspeckled'
-require 'drillbit/requests/base'
-
-module    Drillbit
-module    Requests
-describe  Base do
-  it 'can resolve itself by returning itself' do
-    raw_request      = Base.new(token_private_key: '', request: {})
-    resolved_request = Base.resolve(raw_request)
-
-    expect(resolved_request).to eql raw_request
-  end
-
-  it 'can resolve a Rails request' do
-    raw_request = OpenStruct.new(
-                         headers: {},
-                         params:  {},
-    )
-    resolved_request = Base.resolve(raw_request)
-
-    expect(resolved_request).to be_a Requests::Rails
-  end
-
-  it 'can resolve a Rack request' do
-    raw_request      = {
-      'HTTP_ACCEPT'  => 'accept_string',
-      'QUERY_STRING' => '',
-    }
-    resolved_request = Base.resolve(raw_request)
-
-    expect(resolved_request).to be_a Requests::Rack
-  end
-end
-end
-end

data/spec/drillbit/requests/rack_spec.rb

@@ -1,252 +0,0 @@
-# frozen_string_literal: true
-require 'rspeckled/spec_helpers/rspeckled'
-require 'drillbit/requests/rack'
-
-module    Drillbit
-module    Requests
-describe  Rack do
-  it 'finds the accept header from the headers if it is valid' do
-    raw_request = {
-      'HTTP_ACCEPT'             => 'application/vnd.westeros+redkeep;version=10.0',
-      'QUERY_STRING'            => '',
-      'HTTP_X_APPLICATION_NAME' => 'westeros',
-    }
-    request = Rack.new(request: raw_request)
-
-    expect(request.accept_header.to_s).to eql 'application/vnd.westeros+redkeep;version=10.0'
-  end
-
-  it 'finds the accept header from the headers if it is invalid but there is no ' \
-     'accept header in the params' do
-
-    raw_request = {
-      'HTTP_ACCEPT'             => 'invalid/vnd.westeros+redkeep;version=10.0',
-      'QUERY_STRING'            => '',
-      'HTTP_X_APPLICATION_NAME' => 'westeros',
-    }
-    request = Rack.new(request: raw_request)
-
-    expect(request.accept_header.to_s).to eql 'invalid/vnd.westeros+redkeep;version=10.0'
-  end
-
-  it 'finds the accept header from the params if it is valid' do
-    raw_request = {
-      'HTTP_ACCEPT'             => '',
-      'QUERY_STRING'            => 'accept=application/vnd.westeros+redkeep;version=10.0',
-      'HTTP_X_APPLICATION_NAME' => 'westeros',
-    }
-    request = Rack.new(request: raw_request)
-
-    expect(request.accept_header.to_s).to eql 'application/vnd.westeros+redkeep;version=10.0'
-  end
-
-  it 'finds the accept header from the query string if it is encoded' do
-    raw_request = {
-      'HTTP_ACCEPT'             => '',
-      'QUERY_STRING'            => 'accept=application%2Fvnd.westeros%2Bredkeep%3Bversion%3D10.0',
-      'HTTP_X_APPLICATION_NAME' => 'westeros',
-    }
-    request = Rack.new(request: raw_request)
-
-    expect(request.accept_header.to_s).to eql 'application/vnd.westeros+redkeep;version=10.0'
-  end
-  # rubocop:enable Metrics/LineLength
-
-  it 'finds the authorization token from the header' do
-    raw_request = {
-      'HTTP_AUTHORIZATION' => "Token #{valid_jwe_token}",
-      'QUERY_STRING'       => '',
-    }
-    request = Rack.new(token_private_key: test_private_key,
-                       request:           raw_request)
-
-    expect(request.authorization_token).to      be_valid
-    expect(request.authorization_token.to_h).to eql(
-      [
-        { 'bar' => 'baz' },
-        { 'typ' => 'JWT', 'alg' => 'RS256' },
-      ],
-    )
-  end
-
-  it 'finds the Base64 token from the header' do
-    raw_request = {
-      'HTTP_AUTHORIZATION' => "Basic #{valid_b64_token}",
-      'QUERY_STRING'       => '',
-    }
-    request = Rack.new(token_private_key: test_private_key,
-                       request:           raw_request)
-
-    expect(request.authorization_token).to      be_valid
-    expect(request.authorization_token.to_h).to eql(
-      [
-        { 'token' => valid_b64_token },
-        { 'typ'   => 'base64' },
-      ],
-    )
-  end
-
-  it 'finds a null token from the header if there is no header' do
-    raw_request = {
-      'HTTP_AUTHORIZATION' => '',
-      'QUERY_STRING'       => '',
-    }
-    request = Rack.new(token_private_key: test_private_key,
-                       request:           raw_request)
-
-    expect(request.authorization_token).to be_valid
-    expect(request.authorization_token).to be_blank
-  end
-
-  it 'ignores incorrectly passed in tokens since we do not know what to do' do
-    raw_request = {
-      'HTTP_AUTHORIZATION' => valid_jwe_token.to_s,
-      'QUERY_STRING'       => '',
-    }
-    request = Rack.new(token_private_key: test_private_key,
-                       request:           raw_request)
-
-    expect(request.authorization_token).to be_valid
-    expect(request.authorization_token).to be_blank
-  end
-
-  it 'finds the authorization token from the params if the authorization token from ' \
-     'the header is invalid and the authorization token from the params is valid' do
-
-    raw_request = {
-      'HTTP_AUTHORIZATION' => "Token #{invalid_jwe_token}",
-      'QUERY_STRING'       => "token_jwt=#{valid_jwe_token}",
-    }
-    request = Rack.new(token_private_key: test_private_key,
-                       request:           raw_request)
-
-    expect(request.authorization_token).to      be_valid
-    expect(request.authorization_token.to_h).to eql(
-      [
-        { 'bar' => 'baz' },
-        { 'typ' => 'JWT', 'alg' => 'RS256' },
-      ],
-    )
-  end
-
-  it 'finds the authorization token from the params if the authorization token from ' \
-     'the header is not present and the authorization token from the params is valid' do
-
-    raw_request = {
-      'QUERY_STRING' => "token_jwt=#{valid_jwe_token}",
-    }
-    request = Rack.new(token_private_key: test_private_key,
-                       request:           raw_request)
-
-    expect(request.authorization_token).to      be_valid
-    expect(request.authorization_token.to_h).to eql(
-      [
-        { 'bar' => 'baz' },
-        { 'typ' => 'JWT', 'alg' => 'RS256' },
-      ],
-    )
-  end
-
-  it 'is a null authorization token if neither authorization token is present' do
-    raw_request = {
-      'QUERY_STRING' => '',
-    }
-    request = Rack.new(token_private_key: test_private_key,
-                       request:           raw_request)
-
-    expect(request.authorization_token).to      be_valid
-    expect(request.authorization_token.to_h).to eql([{}, {}])
-  end
-
-  it 'finds the JSON web token from the params' do
-    raw_request = {
-      'QUERY_STRING' => "token_jwt=#{valid_jwe_token}",
-    }
-    request = Rack.new(token_private_key: test_private_key,
-                       request:           raw_request)
-
-    expect(request.authorization_token).to      be_valid
-    expect(request.authorization_token.to_h).to eql(
-      [
-        { 'bar' => 'baz' },
-        { 'typ' => 'JWT', 'alg' => 'RS256' },
-      ],
-    )
-  end
-
-  it 'finds the generic Base64 web token from the params' do
-    raw_request = {
-      'QUERY_STRING' => "token_b64=#{valid_b64_token}",
-    }
-    request = Rack.new(request: raw_request)
-
-    expect(request.authorization_token).to      be_valid
-    expect(request.authorization_token.to_h).to eql(
-      [
-        { 'token' => valid_b64_token },
-        { 'typ'   => 'base64' },
-      ],
-    )
-  end
-
-  it 'finds invalid tokens from the params' do
-    raw_request = {
-      'QUERY_STRING' => 'token_b64=bla.h',
-    }
-    request = Rack.new(request: raw_request)
-
-    expect(request.authorization_token_from_params).not_to be_valid
-    expect(request.authorization_token_from_params).not_to be_blank
-
-    raw_request = {
-      'QUERY_STRING' => "token_jwt=#{invalid_jwe_token}",
-    }
-    request = Rack.new(token_private_key: test_private_key,
-                       request:           raw_request)
-
-    expect(request.authorization_token_from_params).not_to be_valid
-    expect(request.authorization_token_from_params).not_to be_blank
-  end
-
-  it 'finds the null token from the params if nothing is passed in' do
-    raw_request = {
-      'QUERY_STRING' => 'token_b64=',
-    }
-    request = Rack.new(request: raw_request)
-
-    expect(request.authorization_token_from_params).to be_valid
-    expect(request.authorization_token_from_params).to be_blank
-
-    raw_request = {
-      'QUERY_STRING' => 'token_jwt=',
-    }
-    request = Rack.new(request: raw_request)
-
-    expect(request.authorization_token_from_params).to be_valid
-    expect(request.authorization_token_from_params).to be_blank
-
-    raw_request = {
-      'QUERY_STRING' => '',
-    }
-    request = Rack.new(request: raw_request)
-
-    expect(request.authorization_token_from_params).to be_valid
-    expect(request.authorization_token_from_params).to be_blank
-  end
-
-  it 'defaults to the application name in the configuration if none is found in ' \
-     'the header' do
-
-    Drillbit.configuration.application_name = 'redkeep'
-
-    raw_request = {
-      'HTTP_ACCEPT'  => '',
-      'QUERY_STRING' => 'accept=application/vnd.redkeep+zion;version=10.0',
-    }
-    request = Rack.new(request: raw_request)
-
-    expect(request.accept_header.to_s).to eql 'application/vnd.redkeep+zion;version=10.0'
-  end
-end
-end
-end

data/spec/drillbit/requests/rails_spec.rb

@@ -1,264 +0,0 @@
-# frozen_string_literal: true
-require 'ostruct'
-require 'rspeckled/spec_helpers/rspeckled'
-require 'drillbit/requests/rails'
-
-# rubocop:disable Metrics/LineLength
-module    Drillbit
-module    Requests
-describe  Rails do
-  it 'finds the accept header from the headers if it is valid' do
-    raw_request = OpenStruct.new(
-                    headers: {
-                      'X-Application-Name' => 'westeros',
-                      'Accept'             => 'application/vnd.westeros+redkeep;version=10.0',
-                    },
-                    params:  {},
-    )
-    request = Rails.new(request: raw_request)
-
-    expect(request.accept_header.to_s).to eql 'application/vnd.westeros+redkeep;version=10.0'
-  end
-
-  it 'finds the accept header from the headers if it is invalid but there is no ' \
-     'accept header in the params' do
-
-    raw_request = OpenStruct.new(
-                    headers: {
-                      'X-Application-Name' => 'westeros',
-                      'Accept'             => 'invalid/vnd.westeros+redkeep;version=10.0',
-                    },
-                    params:  {},
-    )
-    request = Rails.new(request: raw_request)
-
-    expect(request.accept_header.to_s).to eql 'invalid/vnd.westeros+redkeep;version=10.0'
-  end
-
-  it 'finds the accept header from the params if it is valid' do
-    raw_request = OpenStruct.new(
-                    headers: {
-                      'X-Application-Name' => 'westeros',
-                    },
-                    params:  { 'accept' => 'application/vnd.westeros+redkeep;version=10.0' },
-    )
-    request = Rails.new(request: raw_request)
-
-    expect(request.accept_header.to_s).to eql 'application/vnd.westeros+redkeep;version=10.0'
-  end
-
-  it 'finds the authorization token from the header' do
-    raw_request = OpenStruct.new(
-                    headers: {
-                      'HTTP_AUTHORIZATION' => "Token #{valid_jwe_token}",
-                    },
-                    params:  {},
-    )
-    request = Rails.new(token_private_key: test_private_key,
-                        request:           raw_request)
-
-    expect(request.authorization_token).to      be_valid
-    expect(request.authorization_token.to_h).to eql(
-      [
-        { 'bar' => 'baz' },
-        { 'typ' => 'JWT', 'alg' => 'RS256' },
-      ],
-    )
-  end
-
-  it 'finds the Base64 token from the header' do
-    raw_request = OpenStruct.new(
-                    headers: {
-                      'HTTP_AUTHORIZATION' => "Basic #{valid_b64_token}",
-                    },
-                    params:  {},
-    )
-    request = Rails.new(token_private_key: test_private_key,
-                        request:           raw_request)
-
-    expect(request.authorization_token).to      be_valid
-    expect(request.authorization_token.to_h).to eql(
-      [
-        { 'token' => valid_b64_token },
-        { 'typ'   => 'base64' },
-      ],
-    )
-  end
-
-  it 'finds a null token from the header if there is no header' do
-    raw_request = OpenStruct.new(
-                    headers: {},
-                    params:  {},
-    )
-    request = Rails.new(token_private_key: test_private_key,
-                        request:           raw_request)
-
-    expect(request.authorization_token).to be_valid
-    expect(request.authorization_token).to be_blank
-  end
-
-  it 'ignores incorrectly passed in tokens since we do not know what to do' do
-    raw_request = OpenStruct.new(
-                    headers: {
-                      'HTTP_AUTHORIZATION' => valid_jwe_token.to_s,
-                    },
-                    params:  {},
-    )
-    request = Rails.new(token_private_key: test_private_key,
-                        request:           raw_request)
-
-    expect(request.authorization_token).to be_valid
-    expect(request.authorization_token).to be_blank
-  end
-
-  it 'finds the authorization token from the params if the authorization token from ' \
-     'the header is invalid and the authorization token from the params is valid' do
-
-    raw_request = OpenStruct.new(
-                    headers: {
-                      'HTTP_AUTHORIZATION' => "Token #{invalid_jwe_token}",
-                    },
-                    params:  { 'token_jwt' => valid_jwe_token },
-    )
-    request = Rails.new(token_private_key: test_private_key,
-                        request:           raw_request)
-
-    expect(request.authorization_token).to      be_valid
-    expect(request.authorization_token.to_h).to eql(
-      [
-        { 'bar' => 'baz' },
-        { 'typ' => 'JWT', 'alg' => 'RS256' },
-      ],
-    )
-  end
-
-  it 'finds the authorization token from the params if the authorization token from ' \
-     'the header is not present and the authorization token from the params is valid' do
-
-    raw_request = OpenStruct.new(
-                    headers: {},
-                    params:  { 'token_jwt' => valid_jwe_token },
-    )
-    request = Rails.new(token_private_key: test_private_key,
-                        request:           raw_request)
-
-    expect(request.authorization_token).to      be_valid
-    expect(request.authorization_token.to_h).to eql(
-      [
-        { 'bar' => 'baz' },
-        { 'typ' => 'JWT', 'alg' => 'RS256' },
-      ],
-    )
-  end
-
-  it 'is a null authorization token if neither authorization token is present' do
-    raw_request = OpenStruct.new(
-                    headers: {},
-                    params:  {},
-    )
-    request = Rails.new(token_private_key: test_private_key,
-                        request:           raw_request)
-
-    expect(request.authorization_token).to      be_valid
-    expect(request.authorization_token.to_h).to eql([{}, {}])
-  end
-
-  it 'finds the JSON web token from the params' do
-    raw_request = OpenStruct.new(
-                    headers: {},
-                    params:  { 'token_jwt' => valid_jwe_token },
-    )
-    request = Rails.new(token_private_key: test_private_key,
-                        request:           raw_request)
-
-    expect(request.authorization_token).to      be_valid
-    expect(request.authorization_token.to_h).to eql(
-      [
-        { 'bar' => 'baz' },
-        { 'typ' => 'JWT', 'alg' => 'RS256' },
-      ],
-    )
-  end
-
-  it 'finds the generic Base64 web token from the params' do
-    raw_request = OpenStruct.new(
-                    headers: {},
-                    params:  { 'token_b64' => valid_b64_token },
-    )
-    request = Rails.new(request: raw_request)
-
-    expect(request.authorization_token).to      be_valid
-    expect(request.authorization_token.to_h).to eql(
-      [
-        { 'token' => valid_b64_token },
-        { 'typ'   => 'base64' },
-      ],
-    )
-  end
-
-  it 'finds invalid tokens from the params' do
-    raw_request = OpenStruct.new(
-                    headers: {},
-                    params:  { 'token_b64' => 'bla.h' },
-    )
-    request = Rails.new(request: raw_request)
-
-    expect(request.authorization_token_from_params).not_to be_valid
-    expect(request.authorization_token_from_params).not_to be_blank
-
-    raw_request = OpenStruct.new(
-                    headers: {},
-                    params:  { 'token_jwt' => invalid_jwe_token },
-    )
-    request = Rails.new(token_private_key: test_private_key,
-                        request:           raw_request)
-
-    expect(request.authorization_token_from_params).not_to be_valid
-    expect(request.authorization_token_from_params).not_to be_blank
-  end
-
-  it 'finds the null token from the params if nothing is passed in' do
-    raw_request = OpenStruct.new(
-                    headers: {},
-                    params:  { 'token_b64' => '' },
-    )
-    request = Rails.new(request: raw_request)
-
-    expect(request.authorization_token_from_params).to be_valid
-    expect(request.authorization_token_from_params).to be_blank
-
-    raw_request = OpenStruct.new(
-                    headers: {},
-                    params:  { 'token_jwt' => '' },
-    )
-    request = Rails.new(request: raw_request)
-
-    expect(request.authorization_token_from_params).to be_valid
-    expect(request.authorization_token_from_params).to be_blank
-
-    raw_request = OpenStruct.new(
-                    headers: {},
-                    params:  {},
-    )
-    request = Rails.new(request: raw_request)
-
-    expect(request.authorization_token_from_params).to be_valid
-    expect(request.authorization_token_from_params).to be_blank
-  end
-
-  it 'defaults to the application name in the configuration if none is found in ' \
-     'the header' do
-
-    Drillbit.configuration.application_name = 'redkeep'
-
-    raw_request = OpenStruct.new(
-                    headers: {},
-                    params:  { 'accept' => 'application/vnd.redkeep+zion;version=10.0' },
-    )
-    request = Rails.new(request: raw_request)
-
-    expect(request.accept_header.to_s).to eql 'application/vnd.redkeep+zion;version=10.0'
-  end
-end
-end
-end