praxis 2.0.pre.18 → 2.0.pre.19

data/spec/praxis/media_type_identifier_spec.rb

@@ -1,4 +1,8 @@
-require "spec_helper"
+# frozen_string_literal: true
+
+# rubocop:disable Style/StringConcatenation
+
+require 'spec_helper'
 
 describe Praxis::MediaTypeIdentifier do
   let(:example) { 'application/ice-cream+sundae; nuts="true"; fudge="true"' }
@@ -14,7 +18,7 @@ describe Praxis::MediaTypeIdentifier do
     end
 
     context 'of empty string values' do
-      let(:example) { "" }
+      let(:example) { '' }
       it 'returns nil' do
         expect(subject).to be(nil)
       end
@@ -47,8 +51,6 @@ describe Praxis::MediaTypeIdentifier do
       #   pending("need to stop using a regexp to do a context-free parser's job")
       #   expect(described_class.new(tricky_example).parameters['sauce']).to eq('yes; absolutely')
       # end
-
-
     end
 
     context 'given a malformed type' do
@@ -164,7 +166,7 @@ describe Praxis::MediaTypeIdentifier do
 
     let(:with_suffix) { 'application/vnd.widget+xml' }
     let(:with_subtype) { 'text/xml' }
-    let(:with_both) { 'text/json+xml' } #nonsensical but valid!
+    let(:with_both) { 'text/json+xml' } # nonsensical but valid!
 
     it 'uses the suffix' do
       expect(subject.new(with_suffix).handler_name).to eq('xml')
@@ -192,15 +194,15 @@ describe Praxis::MediaTypeIdentifier do
 
     it 'adds parameters' do
       expect(simple_subject + 'nuts=true').to \
-      eq(described_class.new('application/vnd.icecream; nuts=true'))
+        eq(described_class.new('application/vnd.icecream; nuts=true'))
 
       expect(simple_subject + '; nuts=true').to \
-      eq(described_class.new('application/vnd.icecream; nuts=true'))
+        eq(described_class.new('application/vnd.icecream; nuts=true'))
     end
 
     it 'adds suffix and parameters' do
       expect(simple_subject + 'xml; nuts=true').to \
-      eq(described_class.new('application/vnd.icecream+xml; nuts=true'))
+        eq(described_class.new('application/vnd.icecream+xml; nuts=true'))
     end
 
     it 'replaces the suffix' do
@@ -210,7 +212,7 @@ describe Praxis::MediaTypeIdentifier do
 
     it 'replaces existing parameters and adds new ones' do
       expect(complex_subject + 'nuts=false; cherry=true').to \
-      eq(described_class.new('application/vnd.icecream+json; cherry=true; nuts=false'))
+        eq(described_class.new('application/vnd.icecream+json; cherry=true; nuts=false'))
 
       expect(complex_subject + '; nuts=false; cherry=true').to \
         eq(described_class.new('application/vnd.icecream+json; cherry=true; nuts=false'))
@@ -235,4 +237,5 @@ describe Praxis::MediaTypeIdentifier do
       end
     end
   end
-end
+end
+# rubocop:enable Style/StringConcatenation

data/spec/praxis/media_type_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Praxis::MediaType do
@@ -5,19 +7,18 @@ describe Praxis::MediaType do
   let(:manager_resource) { instance_double(Person, id: 101, name: /[:name:]/.gen, href: '/') }
   let(:custodian_resource) { instance_double(Person, id: 102, name: /[:name:]/.gen, href: '/') }
   let(:residents_summary_resource) do
-    instance_double(Person::CollectionSummary, href: "/people", size: 2)
+    instance_double(Person::CollectionSummary, href: '/people', size: 2)
   end
 
   let(:resource) do
     double('address',
-      id: 1,
-      name: 'Home',
-      owner: owner_resource,
-      manager: manager_resource,
-      custodian: custodian_resource,
-      residents_summary: residents_summary_resource,
-      fields: {id: true, name: true}
-    )
+           id: 1,
+           name: 'Home',
+           owner: owner_resource,
+           manager: manager_resource,
+           custodian: custodian_resource,
+           residents_summary: residents_summary_resource,
+           fields: { id: true, name: true })
   end
 
   subject(:address) { Address.new(resource) }
@@ -28,7 +29,6 @@ describe Praxis::MediaType do
     its(:owner) { should be_instance_of(Person) }
   end
 
-
   context 'accessor methods' do
     subject(:address_klass) { address.class }
 
@@ -41,12 +41,12 @@ describe Praxis::MediaType do
     its(:description) { should be_kind_of(String) }
   end
 
-  context "rendering" do
+  context 'rendering' do
     subject(:output) { address.render }
 
     its([:id])    { should eq(address.id) }
     its([:name])  { should eq(address.name) }
     its([:owner]) { should eq(Person.dump(owner_resource)) }
-    its([:fields]) { should eq(address.fields.dump ) }
+    its([:fields]) { should eq(address.fields.dump) }
   end
 end

data/spec/praxis/middleware_app_spec.rb

@@ -1,73 +1,74 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Praxis::MiddlewareApp do
-
-  let(:init_args){ { root: 'here'} }
-  let(:middleware) { Praxis::MiddlewareApp.for( **init_args ) }
-  let(:instance){ middleware.new(target)}
+  let(:init_args) { { root: 'here' } }
+  let(:middleware) { Praxis::MiddlewareApp.for(**init_args) }
+  let(:instance) { middleware.new(target) }
 
   context '.for' do
     it 'does not initialize the Application instance yet' do
-      expect( Praxis::Application.instance ).to_not receive(:setup)
+      expect(Praxis::Application.instance).to_not receive(:setup)
       middleware
     end
     it 'returns its class' do
-      expect( middleware ).to be < Praxis::MiddlewareApp 
+      expect(middleware).to be < Praxis::MiddlewareApp
     end
   end
 
   context 'instantiated' do
-    subject{ instance }
-    let(:target_response){ [201,{}] }
-    let(:target){ double("target app", call: target_response) }
+    subject { instance }
+    let(:target_response) { [201, {}] }
+    let(:target) { double('target app', call: target_response) }
     it 'saves the target app' do
       expect(subject.target).to be(target)
     end
     it 'does not initialize the Application instance yet' do
-      expect( Praxis::Application.instance ).to_not receive(:setup)
+      expect(Praxis::Application.instance).to_not receive(:setup)
       subject
     end
-    
+
     context '.call' do
-      let(:env){ {} }
-      let(:praxis_response){ [200,{}] }
-      subject(:response){ instance.call(env) }
+      let(:env) { {} }
+      let(:praxis_response) { [200, {}] }
+      subject(:response) { instance.call(env) }
       before do
         # always invokes the praxis app
-        expect( Praxis::Application.instance ).to receive(:call).with( env ).once.and_return(praxis_response)
+        expect(Praxis::Application.instance).to receive(:call).with(env).once.and_return(praxis_response)
       end
 
       context 'when it has not been setup yet' do
         it 'initializes the application singleton with the passed parameters' do
-          expect( Praxis::Application.instance ).to receive(:setup).with( init_args ).once
+          expect(Praxis::Application.instance).to receive(:setup).with(init_args).once
           subject
         end
       end
       context 'when it has already been setup' do
         it 'does NOT call instance setup' do
           middleware.setup
-          expect( Praxis::Application.instance ).to_not receive(:setup)
+          expect(Praxis::Application.instance).to_not receive(:setup)
           subject
         end
       end
 
       context 'properly handled (non-404 and 405) responses from praxis' do
         it 'are returned straight through' do
-          expect( response ).to be(praxis_response)
+          expect(response).to be(praxis_response)
         end
       end
 
       context '404/405 responses with X-Cascade = pass' do
-        let(:praxis_response){ [404, {'X-Cascade' => 'pass'}]}
+        let(:praxis_response) { [404, { 'X-Cascade' => 'pass' }] }
         it 'are forwarded to the target app' do
-          expect( response ).to be(target_response)
+          expect(response).to be(target_response)
         end
       end
 
       context '404/405 responses without X-Cascade = pass' do
-        let(:praxis_response){ [404, {}]}
+        let(:praxis_response) { [404, {}] }
         it 'returned straight through' do
-          expect( response ).to be(praxis_response)
+          expect(response).to be(praxis_response)
         end
       end
     end

data/spec/praxis/multipart/parser_spec.rb

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Praxis::MultipartParser do
-
   let(:form) do
     form_data = MIME::Multipart::FormData.new
 
@@ -36,17 +37,16 @@ describe Praxis::MultipartParser do
       form.add text, 'file', 'docker'
     end
 
-    subject(:part) { parts.find { |p| p.name == 'file'} }
-    #subject(:part_body) { part.body }
-
+    subject(:part) { parts.find { |p| p.name == 'file' } }
+    # subject(:part_body) { part.body }
 
     its(:payload) { should be_kind_of(Tempfile) }
-    its(:filename) { should eq("docker") }
-    its(:name) { should eq("file") }
+    its(:filename) { should eq('docker') }
+    its(:name) { should eq('file') }
 
     context 'headers' do
       subject(:part_headers) { part.headers }
-      its(['Content-Type']) { should eq("text/plain") }
+      its(['Content-Type']) { should eq('text/plain') }
       its(['Content-Disposition']) { should match(/filename=docker/) }
     end
 
@@ -56,7 +56,5 @@ describe Praxis::MultipartParser do
       part.payload.rewind
       expect(part.payload.read).to eq('DOCKER_HOST=tcp://127.0.0.1:2375')
     end
-
   end
-
 end

data/spec/praxis/notifications_spec.rb

@@ -1,11 +1,12 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Praxis::Notifications do
-
   let(:events) { [] }
 
   before do
-    Praxis::Notifications.subscribe('render') do |name, start, finish, id, payload|
+    Praxis::Notifications.subscribe('render') do |_name, _start, _finish, _id, payload|
       events << payload
     end
 
@@ -17,7 +18,6 @@ describe Praxis::Notifications do
 
   it 'works' do
     expect(events).to have(2).items
-    expect(events).to match [{extra: :information}, {extra: :single}]
+    expect(events).to match [{ extra: :information }, { extra: :single }]
   end
-
 end

data/spec/praxis/plugin_concern_spec.rb

@@ -1,21 +1,20 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Praxis::PluginConcern do
-
   it 'works' do
     expect(Praxis::Request.instance_methods).to include(:user_abilities)
   end
 
   context 'ActionDefinition' do
     subject(:action) { ApiResources::Instances.actions[:terminate] }
-    its(:required_abilities) { should match_array [:terminate, :read] }
+    its(:required_abilities) { should match_array %i[terminate read] }
 
     context '#describe' do
       subject(:describe) { action.describe }
-      it { should have_key :required_abilities}
-      its([:required_abilities]) { should match_array action.required_abilities}
+      it { should have_key :required_abilities }
+      its([:required_abilities]) { should match_array action.required_abilities }
     end
-
   end
-
 end

data/spec/praxis/renderer_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../spec_helper'
 
 describe Praxis::Renderer do
@@ -30,7 +31,7 @@ describe Praxis::Renderer do
       address: {
         state: true,
         street: true,
-        resident:  { name: true }
+        resident: { name: true }
       },
       prior_addresses: { name: true },
       work_address: true,
@@ -45,15 +46,15 @@ describe Praxis::Renderer do
   subject(:output) { renderer.render(person, fields) }
 
   it 'renders existing attributes' do
-    expect(output.keys).to match_array([:name, :full_name, :alive, :address, :prior_addresses, :metadata, :aliases])
+    expect(output.keys).to match_array(%i[name full_name alive address prior_addresses metadata aliases])
 
     expect(output[:name]).to eq person.name
     expect(output[:full_name]).to eq(first: person.full_name.first, last: person.full_name.last)
     expect(output[:alive]).to be false
 
     expect(output[:address]).to eq(state: person.address.state,
-                               street: person.address.street,
-                               resident: { name: person.address.resident.name })
+                                   street: person.address.street,
+                                   resident: { name: person.address.resident.name })
 
     expected_prior_addresses = prior_addresses.collect { |addr| { name: addr.name } }
     expect(output[:prior_addresses]).to match_array(expected_prior_addresses)
@@ -118,18 +119,18 @@ describe Praxis::Renderer do
 
   context 'rendering stuff that breaks badly' do
     it 'does not break badly' do
-      expect{renderer.render(person, {tags: true})}.to_not raise_error
+      expect { renderer.render(person, { tags: true }) }.to_not raise_error
     end
   end
 
   context 'caching rendered objects' do
-    let(:fields) { {full_name: true} }
+    let(:fields) { { full_name: true } }
     it 'caches and returns identical results for the same field objects' do
       expect(person).to receive(:full_name).once.and_call_original
 
-      render_1 = renderer.render(person, fields)
-      render_2 = renderer.render(person, fields)
-      expect(render_1).to be(render_2)
+      render1 = renderer.render(person, fields)
+      render2 = renderer.render(person, fields)
+      expect(render1).to be(render2)
     end
   end
 

data/spec/praxis/request_spec.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Praxis::Request do
-  let(:path) { '/instances/1?junk=foo&api_version=1.0' } 
+  let(:path) { '/instances/1?junk=foo&api_version=1.0' }
   let(:rack_input) { StringIO.new('{"something": "given"}') }
-  let(:env_content_type){ 'application/json' }
+  let(:env_content_type) { 'application/json' }
   let(:env) do
     env = Rack::MockRequest.env_for(path)
     env['rack.input'] = rack_input
@@ -17,9 +19,9 @@ describe Praxis::Request do
 
   let(:context) do
     {
-      params: [Attributor::ROOT_PREFIX, "params".freeze],
-      headers: [Attributor::ROOT_PREFIX, "headers".freeze],
-      payload: [Attributor::ROOT_PREFIX, "payload".freeze]
+      params: [Attributor::ROOT_PREFIX, 'params'],
+      headers: [Attributor::ROOT_PREFIX, 'headers'],
+      payload: [Attributor::ROOT_PREFIX, 'payload']
     }.freeze
   end
 
@@ -29,9 +31,9 @@ describe Praxis::Request do
     request
   end
 
-  its(:verb) { should eq("GET") }
+  its(:verb) { should eq('GET') }
   its(:path) { should eq('/instances/1') }
-  its(:raw_params) { should eq({'junk' => 'foo'}) }
+  its(:raw_params) { should eq({ 'junk' => 'foo' }) }
   its(:version) { should eq('1.0') }
 
   context 'path versioning' do
@@ -42,26 +44,24 @@ describe Praxis::Request do
       allow(
         Praxis::ApiDefinition.instance.info
       ).to receive(:base_path).and_return('/api/v:api_version')
-
     end
 
     let(:path) { '/api/v2.0/instances/1' }
 
-
     its(:version) { should eq '2.0' }
-    #its('class.path_version_prefix'){ should eq("/v") }
-    #its(:path_version_matcher){ should be_kind_of(Regexp) }
-    #it 'uses a "/v*" default matcher with a "version" named capture' do
+    # its('class.path_version_prefix'){ should eq("/v") }
+    # its(:path_version_matcher){ should be_kind_of(Regexp) }
+    # it 'uses a "/v*" default matcher with a "version" named capture' do
     #  match = subject.path_version_matcher.match("/v5.5/something")
     #  expect(match).to_not be(nil)
     #  expect(match['version']).to eq("5.5")
-    #end
+    # end
   end
 
   context 'loading api version' do
-    #let(:request) { Praxis::Request.new(env) }
-    subject(:version){ request.version }
-    let(:versioning_scheme){ Praxis::Request::VERSION_USING_DEFAULTS }
+    # let(:request) { Praxis::Request.new(env) }
+    subject(:version) { request.version }
+    let(:versioning_scheme) { Praxis::Request::VERSION_USING_DEFAULTS }
     before do
       allow(
         Praxis::Application.instance
@@ -69,18 +69,18 @@ describe Praxis::Request do
     end
 
     context 'using X-Api-Header' do
-      let(:env){ {'HTTP_X_API_VERSION' => "5.0", "PATH_INFO" => "/something"} }
-      let(:versioning_scheme){ :header }
+      let(:env) { { 'HTTP_X_API_VERSION' => '5.0', 'PATH_INFO' => '/something' } }
+      let(:versioning_scheme) { :header }
       it { should eq('5.0') }
     end
     context 'using query param' do
       let(:env) { Rack::MockRequest.env_for('/instances/1?junk=foo&api_version=5.0') }
-      let(:versioning_scheme){ :params }
+      let(:versioning_scheme) { :params }
       it { should eq('5.0') }
     end
     context 'using path (with the default pattern matcher)' do
-      let(:env){ Rack::MockRequest.env_for('/v5.0/instances/1?junk=foo') }
-      let(:versioning_scheme){ :path }
+      let(:env) { Rack::MockRequest.env_for('/v5.0/instances/1?junk=foo') }
+      let(:versioning_scheme) { :path }
 
       before do
         allow(
@@ -92,21 +92,21 @@ describe Praxis::Request do
 
     context 'using a method that it is not allowed in the definition' do
       context 'allowing query param but passing it through a header' do
-        let(:env){ {'HTTP_X_API_VERSION' => "5.0", "PATH_INFO" => "/something"} }
-        let(:versioning_scheme){ :params }
+        let(:env) { { 'HTTP_X_API_VERSION' => '5.0', 'PATH_INFO' => '/something' } }
+        let(:versioning_scheme) { :params }
         it { should eq('n/a') }
       end
       context 'allowing header but passing it through param' do
         let(:env) { Rack::MockRequest.env_for('/instances/1?junk=foo&api_version=5.0') }
-        let(:versioning_scheme){ :header }
+        let(:versioning_scheme) { :header }
         it { should eq('n/a') }
       end
     end
 
     context 'using defaults' do
-      subject(:version){ request.version }
+      subject(:version) { request.version }
       context 'would succeed if passed through the header' do
-        let(:env){ {'HTTP_X_API_VERSION' => "5.0", "PATH_INFO" => "/something"} }
+        let(:env) { { 'HTTP_X_API_VERSION' => '5.0', 'PATH_INFO' => '/something' } }
         it { should eq('5.0') }
       end
       context 'would succeed if passed through params' do
@@ -126,9 +126,9 @@ describe Praxis::Request do
       form_data
     end
 
-    let(:rack_input) {
+    let(:rack_input) do
       StringIO.new(form.body.to_s)
-    }
+    end
 
     let(:env) do
       env = Rack::MockRequest.env_for('/instances/1?junk=foo&api_version=1.0')
@@ -138,21 +138,18 @@ describe Praxis::Request do
       env
     end
 
-    #its(:multipart?) { should be(true) }
+    # its(:multipart?) { should be(true) }
 
     it 'works' do
-      #p request #.body
-      #p request #.parts
+      # p request #.body
+      # p request #.parts
     end
-
-
   end
 
   context '#load_headers' do
-
     it 'is done preserving the original case' do
       request.load_headers(context[:headers])
-      expect(request.headers).to eq({"Authorization" => "Secret"})
+      expect(request.headers).to eq({ 'Authorization' => 'Secret' })
     end
 
     it 'performs it using the memoized rack keys from the action (Hacky but...performance is important)' do
@@ -161,7 +158,7 @@ describe Praxis::Request do
     end
   end
 
-  context "performs request validation" do
+  context 'performs request validation' do
     before(:each) do
       request.load_headers(context[:headers])
       request.load_params(context[:params])
@@ -205,17 +202,17 @@ describe Praxis::Request do
     end
 
     context '#load_payload' do
-      let(:load_context){ context[:payload] }
-      let(:parsed_result){ double("parsed") }
+      let(:load_context) { context[:payload] }
+      let(:parsed_result) { double('parsed') }
 
       after do
-        expect(request.action.payload).to receive(:load).with(parsed_result, load_context, content_type: request.content_type.to_s )
-        request.load_payload( load_context )
+        expect(request.action.payload).to receive(:load).with(parsed_result, load_context, content_type: request.content_type.to_s)
+        request.load_payload(load_context)
       end
 
       context 'that is json encoded' do
         let(:rack_input) { StringIO.new('{"one":1,"sub_hash":{"first":"hello"}}') }
-        let(:env_content_type){ 'application/json' }
+        let(:env_content_type) { 'application/json' }
         let(:parsed_result) { Praxis::Handlers::JSON.new.parse(request.raw_payload) }
 
         it 'decodes using the JSON handler' do end

data/spec/praxis/request_stages/action_spec.rb

@@ -1,17 +1,18 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Praxis::RequestStages::Action do
-
   let(:controller) do
     Class.new do
       include Praxis::Controller
     end.new(request)
   end
 
-  let(:action) { double("action", name: "foo") }
-  let(:response){ Praxis::Responses::Ok.new }
-  let(:app){ double("App", controller: controller, action:action, request: request)}
-  let(:action_stage){ Praxis::RequestStages::Action.new(action.name,app) }
+  let(:action) { double('action', name: 'foo') }
+  let(:response) { Praxis::Responses::Ok.new }
+  let(:app) { double('App', controller: controller, action: action, request: request) }
+  let(:action_stage) { Praxis::RequestStages::Action.new(action.name, app) }
 
   let(:request) do
     env = Rack::MockRequest.env_for('/instances/1?cloud_id=1&api_version=1.0')
@@ -23,19 +24,17 @@ describe Praxis::RequestStages::Action do
     request
   end
 
-
   context '.execute' do
     before do
       expect(controller).to receive(action_stage.name) do |args|
         if args
           expect(args).to eq({})
         else
-           expect(args).to eq(nil)
+          expect(args).to eq(nil)
         end
       end.and_return(controller_response)
-        
     end
-    let(:controller_response){ controller.response }
+    let(:controller_response) { controller.response }
 
     it 'always call the right controller method' do
       action_stage.execute
@@ -47,28 +46,28 @@ describe Praxis::RequestStages::Action do
     end
 
     it 'sends the right ActiveSupport::Notification' do
-      expect(ActiveSupport::Notifications).to receive(:instrument).with('praxis.request_stage.execute', {controller: an_instance_of(controller.class)}).and_call_original
+      expect(ActiveSupport::Notifications).to receive(:instrument).with('praxis.request_stage.execute', { controller: an_instance_of(controller.class) }).and_call_original
       action_stage.execute
     end
 
     context 'if the controller method returns a string' do
-      let(:controller_response){ "this is the body"}
+      let(:controller_response) { 'this is the body' }
       it 'sets the response body with it (and save the request too)' do
         action_stage.execute
-        expect(controller.response.body).to eq("this is the body")
+        expect(controller.response.body).to eq('this is the body')
       end
     end
     context 'if the controller method returns a response object' do
-      let(:controller_response){ Praxis::Responses::Created.new }
+      let(:controller_response) { Praxis::Responses::Created.new }
       it 'set that response in the controller' do
         action_stage.execute
         expect(controller.response).to eq(controller_response)
       end
     end
     context 'if the controller method returns neither a string or a response' do
-      let(:controller_response){ nil }
+      let(:controller_response) { nil }
       it 'an error is raised ' do
-        expect{ action_stage.execute }.to raise_error(/Only Response objects or Strings allowed/)
+        expect { action_stage.execute }.to raise_error(/Only Response objects or Strings allowed/)
       end
     end
   end