drillbit 0.0.1

data/spec/drillbit/requests/rails_spec.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+require 'ostruct'
+require 'spec_helper'
+require 'drillbit/requests/rails'
+
+# rubocop:disable Metrics/LineLength
+module          Drillbit
+module          Requests
+RSpec.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

data/spec/drillbit/resource/model_spec.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+require 'spec_helper'
+require 'drillbit/resource/model'
+
+module          Drillbit
+module          Resource
+RSpec.describe  Model do
+  it 'can chain multiple processors together' do
+    resource           = double
+    processed_resource = double
+
+    model = Model.new(resource:   resource,
+                      parameters: {
+                        'filter' => {
+                          'query'          => 'my_query',
+                          'single_arity'   => true,
+                          'multiple_arity' => 'multi',
+                        },
+                        'sort'   => 'my_attribute',
+                        'page'   => {
+                          'number' => 10,
+                          'size'   => 100,
+                        },
+                      })
+
+    allow(resource).to receive(:single_arity).
+                       and_return(resource)
+    allow(resource).to receive(:multiple_arity).
+                       with('multi').
+                       and_return(resource)
+    allow(resource).to receive(:order).
+                       with('my_attribute' => 'asc').
+                       and_return(resource)
+    allow(resource).to receive(:page).
+                       with(10).
+                       and_return(resource)
+    allow(resource).to receive(:per).
+                       with(100).
+                       and_return(resource)
+    allow(resource).to receive(:for_query).
+                       with('my_query').
+                       and_return(processed_resource)
+
+    allow(processed_resource).to receive(:total_pages).
+                       and_return(10)
+    allow(processed_resource).to receive(:current_page).
+                       and_return(5)
+    allow(processed_resource).to receive(:prev_page).
+                       and_return(4)
+    allow(processed_resource).to receive(:next_page).
+                       and_return(6)
+
+    expect(model.processed).to eql processed_resource
+    expect(model.meta).to      eql(
+      'current-page'  => 5,
+      'total-pages'   => 10,
+      'previous-page' => 4,
+      'next-page'     => 6,
+      'sort'          => { 'my_attribute' => 'asc' },
+    )
+  end
+end
+end
+end

data/spec/drillbit/resource/processors/filtering_spec.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+require 'spec_helper'
+require 'drillbit/resource/processors/filtering'
+
+module          Drillbit
+module          Resource
+module          Processors
+RSpec.describe  Filtering do
+  let(:filtering_resource) { double }
+
+  it 'can return the resource if not filtered parameters are passed in' do
+    filtering = Filtering.new(filtering_resource)
+
+    expect(filtering.processed).to eql filtering_resource
+  end
+
+  it 'can return a queried resource' do
+    filtering = Filtering.new(filtering_resource,
+                              'filter' => {
+                                'stuff' => 'blah',
+                              })
+
+    allow(filtering_resource).to receive(:for_stuff).
+                                 with('blah').
+                                 and_return 'stuffed'
+
+    expect(filtering.processed).to eql 'stuffed'
+  end
+
+  it 'does not try to query if the resource cannot query for that thing' do
+    filtering = Filtering.new(filtering_resource,
+                              'filter' => {
+                                'whatever' => 'blah',
+                              })
+
+    expect(filtering.processed).to eql filtering_resource
+  end
+
+  it 'can query for something that does not take arguments' do
+    filtering = Filtering.new(filtering_resource,
+                              'filter' => {
+                                'stuff' => 'blah',
+                              })
+
+    allow(filtering_resource).to receive(:stuff).
+                                 and_return 'stuffed'
+
+    expect(filtering.processed).to eql 'stuffed'
+  end
+
+  it 'can query for something that does not take arguments' do
+    filtering = Filtering.new(filtering_resource,
+                              'filter' => {
+                                'stuff'       => 'blah',
+                                'other_stuff' => 'other_blah',
+                              })
+
+    allow(filtering_resource).to receive(:for_stuff).
+                                 with('blah').
+                                 and_return filtering_resource
+    allow(filtering_resource).to receive(:other_stuff).
+                                 and_return 'other_stuffed'
+
+    expect(filtering.processed).to eql 'other_stuffed'
+  end
+
+  it 'can properly format numerical ranges' do
+    filtering = Filtering.new(filtering_resource,
+                              'filter' => {
+                                'stuff'       => '100...200',
+                                'infinity'    => '9...Infinity',
+                                'other_stuff' => '3_333.33..8_8__8.0',
+                              })
+
+    allow(filtering_resource).to receive(:for_stuff).
+                                 with(100.0...200.0).
+                                 and_return filtering_resource
+    allow(filtering_resource).to receive(:infinity).
+                                 with(9.0...9_999_999).
+                                 and_return filtering_resource
+    allow(filtering_resource).to receive(:other_stuff).
+                                 with(3333.33..888.0).
+                                 and_return 'other_stuffed'
+
+    expect(filtering.processed).to eql 'other_stuffed'
+  end
+
+  it 'can handle objects (eg ActiveRelation) that store their proxy class in klass' do
+    resource_class = double
+    filtering      = Filtering.new(filtering_resource,
+                                   'filter' => {
+                                     'stuff' => 'blah',
+                                   })
+
+    allow(filtering_resource).to receive(:klass).
+                                 and_return(resource_class)
+    allow(resource_class).to     receive(:stuff)
+    allow(filtering_resource).to receive(:stuff).
+                                 and_return 'stuffed'
+
+    expect(filtering.processed).to eql 'stuffed'
+  end
+end
+end
+end
+end

data/spec/drillbit/resource/processors/indexing_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+require 'spec_helper'
+require 'drillbit/resource/processors/indexing'
+
+module Drillbit
+class  TestIndexClass
+  def for_query(_param)
+  end
+end
+end
+
+module          Drillbit
+module          Resource
+module          Processors
+RSpec.describe  Indexing do
+  let(:indexing_resource) { double }
+
+  it 'does not do anything if indexing params are not passed in' do
+    indexing = Indexing.new(indexing_resource)
+
+    expect(indexing.processed).to eql indexing_resource
+  end
+
+  it 'does not do anything if indexing params are passed in but they are blank' do
+    indexing = Indexing.new(indexing_resource,
+                            'filter' => {
+                              'query' => '',
+                            })
+
+    expect(indexing.processed).to eql indexing_resource
+  end
+
+  it 'forces a query even if no parameters were passed in' do
+    indexing_resource = TestIndexClass.new
+    indexing          = Indexing.new(indexing_resource)
+
+    allow(indexing_resource).to receive(:for_query).
+                                with('*').
+                                and_return('blah')
+
+    expect(indexing.processed).to eql 'blah'
+  end
+end
+end
+end
+end