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

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

data/spec/praxis/routing_config_spec.rb

@@ -1,22 +1,25 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Praxis::RoutingConfig do
-
   let(:endpoint_definition) do
     Class.new do
       include Praxis::EndpointDefinition
-      def self.name; 'MyResource'; end
+      def self.name
+        'MyResource'
+      end
     end
   end
 
-  let(:routing_block) { Proc.new{} }
-  let(:base_path){ '' }
-  let(:default_route_prefix) { "/" + endpoint_definition.name.split("::").last.underscore }
+  let(:routing_block) { proc {} }
+  let(:base_path) { '' }
+  let(:default_route_prefix) { "/#{endpoint_definition.name.split('::').last.underscore}" }
 
-  subject(:routing_config){ Praxis::RoutingConfig.new(base: base_path, &routing_block) }
+  subject(:routing_config) { Praxis::RoutingConfig.new(base: base_path, &routing_block) }
 
   its(:version) { should eq('n/a') }
-  its(:prefix ) { should eq('') }
+  its(:prefix) { should eq('') }
 
   context '#prefix' do
     it 'sets the prefix' do
@@ -35,15 +38,14 @@ describe Praxis::RoutingConfig do
       routing_config.prefix '/people'
       expect(routing_config.prefix).to eq('/people')
     end
-
   end
 
   context '#add_route' do
     let(:path) { '/people' }
     let(:options) { {} }
-    let(:base_path){ '/api' }
-    let(:route) { routing_config.add_route 'GET', path, **options}
-    
+    let(:base_path) { '/api' }
+    let(:route) { routing_config.add_route 'GET', path, **options }
+
     it 'returns a corresponding Praxis::Route' do
       expect(route).to be_kind_of(Praxis::Route)
     end
@@ -53,11 +55,11 @@ describe Praxis::RoutingConfig do
     end
 
     context 'passing  options' do
-      let(:options){ { except: '/special' } }
+      let(:options) { { except: '/special' } }
 
       it 'passes them through the underlying mustermann object (telling it to ignore unknown ones)' do
         expect(Mustermann).to receive(:new).with(base_path + path, hash_including(ignore_unknown_options: true, except: '/special'))
-        expect(route.options).to eq( { except: '/special' })
+        expect(route.options).to eq({ except: '/special' })
       end
     end
 
@@ -82,5 +84,4 @@ describe Praxis::RoutingConfig do
       end
     end
   end
-
 end

data/spec/praxis/stage_spec.rb

@@ -1,106 +1,109 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Praxis::Stage do
-  subject(:stage) {Praxis::Stage.new("name","context")}
+  subject(:stage) { Praxis::Stage.new('name', 'context') }
 
-  context "attributes" do
-    its(:name) {should eq("name")}
-    its(:context) {should eq("context")}
-    its(:stages) {should eq([])}
-    its(:before_callbacks) {should eq([])}
-    its(:after_callbacks) {should eq([])}
+  context 'attributes' do
+    its(:name) { should eq('name') }
+    its(:context) { should eq('context') }
+    its(:stages) { should eq([]) }
+    its(:before_callbacks) { should eq([]) }
+    its(:after_callbacks) { should eq([]) }
   end
 
-  context ".run" do
-    it "sets up and execute callbacks" do
+  context '.run' do
+    it 'sets up and execute callbacks' do
       expect(stage).to receive('execute')
       expect(stage).to receive('execute_callbacks').twice
       stage.run
     end
   end
 
-  context ".setup!" do
+  context '.setup!' do
     it 'should call setup_deferred_callbacks' do
       expect(stage).to receive('setup_deferred_callbacks!')
       stage.setup!
     end
   end
 
-  context ".setup_deferred_callbacks!" do
-    it "calls .before and .after for each stage name in @deferred_callbacks" do
+  context '.setup_deferred_callbacks!' do
+    it 'calls .before and .after for each stage name in @deferred_callbacks' do
       deferred_callbacks = {
-        "stage" => {
-          :before => [["before",nil]],
-          :after  => [["after",nil]]
-        }}
-      stage.instance_variable_set("@deferred_callbacks", deferred_callbacks)
-      expect(stage).to receive("before")
-      expect(stage).to receive("after")
+        'stage' => {
+          before: [['before', nil]],
+          after: [['after', nil]]
+        }
+      }
+      stage.instance_variable_set('@deferred_callbacks', deferred_callbacks)
+      expect(stage).to receive('before')
+      expect(stage).to receive('after')
       stage.setup_deferred_callbacks!
     end
   end
 
-  context ".execute" do
-    it "runs all the stages" do
-      double_stage = double("stage")
+  context '.execute' do
+    it 'runs all the stages' do
+      double_stage = double('stage')
       expect(double_stage).to receive('run')
-      stage.instance_variable_set("@stages", [double_stage])
+      stage.instance_variable_set('@stages', [double_stage])
       stage.execute
     end
   end
 
-  context ".execute_callbacks" do
-    let(:callback) {double('callback')}
-    it "executes every callback" do
-      expect(callback).to receive("call")
+  context '.execute_callbacks' do
+    let(:callback) { double('callback') }
+    it 'executes every callback' do
+      expect(callback).to receive('call')
       stage.execute_callbacks([callback])
     end
   end
 
-  context ".callback_args" do
-    # TODO should this method return something else than nil?
-    it "returns nil" do
+  context '.callback_args' do
+    # TODO: should this method return something else than nil?
+    it 'returns nil' do
       expect(stage.callback_args).to be(nil)
     end
   end
 
-  context ".before" do
-    it "adds block to @before_callbacks when stage_path is not provided" do
-      stage.before {1}
+  context '.before' do
+    it 'adds block to @before_callbacks when stage_path is not provided' do
+      stage.before { 1 }
       expect(stage.before_callbacks.last.call).to be(1)
     end
 
-    it "calls .before for the name matched stage" do
-      double_stage = double("stage", name: "name")
+    it 'calls .before for the name matched stage' do
+      double_stage = double('stage', name: 'name')
       expect(double_stage).to receive('before')
-      stage.instance_variable_set("@stages", [double_stage])
-      stage.before("name")
+      stage.instance_variable_set('@stages', [double_stage])
+      stage.before('name')
     end
 
-    it "adds to deferred_callbacks if no state name matched" do
-      double_stage = double("stage", name: "name")
-      stage.instance_variable_set("@stages", [double_stage])
-      expect(stage.before("hello", "world")).to eq([["world",nil]])
+    it 'adds to deferred_callbacks if no state name matched' do
+      double_stage = double('stage', name: 'name')
+      stage.instance_variable_set('@stages', [double_stage])
+      expect(stage.before('hello', 'world')).to eq([['world', nil]])
     end
   end
 
-  context ".after" do
-    it "adds block to @after_callbacks when stage_path is not provided" do
-      stage.after {1}
+  context '.after' do
+    it 'adds block to @after_callbacks when stage_path is not provided' do
+      stage.after { 1 }
       expect(stage.after_callbacks.last.call).to be(1)
     end
 
-    it "calls .after for the name matched stage" do
-      double_stage = double("stage", name: "name")
-      expect(double_stage).to receive("after")
-      stage.instance_variable_set("@stages", [double_stage])
-      stage.after("name")
+    it 'calls .after for the name matched stage' do
+      double_stage = double('stage', name: 'name')
+      expect(double_stage).to receive('after')
+      stage.instance_variable_set('@stages', [double_stage])
+      stage.after('name')
     end
 
-    it "adds to deferred_callbacks if no state name matched" do
-      double_stage = double("stage", name: "name")
-      stage.instance_variable_set("@stages", [double_stage])
-      expect(stage.after("hello", "world")).to eq([["world",nil]])
+    it 'adds to deferred_callbacks if no state name matched' do
+      double_stage = double('stage', name: 'name')
+      stage.instance_variable_set('@stages', [double_stage])
+      expect(stage.after('hello', 'world')).to eq([['world', nil]])
     end
   end
 end