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

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

data/spec/praxis/response_definition_spec.rb

@@ -1,15 +1,17 @@
-require "spec_helper"
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 describe Praxis::ResponseDefinition do
   subject(:response_definition) { Praxis::ResponseDefinition.new(name, &block) }
   let(:name) { 'response_name' }
 
   let(:block) do
-    Proc.new do
+    proc do
       status 200
       description 'test description'
-      header( "X-Header", "value", description: 'Very nais header')
-      header( "Content-Type", "application/some-type" )
+      header('X-Header', 'value', description: 'Very nais header')
+      header('Content-Type', 'application/some-type')
     end
   end
 
@@ -17,11 +19,10 @@ describe Praxis::ResponseDefinition do
   its(:description) { should == 'test description' }
   its(:parts) { should be(nil) }
   let(:response_status) { 200 }
-  let(:response_content_type) { "application/some-type" }
-  let(:response_headers) { { "X-Header" => "value", "Content-Type" => response_content_type, "Location" => '/somewhere/over/the/rainbow'} }
-
-  let(:response) { instance_double("Praxis::Response", status: response_status , headers: response_headers, content_type: response_content_type ) }
+  let(:response_content_type) { 'application/some-type' }
+  let(:response_headers) { { 'X-Header' => 'value', 'Content-Type' => response_content_type, 'Location' => '/somewhere/over/the/rainbow' } }
 
+  let(:response) { instance_double('Praxis::Response', status: response_status, headers: response_headers, content_type: response_content_type) }
 
   context '#media_type' do
     it 'accepts a MediaType object and returns the media_type that was set' do
@@ -42,11 +43,11 @@ describe Praxis::ResponseDefinition do
     end
 
     it 'should return an error when media_type is not a String or a MediaType' do
-      expect{ response_definition.media_type Object.new }.to raise_error(Praxis::Exceptions::InvalidConfiguration)
+      expect { response_definition.media_type Object.new }.to raise_error(Praxis::Exceptions::InvalidConfiguration)
     end
 
     it 'should return an error when media_type is a Symbol other than :controller_defined' do
-      expect{ response_definition.media_type :symbol }.to raise_error(Praxis::Exceptions::InvalidConfiguration)
+      expect { response_definition.media_type :symbol }.to raise_error(Praxis::Exceptions::InvalidConfiguration)
     end
   end
 
@@ -73,7 +74,7 @@ describe Praxis::ResponseDefinition do
     end
 
     # TODO: Complete/correct the "example" generation when it is done in the ResponseDefinition class
-    #context 'with media_type set to a MediaType' do
+    # context 'with media_type set to a MediaType' do
     #  let(:media_type) { Person }
     #
     #  let(:expected_context) { "Person-#{name}" }
@@ -87,17 +88,17 @@ describe Praxis::ResponseDefinition do
     #  it 'is rendered in the describe output' do
     #    expect(response_definition.describe[:example]).to eq(example.render)
     #  end
-    #end
+    # end
   end
 
   context '#location' do
     it 'accepts a String' do
-      response_definition.location "string_location"
-      expect(response_definition.location).to eq("string_location")
+      response_definition.location 'string_location'
+      expect(response_definition.location).to eq('string_location')
     end
 
     it 'accepts a Regex' do
-      response_definition.location /regex_location/
+      response_definition.location(/regex_location/)
       expect(response_definition.location).to eq(/regex_location/)
     end
 
@@ -114,31 +115,30 @@ describe Praxis::ResponseDefinition do
 
       subject(:parts) { response_definition.parts }
 
-      it{ should be_kind_of(Praxis::ResponseDefinition) }
-      its('media_type.identifier'){ should == 'application/special' }
-      its(:name){ should be(:ok) }
-      its(:status){ should be( 200 ) }
-
+      it { should be_kind_of(Praxis::ResponseDefinition) }
+      its('media_type.identifier') { should == 'application/special' }
+      its(:name) { should be(:ok) }
+      its(:status) { should be(200) }
     end
     context 'without a :like argument, and without a block' do
       it 'complains' do
-        expect{
+        expect do
           response_definition.parts media_type: 'application/special'
-        }.to raise_error(ArgumentError, /needs a :like argument or a block/)
+        end.to raise_error(ArgumentError, /needs a :like argument or a block/)
       end
     end
     context 'with a :like argument, and a block' do
       it 'complains' do
-        expect{
+        expect do
           response_definition.parts like: :something, media_type: 'application/special' do
           end
-        }.to raise_error(ArgumentError, /does not allow :like and a block simultaneously/)
+        end.to raise_error(ArgumentError, /does not allow :like and a block simultaneously/)
       end
     end
 
     context 'with a proc' do
       let(:the_proc) do
-        Proc.new do
+        proc do
           status 201
           media_type 'from_proc'
         end
@@ -150,10 +150,9 @@ describe Praxis::ResponseDefinition do
 
       subject(:parts) { response_definition.parts }
 
-      it{ should be_kind_of(Praxis::ResponseDefinition) }
-      its('media_type.identifier'){ should == 'from_proc' }
-      its(:status){ should be( 201 ) }
-
+      it { should be_kind_of(Praxis::ResponseDefinition) }
+      its('media_type.identifier') { should == 'from_proc' }
+      its(:status) { should be(201) }
     end
 
     context 'with a block' do
@@ -166,10 +165,9 @@ describe Praxis::ResponseDefinition do
 
       subject(:parts) { response_definition.parts }
 
-      it{ should be_kind_of(Praxis::ResponseDefinition) }
-      its('media_type.identifier'){ should == 'from_proc' }
-      its(:status){ should be( 201 ) }
-
+      it { should be_kind_of(Praxis::ResponseDefinition) }
+      its('media_type.identifier') { should == 'from_proc' }
+      its(:status) { should be(201) }
     end
   end
   #  context '#multipart' do
@@ -217,8 +215,7 @@ describe Praxis::ResponseDefinition do
 
   context '#validate' do
     context 'functional test' do
-
-      it "calls all the validation sub-functions" do
+      it 'calls all the validation sub-functions' do
         expect(response_definition).to receive(:validate_status!).once
         expect(response_definition).to receive(:validate_headers!).once
         expect(response_definition).to receive(:validate_content_type!).once
@@ -227,68 +224,64 @@ describe Praxis::ResponseDefinition do
     end
 
     describe 'custom validate_xxx! methods' do
-
-      describe "#validate_status!" do
+      describe '#validate_status!' do
         context 'that is completely valid' do
           it 'should succeed' do
-            expect {
+            expect do
               response_definition.validate_status!(response)
-            }.to_not raise_error
+            end.to_not raise_error
           end
         end
 
-
         context 'with internal error' do
           let(:response_status) { 500 }
           it 'should raise an error that later gets swallowed' do
-            expect {
+            expect do
               response_definition.validate_status!(response)
-            }.to raise_error(Praxis::Exceptions::Validation)
+            end.to raise_error(Praxis::Exceptions::Validation)
           end
         end
-
       end
 
-      describe "#validate_headers!" do
+      describe '#validate_headers!' do
         context 'when there are missing headers' do
           it 'should raise error' do
             response_definition.header('X-Unknown', 'test')
-            expect {
+            expect do
               response_definition.validate_headers!(response)
-            }.to raise_error(Praxis::Exceptions::Validation)
+            end.to raise_error(Praxis::Exceptions::Validation)
           end
         end
         context 'when headers with same names are returned' do
           it 'a simply required header should not raise error just by being there' do
             response_definition.header('X-Header', nil)
-            expect {
+            expect do
               response_definition.validate_headers!(response)
-            }.to_not raise_error
+            end.to_not raise_error
           end
           it 'an exact string header should not raise error if it fully matches' do
             response_definition.header('X-Header', 'value')
-            expect {
+            expect do
               response_definition.validate_headers!(response)
-            }.to_not raise_error
+            end.to_not raise_error
           end
           it 'a regexp header should not raise error if it matches the regexp' do
             response_definition.header('X-Header', /value/)
-            expect {
+            expect do
               response_definition.validate_headers!(response)
-            }.to_not raise_error
+            end.to_not raise_error
           end
           it 'a regexp header should raise error if it does not match the regexp' do
             response_definition.header('X-Header', /anotherthing/)
-            expect {
+            expect do
               response_definition.validate_headers!(response)
-            }.to raise_error(Praxis::Exceptions::Validation)
+            end.to raise_error(Praxis::Exceptions::Validation)
           end
         end
       end
 
-      describe "#validate_content_type!" do
-
-        let(:response_headers) { {'Content-Type' => content_type } }
+      describe '#validate_content_type!' do
+        let(:response_headers) { { 'Content-Type' => content_type } }
         let(:content_type) { 'application/none' }
 
         let(:media_type) do
@@ -299,9 +292,9 @@ describe Praxis::ResponseDefinition do
 
         context 'for definition without media_type defined' do
           it 'should not check that it matches the content type' do
-            expect {
+            expect do
               response_definition.validate_content_type!(response)
-            }.to_not raise_error
+            end.to_not raise_error
           end
         end
 
@@ -312,60 +305,58 @@ describe Praxis::ResponseDefinition do
             let(:response_content_type) { content_type }
 
             it 'validates successfully' do
-              expect {
+              expect do
                 response_definition.validate_content_type!(response)
-              }.to_not raise_error
+              end.to_not raise_error
             end
           end
 
           context 'when content type includes a parameter' do
             let(:response_content_type) { "#{content_type}; collection=true" }
             it 'validates successfully' do
-              expect {
+              expect do
                 response_definition.validate_content_type!(response)
-              }.to_not raise_error
+              end.to_not raise_error
             end
           end
 
           context 'when content type does not match' do
-            let(:response_content_type) { "application/will_never_match" }
+            let(:response_content_type) { 'application/will_never_match' }
 
             it 'should raise error telling you so' do
-              expect {
+              expect do
                 response_definition.validate_content_type!(response)
-              }.to raise_error(Praxis::Exceptions::Validation)
+              end.to raise_error(Praxis::Exceptions::Validation)
             end
           end
 
           context 'when content type is not set' do
             let(:response_headers) { {} }
             it 'should still raise an error' do
-              expect {
+              expect do
                 response_definition.validate_content_type!(response)
-              }.to raise_error(Praxis::Exceptions::Validation)
+              end.to raise_error(Praxis::Exceptions::Validation)
             end
           end
         end
       end
     end
-
   end
 
-
   context 'with invalid definitions' do
     it 'raises an error if status code is not part of the definition' do
       expect do
         Praxis::ResponseDefinition.new('response name') do
-          description "testing"
+          description 'testing'
         end
       end.to raise_error(Praxis::Exceptions::InvalidConfiguration)
     end
   end
 
   context '.describe' do
-    let(:description) { "A description" }
+    let(:description) { 'A description' }
     let(:location) { %r{/my/url/} }
-    let(:headers) { {'Header1' => 'Value1'} }
+    let(:headers) { { 'Header1' => 'Value1' } }
     let(:parts) { nil }
     let(:parts_block) { nil }
 
@@ -380,7 +371,7 @@ describe Praxis::ResponseDefinition do
       response.description(description) if description
       response.location(location) if location
       if parts || parts_block
-        parts ? response.parts(nil, **parts, &parts_block) : response.parts(nil, &parts_block) 
+        parts ? response.parts(nil, **parts, &parts_block) : response.parts(nil, &parts_block)
       end
 
       headers&.each do |(name, value)|
@@ -403,7 +394,6 @@ describe Praxis::ResponseDefinition do
         it 'properly encodes the example bodies' do
           expect(JSON.parse(examples['json'][:body])).to be_kind_of(Hash)
         end
-
       end
 
       context 'which does not have a identifier' do
@@ -416,51 +406,48 @@ describe Praxis::ResponseDefinition do
           expect(subject['json'][:content_type]).to eq('application/json')
         end
       end
-
-
     end
 
-
     context 'for a definition without parts' do
-      it{ should be_kind_of(::Hash) }
-      its([:description]){ should be(description) }
-      its([:location]){ should == {value: location.inspect ,type: :regexp} }
+      it { should be_kind_of(::Hash) }
+      its([:description]) { should be(description) }
+      its([:location]) { should == { value: location.inspect, type: :regexp } }
 
       it 'should have a header defined with value and type keys' do
-        expect( output[:headers] ).to have(2).keys
-        expect( output[:headers]['Header1'] ).to eq({value: 'Value1' ,type: :string })
-        expect( output[:headers]['Location'] ).to eq({value: "/\\/my\\/url\\//" ,type: :regexp })        
+        expect(output[:headers]).to have(2).keys
+        expect(output[:headers]['Header1']).to eq({ value: 'Value1', type: :string })
+        expect(output[:headers]['Location']).to eq({ value: '/\\/my\\/url\\//', type: :regexp })
       end
     end
 
     context 'for a definition with (homogeneous) parts' do
-      subject(:described_parts){ output[:parts_like] }
+      subject(:described_parts) { output[:parts_like] }
       context 'using :like' do
-        let(:parts) { {like: :ok, media_type: 'foobar'} }
+        let(:parts) { { like: :ok, media_type: 'foobar' } }
 
         it 'should contain a parts_like key with a hash' do
-          expect( output ).to have_key(:parts_like)
+          expect(output).to have_key(:parts_like)
         end
 
-        it{ should be_kind_of(::Hash) }
+        it { should be_kind_of(::Hash) }
         it 'has the right type info' do
           expect(subject[:payload][:type]).to match(id: 'Praxis-SimpleMediaType', name: 'Praxis::SimpleMediaType', family: 'string', identifier: 'foobar')
         end
-        its([:status]){ should == 200 }
+        its([:status]) { should == 200 }
       end
       context 'using a full response definition block' do
         let(:parts_block) do
-          Proc.new do
+          proc do
             status 234
             media_type 'custom_media'
           end
         end
 
         it 'should contain a parts_like key with a hash' do
-          expect( output ).to have_key(:parts_like)
+          expect(output).to have_key(:parts_like)
         end
 
-        it{ should be_kind_of(::Hash) }
+        it { should be_kind_of(::Hash) }
         it 'has the right type info' do
           expect(subject[:payload][:type]).to match(id: 'Praxis-SimpleMediaType', name: 'Praxis::SimpleMediaType', family: 'string', identifier: 'custom_media')
         end