praxis 2.0.pre.17 → 2.0.pre.21

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::AttributeResolver::ROOT_PREFIX, "params".freeze],
-      headers: [Attributor::AttributeResolver::ROOT_PREFIX, "headers".freeze],
-      payload: [Attributor::AttributeResolver::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

data/spec/praxis/request_stages/request_stage_spec.rb

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Praxis::RequestStages::RequestStage do
-
   let(:controller_class) do
     Class.new do
       include Praxis::Controller
@@ -11,15 +12,14 @@ describe Praxis::RequestStages::RequestStage do
   let(:stage_class) { Class.new(Praxis::RequestStages::RequestStage) }
 
   let(:request) { Praxis::Request.new({}) }
-  let(:controller){ controller_class.new(request) }
+  let(:controller) { controller_class.new(request) }
 
+  let(:action) { instance_double('Praxis::ActionDefinition') }
+  let(:context) { double('context', controller: controller, action: action) }
 
-  let(:action){ instance_double("Praxis::ActionDefinition") }
-  let(:context){ double("context", controller: controller , action: action) }
-
-  let(:substage_1) { instance_double('Praxis::RequestStage') }
-  let(:substage_2) { instance_double('Praxis::RequestStage') }
-  let(:substage_3) { instance_double('Praxis::RequestStage') }
+  let(:substage1) { instance_double('Praxis::RequestStage') }
+  let(:substage2) { instance_double('Praxis::RequestStage') }
+  let(:substage3) { instance_double('Praxis::RequestStage') }
 
   let(:before_callbacks) { double('before_callbacks') }
   let(:after_callbacks) { double('after_callbacks') }
@@ -28,19 +28,18 @@ describe Praxis::RequestStages::RequestStage do
 
   subject(:stage) { stage_class.new(:action, context) }
 
-
   before do
     # clear any pre-existing callbacks that may have been added by plugins
-    controller_class.before_callbacks = Hash.new
-    controller_class.after_callbacks = Hash.new
+    controller_class.before_callbacks = ({})
+    controller_class.after_callbacks = ({})
   end
 
   context 'for an abstract stage' do
     subject(:stage) { Praxis::RequestStages::RequestStage.new(:action, context) }
     it 'raises NotImplementedError for undefined #execute' do
-      expect {
+      expect do
         stage.execute
-      }.to raise_error(NotImplementedError,/Subclass must implement Stage#execute/)
+      end.to raise_error(NotImplementedError, /Subclass must implement Stage#execute/)
     end
   end
 
@@ -57,16 +56,16 @@ describe Praxis::RequestStages::RequestStage do
     end
   end
 
-  context "#execute" do
+  context '#execute' do
     before do
-      stage.stages.push(substage_1, substage_2, substage_3)
+      stage.stages.push(substage1, substage2, substage3)
     end
 
     context 'when all stages succeed' do
-      it "runs them all and returns nil" do
-        expect(substage_1).to receive(:run).once
-        expect(substage_2).to receive(:run).once
-        expect(substage_3).to receive(:run).once
+      it 'runs them all and returns nil' do
+        expect(substage1).to receive(:run).once
+        expect(substage2).to receive(:run).once
+        expect(substage3).to receive(:run).once
         expect(stage.execute).to be(nil)
       end
     end
@@ -74,12 +73,12 @@ describe Praxis::RequestStages::RequestStage do
     context 'when one stage returns a Response' do
       let(:response) { Praxis::Responses::Ok.new }
       before do
-        expect(substage_1).to receive(:run).once
-        expect(substage_2).to receive(:run).once.and_return(response)
+        expect(substage1).to receive(:run).once
+        expect(substage2).to receive(:run).once.and_return(response)
       end
 
-      it "runs no further stages after that" do
-        expect(substage_3).to_not receive(:run)
+      it 'runs no further stages after that' do
+        expect(substage3).to_not receive(:run)
         stage.execute
       end
 
@@ -88,12 +87,10 @@ describe Praxis::RequestStages::RequestStage do
 
         expect(controller.response).to be(response)
       end
-
     end
   end
 
-  context "#run" do
-
+  context '#run' do
     let(:before_callbacks) { double('before_callbacks') }
     let(:after_callbacks) { double('after_callbacks') }
 
@@ -113,14 +110,13 @@ describe Praxis::RequestStages::RequestStage do
         allow(controller_class).to receive(:after_callbacks).once.and_return(controller_after_callbacks)
       end
 
-      it "sets up and executes callbacks" do
+      it 'sets up and executes callbacks' do
         expect(stage).to receive(:execute)
         expect(stage).to receive(:execute_callbacks).once.with(before_callbacks)
         expect(stage).to receive(:execute_callbacks).once.with(after_callbacks)
         expect(stage).to receive(:execute_controller_callbacks).once.with(controller_before_callbacks)
         expect(stage).to receive(:execute_controller_callbacks).once.with(controller_after_callbacks)
       end
-
     end
 
     context 'when the before execute_controller_callbacks return a Response' do
@@ -131,7 +127,6 @@ describe Praxis::RequestStages::RequestStage do
         expect(stage).to receive(:execute_controller_callbacks).once.and_return(response)
       end
 
-
       it 'does not call "execute"' do
         expect(stage).to_not receive(:execute)
       end
@@ -140,22 +135,20 @@ describe Praxis::RequestStages::RequestStage do
         expect(stage).to_not receive(:after_callbacks)
         expect(controller_class).to_not receive(:after_callbacks)
       end
-
     end
 
     context 'with substages' do
       before do
-        stage.stages.push(substage_1, substage_2, substage_3)
+        stage.stages.push(substage1, substage2, substage3)
       end
 
-
       context 'when one returns a Response' do
         let(:response) { Praxis::Responses::Unauthorized.new }
 
         before do
-          expect(substage_1).to receive(:run).once
-          expect(substage_2).to receive(:run).once.and_return(response)
-          expect(substage_3).to_not receive(:run)
+          expect(substage1).to receive(:run).once
+          expect(substage2).to receive(:run).once.and_return(response)
+          expect(substage3).to_not receive(:run)
         end
 
         it 'runs no after callbacks (including from the controller) ' do
@@ -165,14 +158,10 @@ describe Praxis::RequestStages::RequestStage do
 
         it 'assigns controller.response' do
           # twice, because we do it once in #execute, and again in #run...
-          expect(controller).to receive(:response=).
-            with(response).twice.and_call_original
+          expect(controller).to receive(:response=)
+            .with(response).twice.and_call_original
         end
-
       end
     end
   end
-
-
-
 end

data/spec/praxis/request_stages/validate_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Praxis::RequestStages::Validate do
@@ -19,7 +21,7 @@ describe Praxis::RequestStages::Validate do
 
   let(:request) do
     r = Praxis::Request.new(env)
-    r.route_params = {id: 1}
+    r.route_params = { id: 1 }
     r.action = action
     r
   end