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

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

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,29 @@ describe Praxis::Response do
       end
 
       it 'should raise an error' do
-        expect {
-          response.validate(action)
-        }.to raise_error(Praxis::Exceptions::Validation, /response definition with that name can be found/)
+        resp = nil
+        expect do
+          resp = response.validate(action)
+        end.to_not raise_error
+
+        expect(resp.status).to eq(500)
+        expect(resp.body[:name]).to eq('ValidationError')
+        expect(resp.body[:summary]).to eq('Error validating response')
+        expect(resp.body[:errors]).to include(/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 +100,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 +141,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 +171,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 +179,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 +188,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