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

data/spec/praxis/response_spec.rb

@@ -1,11 +1,12 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
+require 'spec_helper'
 
 describe Praxis::Response do
   let(:spec_status)     { 200 }
   let(:spec_location)   { /resources/ }
   let(:spec_headers)    { { 'X-Header' => 'Foobar' } }
-  let(:spec_mime_type)  { "application/vnd.resource" }
+  let(:spec_mime_type)  { 'application/vnd.resource' }
 
   let(:application_vnd_resource_media_type) do
     Class.new(Praxis::MediaType) do
@@ -18,33 +19,33 @@ describe Praxis::Response do
   let(:response_spec) do
     instance_double(
       Praxis::ResponseDefinition,
-      :status     => spec_status,
-      :location   => spec_location,
-      :headers    => spec_headers,
-      :media_type => spec_media_type,
-      :name       => :ok
+      status: spec_status,
+      location: spec_location,
+      headers: spec_headers,
+      media_type: spec_media_type,
+      name: :ok
     )
   end
 
   let(:action) do
     instance_double(
       Praxis::ActionDefinition,
-      :endpoint_definition => config_class
+      endpoint_definition: config_class
     )
   end
 
   let(:response_status)  { 200 }
-  let(:response_headers) {
+  let(:response_headers) do
     { 'Content-Type' => 'application/vnd.resource+json;type=collection',
-      'X-Header'     => 'Foobar',
-      'Location'     => '/api/resources/123' }
-  }
+      'X-Header' => 'Foobar',
+      'Location' => '/api/resources/123' }
+  end
 
   let(:config_media_type) { nil }
   let(:config_class) do
     instance_double(
       Praxis::ResponseDefinition,
-      :media_type => config_media_type
+      media_type: config_media_type
     )
   end
 
@@ -52,7 +53,7 @@ describe Praxis::Response do
 
   describe '#validate' do
     before do
-      allow(action).to receive(:responses).and_return({response_spec.name => response_spec })
+      allow(action).to receive(:responses).and_return({ response_spec.name => response_spec })
     end
     context 'response spec is not defined' do
       before :each do
@@ -60,26 +61,23 @@ describe Praxis::Response do
       end
 
       it 'should raise an error' do
-        expect {
+        expect do
           response.validate(action)
-        }.to raise_error(Praxis::Exceptions::Validation, /response definition with that name can be found/)
+        end.to raise_error(Praxis::Exceptions::Validation, /response definition with that name can be found/)
       end
     end
 
     context 'with an existing response spec in the action' do
-
       it 'should use the spec to validate the response' do
         expect(response_spec).to receive(:validate).and_return(nil)
 
         response.validate(action)
       end
     end
-
-
   end
 
   describe '#encode!' do
-    let(:response_body_structured_data) { [{"moo" => "bah"}] }
+    let(:response_body_structured_data) { [{ 'moo' => 'bah' }] }
     let(:response_body_entity) { '[{"moo": "bah"}]' }
 
     context 'given a String body' do
@@ -96,31 +94,28 @@ describe Praxis::Response do
 
       it 'encodes using a suitable handler' do
         response.encode!
-        expect(JSON.load(response.body)).to eq(response_body_structured_data)
+        expect(JSON.parse(response.body)).to eq(response_body_structured_data)
       end
     end
 
     context 'when no Content-Type is defined' do
       before { response.body = response_body_structured_data }
 
-      let(:response_headers) {
-        { 'X-Header'     => 'Foobar',
-          'Location'     => '/api/resources/123' }
-      }
+      let(:response_headers) do
+        { 'X-Header' => 'Foobar',
+          'Location' => '/api/resources/123' }
+      end
       it 'still defaults to the default handler' do
         response.encode!
-        expect(JSON.load(response.body)).to eq(response_body_structured_data)
+        expect(JSON.parse(response.body)).to eq(response_body_structured_data)
       end
     end
-
-
   end
 
   context 'multipart responses' do
-    let(:part) { Praxis::MultipartPart.new('not so ok', {'Status' => 400, "Location" => "somewhere"}) }
+    let(:part) { Praxis::MultipartPart.new('not so ok', { 'Status' => 400, 'Location' => 'somewhere' }) }
 
     context '#add_part' do
-
       context 'without a name' do
         before do
           response.add_part(part)
@@ -140,18 +135,16 @@ describe Praxis::Response do
       context 'with a name' do
         let(:part_name) { 'a-part' }
         before do
-          response.add_part(part_name, part)
+          response.add_part(part, part_name)
         end
 
         it 'adds the part' do
           expect(response.parts[part_name]).to be(part)
         end
       end
-
     end
 
     context '#finish for a multipart response' do
-
       before do
         response.add_part(part)
         response.body = 'a preamble'
@@ -172,7 +165,7 @@ describe Praxis::Response do
       end
 
       it 'sets the headers' do
-        expect(response.headers['Content-Type']).to match(/multipart\/form-data/)
+        expect(response.headers['Content-Type']).to match(%r{multipart/form-data})
         expect(response.headers['Location']).to eq('/api/resources/123')
       end
 
@@ -180,7 +173,7 @@ describe Praxis::Response do
         parser = Praxis::MultipartParser.new(response.headers, response.body)
         preamble, parts = parser.parse
 
-        expect(preamble).to eq("a preamble")
+        expect(preamble).to eq('a preamble')
         expect(parts).to have(1).item
 
         part_response = parts.first
@@ -189,9 +182,5 @@ describe Praxis::Response do
         expect(part_response.body).to eq('not so ok')
       end
     end
-
   end
-
-
-
 end

data/spec/praxis/responses/internal_server_error_spec.rb

@@ -1,8 +1,8 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
+require 'spec_helper'
 
 describe Praxis::Responses::InternalServerError do
-
   context 'a basic response' do
     subject(:response) { Praxis::Responses::InternalServerError.new }
     it 'always sets the json content type' do
@@ -15,12 +15,11 @@ describe Praxis::Responses::InternalServerError do
     end
   end
 
-
   context '.format!' do
     let(:error) { double('error', message: 'error message', backtrace: [1, 2], cause: cause) }
 
     let(:show_exceptions) { true }
-    let(:config) { double("config", show_exceptions: show_exceptions) }
+    let(:config) { double('config', show_exceptions: show_exceptions) }
 
     before do
       allow(Praxis::Application.instance.config).to receive(:praxis).and_return(config)
@@ -30,18 +29,17 @@ describe Praxis::Responses::InternalServerError do
     end
 
     context 'with show_exceptions true' do
-
       context 'without a cause' do
         let(:cause) { nil }
         it 'it fills message and backtrace' do
-          expect(response.body).to eq({name: error.class.name, message: error.message, backtrace: error.backtrace})
+          expect(response.body).to eq({ name: error.class.name, message: error.message, backtrace: error.backtrace })
         end
       end
 
       context 'with a cause' do
         let(:cause) { Exception.new('cause message') }
         it 'it fills message, backtrace and cause' do
-          expect(response.body.keys).to eq([:name, :message, :backtrace, :cause])
+          expect(response.body.keys).to eq(%i[name message backtrace cause])
           expect(response.body[:name]).to eq(error.class.name)
           expect(response.body[:message]).to eq(error.message)
           expect(response.body[:backtrace]).to eq(error.backtrace)
@@ -55,11 +53,10 @@ describe Praxis::Responses::InternalServerError do
       expect(response.body).to be_nil
       response.format!
     end
-
   end
 
   context 'its response template' do
-    let(:template){ Praxis::ApiDefinition.instance.responses[:internal_server_error] }
+    let(:template) { Praxis::ApiDefinition.instance.responses[:internal_server_error] }
     it 'is registered with the ApiDefinition' do
       expect(template).to be_kind_of(Praxis::ResponseTemplate)
     end

data/spec/praxis/responses/validation_error_spec.rb

@@ -1,9 +1,9 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
+require 'spec_helper'
 
 describe Praxis::Responses::ValidationError do
-
-  let(:summary){ "Something happened here" }
+  let(:summary) { 'Something happened here' }
   context 'a basic response' do
     subject(:response) { Praxis::Responses::ValidationError.new(summary: summary) }
     it 'always sets the json content type' do
@@ -18,10 +18,10 @@ describe Praxis::Responses::ValidationError do
   end
 
   context '.format!' do
-    let(:errors) { [1,2] }
-    let(:cause){ Exception.new( "cause message") }
-    let(:exception_message){ "exception message" }
-    let(:exception){ nil }
+    let(:errors) { [1, 2] }
+    let(:cause) { Exception.new('cause message') }
+    let(:exception_message) { 'exception message' }
+    let(:exception) { nil }
     subject(:response) { Praxis::Responses::ValidationError.new(summary: summary, errors: errors, exception: exception) }
     before do
       expect(response.body).to be_nil
@@ -29,18 +29,18 @@ describe Praxis::Responses::ValidationError do
     context 'when errors' do
       it 'it fills the errors key' do
         response.format!
-        expect(response.body).to eq({name: 'ValidationError', summary: summary, errors: errors})
+        expect(response.body).to eq({ name: 'ValidationError', summary: summary, errors: errors })
       end
     end
 
     context 'without errors but with an exception' do
       let(:errors) { nil }
-      let(:exception){ double("exception", message: exception_message, cause: cause)}
+      let(:exception) { double('exception', message: exception_message, cause: cause) }
       before do
-         response.format!
-         expect(response.body.keys).to include(:name,:summary)
-         expect(response.body[:name]).to eq('ValidationError')
-         expect(response.body[:summary]).to eq(summary)
+        response.format!
+        expect(response.body.keys).to include(:name, :summary)
+        expect(response.body[:name]).to eq('ValidationError')
+        expect(response.body[:summary]).to eq(summary)
       end
 
       context 'that has a message' do
@@ -51,14 +51,14 @@ describe Praxis::Responses::ValidationError do
       end
 
       context 'that does not contain a message' do
-        let(:exception_message){ nil }
+        let(:exception_message) { nil }
         it 'does not touch the errors key' do
           expect(response.body).to_not have_key(:errors)
         end
       end
 
       context 'without cause' do
-        let(:cause){ nil}
+        let(:cause) { nil }
         it 'does not include it in the output' do
           expect(response.body).to_not have_key(:cause)
         end
@@ -67,15 +67,14 @@ describe Praxis::Responses::ValidationError do
       context 'with a cause' do
         it 'it fills the cause too' do
           expect(response.body).to have_key(:cause)
-          expect(response.body[:cause]).to eq({name: cause.class.name, message: cause.message })
+          expect(response.body[:cause]).to eq({ name: cause.class.name, message: cause.message })
         end
       end
     end
-
   end
 
   context 'its response template' do
-    let(:template){ Praxis::ApiDefinition.instance.responses[:validation_error] }
+    let(:template) { Praxis::ApiDefinition.instance.responses[:validation_error] }
     it 'is registered with the ApiDefinition' do
       expect(template).to be_kind_of(Praxis::ResponseTemplate)
     end

data/spec/praxis/route_spec.rb

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Praxis::Route do
-
   let(:verb) { 'GET' }
   let(:path) { '/base/stuff' }
   let(:prefixed_path) { '/stuff' }
@@ -23,15 +24,11 @@ describe Praxis::Route do
 
   context '#describe' do
     subject(:description) { route.describe }
-    it { should eq({verb:verb, path:path , version:version}) }
+    it { should eq({ verb: verb, path: path, version: version }) }
 
     context 'with options' do
-      let(:options) { {option: 'value'} }
+      let(:options) { { option: 'value' } }
       its([:options]) { should eq(options) }
     end
-
   end
-
-
-
 end

data/spec/praxis/router_spec.rb

@@ -1,26 +1,28 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Praxis::Router do
   describe Praxis::Router::VersionMatcher do
-    let(:endpoint_definition){ double("endpoint_definition", version_options: { using: [:header, :params] }) }
-    let(:action){ double("action", endpoint_definition: endpoint_definition ) }
-    let(:target){ double("target", action: action ) }
-    let(:args){ {version: "1.0"} }
-    subject(:matcher){ Praxis::Router::VersionMatcher.new(target,**args) }
+    let(:endpoint_definition) { double('endpoint_definition', version_options: { using: %i[header params] }) }
+    let(:action) { double('action', endpoint_definition: endpoint_definition) }
+    let(:target) { double('target', action: action) }
+    let(:args) { { version: '1.0' } }
+    subject(:matcher) { Praxis::Router::VersionMatcher.new(target, **args) }
 
     context '.initialize' do
-      let(:args){ {} }
+      let(:args) { {} }
       it 'defaults to no version' do
-        expect( matcher.instance_variable_get(:@version) ).to eq("n/a")
+        expect(matcher.instance_variable_get(:@version)).to eq('n/a')
       end
     end
 
     context '.call' do
-      let(:env){ {"HTTP_X_API_VERSION" => request_version } }
-      let(:request) {Praxis::Request.new(env)}
+      let(:env) { { 'HTTP_X_API_VERSION' => request_version } }
+      let(:request) { Praxis::Request.new(env) }
 
       context 'with matching versions' do
-        let(:request_version) { "1.0" }
+        let(:request_version) { '1.0' }
         it 'calls the target' do
           expect(target).to receive(:call).with(request)
           matcher.call(request)
@@ -28,67 +30,63 @@ describe Praxis::Router do
       end
 
       context 'with non-matching versions' do
-        let(:request_version) { "4.0" }
+        let(:request_version) { '4.0' }
         before do
           expect { matcher.call(request) }.to throw_symbol(:pass)
         end
         it 'does not call the target' do
-          expect( target ).not_to receive(:call).with(request)
+          expect(target).not_to receive(:call).with(request)
         end
         it 'saves the unmatched version' do
-          expect( request.unmatched_versions ).to include(args[:version])
+          expect(request.unmatched_versions).to include(args[:version])
         end
       end
-
     end
   end
 
   describe Praxis::Router::RequestRouter do
+    let(:request) { double('request', route_params: '', path: 'path') }
+    let(:callback) { double('callback') }
 
-    let(:request) {double("request", route_params: '', path: 'path')}
-    let(:callback) {double("callback")}
+    subject(:request_router) { Praxis::Router::RequestRouter.new }
 
-    subject(:request_router) {Praxis::Router::RequestRouter.new}
-
-    context ".invoke" do
-      it "update request and call request for callback" do
+    context '.invoke' do
+      it 'update request and call request for callback' do
         allow(request).to receive(:route_params=)
         allow(callback).to receive(:call).and_return(1)
 
-        invoke_call = request_router.invoke(callback, request, "params", "pattern")
+        invoke_call = request_router.invoke(callback, request, 'params', 'pattern')
         expect(invoke_call).to eq(1)
       end
     end
 
-    context ".string_for" do
-      it "returns request path string" do
+    context '.string_for' do
+      it 'returns request path string' do
         expect(request_router.string_for(request)).to eq('path')
       end
     end
   end
 
-  let(:application) { instance_double('Praxis::Application')}
-  subject(:router) {Praxis::Router.new(application)}
+  let(:application) { instance_double('Praxis::Application') }
+  subject(:router) { Praxis::Router.new(application) }
 
-  context "attributes" do
-    its(:request_class) {should be(Praxis::Request)}
+  context 'attributes' do
+    its(:request_class) { should be(Praxis::Request) }
   end
 
-  context ".add_route" do
-
-    let(:route){ double('route', options: [1], version: 1, verb: 'verb', path: 'path')}
-    let(:target){ double('target') }
-    let(:verb_router){ double('verb_router') }
+  context '.add_route' do
+    let(:route) { double('route', options: [1], version: 1, verb: 'verb', path: 'path') }
+    let(:target) { double('target') }
+    let(:verb_router) { double('verb_router') }
 
-    let(:endpoint_definition) { double('endpoint_definition', version_options: {using: [:header, :params]} ) }
+    let(:endpoint_definition) { double('endpoint_definition', version_options: { using: %i[header params] }) }
     let(:action) { double('action', endpoint_definition: endpoint_definition) }
     let(:target) { double('target', action: action) }
 
-
     context 'with params or header versioning' do
       it 'wraps the target with a VersionMatcher' do
-        router.instance_variable_set( :@routes, {'verb'=>verb_router} ) # Ugly, but no need to have a reader
-        expect(verb_router).to receive(:on) do|path, args|# .with(route.path, call: "foo")
+        router.instance_variable_set(:@routes, { 'verb' => verb_router }) # Ugly, but no need to have a reader
+        expect(verb_router).to receive(:on) do |path, args| # .with(route.path, call: "foo")
           expect(path).to eq(route.path)
           expect(args).to be_kind_of(Hash)
           expect(args[:call]).to be_kind_of(Praxis::Router::VersionMatcher)
@@ -96,75 +94,72 @@ describe Praxis::Router do
         router.add_route(target, route)
       end
     end
-
   end
 
-  context ".call" do
-    let(:env){ {"PATH_INFO"=>request_path_info, "REQUEST_METHOD"=>request_verb} }
+  context '.call' do
+    let(:env) { { 'PATH_INFO' => request_path_info, 'REQUEST_METHOD' => request_verb } }
     let(:request_verb) { 'POST' }
     let(:request_path_info) { '/' }
-    let(:request_version){ nil }
-    let(:request) {Praxis::Request.new(env)}
-    let(:router_response){ 1 }
-    let(:router_response_for_post){ "POST result" }
-    let(:router_response_for_wildcard){ "* result" }
-    let(:post_target_router){ double("POST target", call: router_response_for_post) }
-    let(:any_target_router){ double("ANY target", call: router_response_for_wildcard) }
-
-    let(:endpoint_definition) { double('endpoint_definition', version_options: {using: [:header, :params]} ) }
+    let(:request_version) { nil }
+    let(:request) { Praxis::Request.new(env) }
+    let(:router_response) { 1 }
+    let(:router_response_for_post) { 'POST result' }
+    let(:router_response_for_wildcard) { '* result' }
+    let(:post_target_router) { double('POST target', call: router_response_for_post) }
+    let(:any_target_router) { double('ANY target', call: router_response_for_wildcard) }
+
+    let(:endpoint_definition) { double('endpoint_definition', version_options: { using: %i[header params] }) }
     let(:action) { double('action', endpoint_definition: endpoint_definition) }
     let(:target) { double('target', action: action) }
 
     before do
       env['HTTP_X_API_VERSION'] = request_version if request_version
-      allow_any_instance_of(Praxis::Router::RequestRouter).
-        to receive(:call).with(request).and_return(router_response)
-      router.add_route(target,double("route1", verb: 'POST', path: '/', options: {} , version: request_version))
+      allow_any_instance_of(Praxis::Router::RequestRouter)
+        .to receive(:call).with(request).and_return(router_response)
+      router.add_route(target, double('route1', verb: 'POST', path: '/', options: {}, version: request_version))
       # Hijack the callable block in the routes (since there's no way to point back to the registered route object)
       router.instance_variable_get(:@routes)['POST'] = post_target_router
-
     end
 
     context 'for routes without wildcards (a single POST route)' do
-
       context 'and an incoming POST request' do
-        it "finds a match and invokes it the route" do
+        it 'finds a match and invokes it the route' do
           expect(router.call(request)).to eq(router_response_for_post)
         end
       end
       context 'and an incoming PUT request' do
         let(:request_verb) { 'PUT' }
-        it "does not find a route" do
-          response_code, _ , _ = router.call(request)
+        it 'does not find a route' do
+          response_code, = router.call(request)
           expect(response_code).to be(404)
         end
       end
     end
 
     context 'for routes with wildcards (a POST and a * route)' do
-      let(:endpoint_definition) { double('endpoint_definition', version_options: {using: [:header, :params]} ) }
+      let(:endpoint_definition) { double('endpoint_definition', version_options: { using: %i[header params] }) }
       let(:action) { double('action', endpoint_definition: endpoint_definition) }
       let(:target) { double('target', action: action) }
 
       before do
-        router.add_route(target,double("route2", verb: 'ANY', path: '/*', options: {} , version: request_version))
+        router.add_route(target, double('route2', verb: 'ANY', path: '/*', options: {}, version: request_version))
         # Hijack the callable block in the routes (since there's no way to point back to the registered route object)
-        router.instance_variable_get( :@routes )['ANY'] = any_target_router
+        router.instance_variable_get(:@routes)['ANY'] = any_target_router
       end
 
       context 'and an incoming PUT request' do
         let(:request_verb) { 'PUT' }
-        it "it can successfully find a match using the wildcard target" do
+        it 'it can successfully find a match using the wildcard target' do
           expect(router.call(request)).to eq(router_response_for_wildcard)
         end
       end
       context 'and an incoming POST request' do
-        it 'matches the most specific POST route, rather than the wildcard'do
+        it 'matches the most specific POST route, rather than the wildcard' do
           expect(router.call(request)).to eq(router_response_for_post)
         end
       end
       context 'and an incoming POST request (but that does not match other route conditions)' do
-        let(:router_response_for_post){ :not_found }
+        let(:router_response_for_post) { :not_found }
         it 'still matches wildcard verb if that was route conditions-compatible' do
           expect(post_target_router).to receive(:call).once # try the match cause it's a POST
           expect(any_target_router).to receive(:call).once  # fallback to wildcard upon a not_found
@@ -173,13 +168,12 @@ describe Praxis::Router do
       end
     end
 
-    context "when not_found is returned" do
+    context 'when not_found is returned' do
       let(:request_verb) { 'DELETE' }
-      let(:router_response){ :not_found }
-
+      let(:router_response) { :not_found }
 
       it 'sets X-Cascade: pass by default' do
-        _, headers, _ = router.call(request)
+        _, headers, = router.call(request)
         expect(headers).to have_key('X-Cascade')
         expect(headers['X-Cascade']).to eq('pass')
       end
@@ -191,10 +185,9 @@ describe Praxis::Router do
         end
 
         it 'does not set X-Cascade: pass' do
-          _, headers, _ = router.call(request)
-          expect(headers).to_not have_key("X-Cascade")
+          _, headers, = router.call(request)
+          expect(headers).to_not have_key('X-Cascade')
         end
-
       end
 
       context 'with versioning' do
@@ -202,29 +195,28 @@ describe Praxis::Router do
           request.instance_variable_set(:@unmatched_versions, unmatched_versions)
         end
 
-        context "having passed no version in the request" do
+        context 'having passed no version in the request' do
           context 'and no controllers matching the path' do
             let(:unmatched_versions) { Set.new([]) }
 
             it 'returns a basic "NotFound" response: 404 status, text/plain content and "NotFound" body' do
-              expect( router.call(request) ).to eq([404, {"Content-Type" => "text/plain","X-Cascade"=>"pass"}, ["NotFound"]])
+              expect(router.call(request)).to eq([404, { 'Content-Type' => 'text/plain', 'X-Cascade' => 'pass' }, ['NotFound']])
             end
           end
 
           context 'and some controllers matching the path' do
-            let(:unmatched_versions) { Set.new(["1.0"]) }
+            let(:unmatched_versions) { Set.new(['1.0']) }
             it 'returns a specific body response noting which request versions would matched if passed in' do
               _, _, body = router.call(request)
-              expect( body.first ).to eq('NotFound. Your request did not specify an API version. Available versions = "1.0".')
+              expect(body.first).to eq('NotFound. Your request did not specify an API version. Available versions = "1.0".')
             end
           end
         end
 
-        context "having passed a version in the request" do
-
+        context 'having passed a version in the request' do
           context 'but having no controllers matching the path part' do
-            let(:request_version) { "50.0" }
-            let(:unmatched_versions) { Set.new(["1.0","2.0"]) }
+            let(:request_version) { '50.0' }
+            let(:unmatched_versions) { Set.new(['1.0', '2.0']) }
 
             it 'returns a specific body response noting that the version might be wrong (and which could be right)' do
               code, headers, body = router.call(request)
@@ -235,8 +227,6 @@ describe Praxis::Router do
           end
         end
       end
-
-
     end
   end
 end