praxis 0.16.1 → 0.17.0

data/spec/praxis/plugins/praxis_mapper_plugin_spec.rb

@@ -56,7 +56,7 @@ describe Praxis::Plugins::PraxisMapperPlugin do
         with(kind_of(Praxis::Request),kind_of(Praxis::Mapper::IdentityMap), 'detailed').
         and_call_original
       the_body = StringIO.new("{}") # This is a funny, GET request expecting a body
-      get '/clouds/1/instances/2?junk=foo&api_version=1.0', nil, 'rack.input' => the_body,'CONTENT_TYPE' => "application/json", 'global_session' => session
+      get '/api/clouds/1/instances/2?junk=foo&api_version=1.0', nil, 'rack.input' => the_body,'CONTENT_TYPE' => "application/json", 'global_session' => session
 
       expect(last_response.status).to eq(200)
     end

data/spec/praxis/request_spec.rb

@@ -1,10 +1,11 @@
 require 'spec_helper'
 
 describe Praxis::Request do
+  let(:path) { '/instances/1?junk=foo&api_version=1.0' } 
   let(:rack_input) { StringIO.new('something=given') }
   let(:env_content_type){ 'application/x-www-form-urlencoded' }
   let(:env) do
-    env = Rack::MockRequest.env_for('/instances/1?junk=foo&api_version=1.0')
+    env = Rack::MockRequest.env_for(path)
     env['rack.input'] = rack_input
     env['CONTENT_TYPE'] = env_content_type
     env['HTTP_VERSION'] = 'HTTP/1.1'
@@ -32,49 +33,76 @@ describe Praxis::Request do
   its(:path) { should eq('/instances/1') }
   its(:raw_params) { should eq({'junk' => 'foo'}) }
   its(:version) { should eq('1.0') }
-  
+
   context 'path versioning' do
-    its('class.path_version_prefix'){ should eq("/v") }
-    its(:path_version_matcher){ should be_kind_of(Regexp) }
-    it 'uses a "/v*" default matcher with a "version" named capture' do
-      match = subject.path_version_matcher.match("/v5.5/something")
-      expect(match).to_not be(nil)
-      expect(match['version']).to eq("5.5")
+    before do
+      allow(
+        Praxis::Application.instance
+      ).to receive(:versioning_scheme).and_return(:path)
+      allow(
+        Praxis::ApiDefinition.instance.info
+      ).to receive(:base_path).and_return('/api/v:api_version')
+
     end
+
+    let(:path) { '/api/v2.0/instances/1' }
+
+
+    its(:version) { should eq '2.0' }
+    #its('class.path_version_prefix'){ should eq("/v") }
+    #its(:path_version_matcher){ should be_kind_of(Regexp) }
+    #it 'uses a "/v*" default matcher with a "version" named capture' do
+    #  match = subject.path_version_matcher.match("/v5.5/something")
+    #  expect(match).to_not be(nil)
+    #  expect(match['version']).to eq("5.5")
+    #end
   end
-  
+
   context 'loading api version' do
-    let(:request) { Praxis::Request.new(env) }
-    subject(:version){ request.version( version_options ) }
+    #let(:request) { Praxis::Request.new(env) }
+    subject(:version){ request.version }
+    let(:versioning_scheme){ Praxis::Request::VERSION_USING_DEFAULTS }
+    before do
+      allow(
+        Praxis::Application.instance
+      ).to receive(:versioning_scheme).and_return(versioning_scheme)
+    end
+
     context 'using X-Api-Header' do
       let(:env){ {'HTTP_X_API_VERSION' => "5.0", "PATH_INFO" => "/something"} }
-      let(:version_options){ {using: :header} }
+      let(:versioning_scheme){ :header }
       it { should eq('5.0') }
     end
     context 'using query param' do
       let(:env) { Rack::MockRequest.env_for('/instances/1?junk=foo&api_version=5.0') }
-      let(:version_options){ {using: :params} }
+      let(:versioning_scheme){ :params }
       it { should eq('5.0') }
     end
     context 'using path (with the default pattern matcher)' do
       let(:env){ Rack::MockRequest.env_for('/v5.0/instances/1?junk=foo') }
-      let(:version_options){ {using: :path} }
-      it { should eq('5.0') }  
+      let(:versioning_scheme){ :path }
+
+      before do
+        allow(
+          Praxis::ApiDefinition.instance.info
+        ).to receive(:base_path).and_return('/v:api_version')
+      end
+      it { should eq('5.0') }
     end
-    
+
     context 'using a method that it is not allowed in the definition' do
       context 'allowing query param but passing it through a header' do
         let(:env){ {'HTTP_X_API_VERSION' => "5.0", "PATH_INFO" => "/something"} }
-        let(:version_options){ {using: :params} }
+        let(:versioning_scheme){ :params }
         it { should eq('n/a') }
       end
       context 'allowing header but passing it through param' do
         let(:env) { Rack::MockRequest.env_for('/instances/1?junk=foo&api_version=5.0') }
-        let(:version_options){ {using: :header} }
+        let(:versioning_scheme){ :header }
         it { should eq('n/a') }
       end
     end
-    
+
     context 'using defaults' do
       subject(:version){ request.version }
       context 'would succeed if passed through the header' do
@@ -98,8 +126,8 @@ describe Praxis::Request do
       form_data
     end
 
-    let(:rack_input) { 
-      StringIO.new(form.body.to_s) 
+    let(:rack_input) {
+      StringIO.new(form.body.to_s)
     }
 
     let(:env) do
@@ -124,7 +152,7 @@ describe Praxis::Request do
 
     it 'is done preserving the original case' do
       request.load_headers(context[:headers])
-      expect(request.headers).to match({"Authorization" => "Secret"})
+      expect(request.headers).to eq({"Authorization" => "Secret"})
     end
 
     it 'performs it using the memoized rack keys from the action (Hacky but...performance is important)' do
@@ -132,7 +160,7 @@ describe Praxis::Request do
       request.load_headers(context[:headers])
     end
   end
-  
+
   context "performs request validation" do
     before(:each) do
       request.load_headers(context[:headers])
@@ -175,7 +203,7 @@ describe Praxis::Request do
         expect(request.validate_payload(context[:payload])).to eq(['some_error'])
       end
     end
-  
+
     context '#load_payload' do
       let(:load_context){ context[:payload] }
       let(:parsed_result){ double("parsed") }

data/spec/praxis/{request_stages_action_spec.rb → request_stages/action_spec.rb}

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'spec_helper'
 
 describe Praxis::RequestStages::Action do
 

data/spec/praxis/{request_stages_validate_spec.rb → request_stages/validate_spec.rb}

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'spec_helper'
 
 describe Praxis::RequestStages::Validate do
   let(:dispatcher) { Praxis::Dispatcher.new }

data/spec/praxis/resource_definition_spec.rb

@@ -7,7 +7,6 @@ describe Praxis::ResourceDefinition do
   its(:media_type) { should eq(Person) }
 
   its(:version) { should eq('1.0') }
-  its(:version_options) { should eq({using: [:header,:params]}) }
 
   its(:prefix) { should eq('/people') }
 
@@ -23,8 +22,34 @@ describe Praxis::ResourceDefinition do
     its([:actions]) { should have(2).items }
     its([:metadata]) { should be_kind_of(Hash) }
     its([:traits]) { should eq [:test] }
+    it { should_not have_key(:parent)}
+
+    context 'for a resource with a parent' do
+      let(:resource_definition) { ApiResources::VolumeSnapshots}
+      
+      its([:parent]) { should eq ApiResources::Volumes.id }
+    end
+
+  end
+
+
+  context '.routing_prefix' do
+    subject(:resource_definition) { ApiResources::VolumeSnapshots }
+    it do
+      expect(resource_definition.routing_prefix).to eq('/clouds/:cloud_id/volumes/:volume_id/snapshots')
+    end
   end
 
+  context '.parent_prefix' do
+    subject(:resource_definition) { ApiResources::VolumeSnapshots }
+    let(:base_path){ Praxis::ApiDefinition.instance.info.base_path }
+    its(:parent_prefix){ should eq('/clouds/:cloud_id/volumes/:volume_id') }
+    it do
+      expect(resource_definition.parent_prefix).to_not match(/^#{base_path}/)
+    end
+  end
+
+
   context '.action' do
     it 'requires a block' do
       expect { resource_definition.action(:something)
@@ -79,11 +104,11 @@ describe Praxis::ResourceDefinition do
     it 'are applied to actions' do
       action = resource_definition.actions[:show]
       expect(action.params.attributes).to have_key(:id)
-      expect(action.routes.first.path.to_s).to eq '/people/:id'
+      expect(action.routes.first.path.to_s).to eq '/api/people/:id'
     end
 
   end
-  
+
   context 'setting other values' do
     subject(:resource_definition) { Class.new {include Praxis::ResourceDefinition } }
 
@@ -118,7 +143,7 @@ describe Praxis::ResourceDefinition do
         def self.name
           'FooBar'
         end
-        
+
         silence_warnings do
           payload { attribute :inherited_payload, String }
           headers { key "Inherited-Header", String }
@@ -209,4 +234,5 @@ describe Praxis::ResourceDefinition do
       expect(parsed[:id]).to be_kind_of(Integer)
     end
   end
+
 end

data/spec/praxis/response_definition_spec.rb

@@ -49,6 +49,46 @@ describe Praxis::ResponseDefinition do
     end
   end
 
+  context '#example' do
+    let(:media_type) { nil }
+
+    before do
+      response_definition.media_type media_type
+    end
+
+    context 'with media_type unset' do
+      its(:example) { should be nil }
+      it 'is not in the describe output' do
+        expect(response_definition.describe).to_not have_key(:example)
+      end
+    end
+
+    context 'with media_type set to a string' do
+      let(:media_type) { 'application/json' }
+      its(:example) { should be nil }
+      it 'is not in the describe output' do
+        expect(response_definition.describe).to_not have_key(:example)
+      end
+    end
+
+    # TODO: Complete/correct the "example" generation when it is done in the ResponseDefinition class
+    #context 'with media_type set to a MediaType' do
+    #  let(:media_type) { Person }
+    #
+    #  let(:expected_context) { "Person-#{name}" }
+    #  let!(:example) { Person.example(expected_context) }
+    #
+    #  before do
+    #    expect(Person).to receive(:example).with(expected_context).and_call_original
+    #  end
+    #
+    #  its(:example) { should be_kind_of(Person) }
+    #  it 'is rendered in the describe output' do
+    #    expect(response_definition.describe[:example]).to eq(example.render)
+    #  end
+    #end
+  end
+
   context '#location' do
     it 'accepts a String' do
       response_definition.location "string_location"
@@ -405,33 +445,34 @@ describe Praxis::ResponseDefinition do
       end
 
       describe '#validate_parts!' do
-        subject(:response) { BulkResponse.new(status: response_status, headers: response_headers) }
-
-        let(:part) { Praxis::MultipartPart.new('done', {'Status' => 200, 'Content-Type' => 'application/special'}) }
+        context 'with legacy multipart response' do
+          subject(:response) { Praxis::Responses::Ok.new(status: response_status, headers: response_headers) }
 
-        before do
-          response_definition.parts like: :ok, media_type: 'application/special'
-          response.add_part(part)
-        end
-
-        it 'validates each part' do
-          response_definition.parts
-          expect {
-            response_definition.validate_parts!(response)
-          }.to_not raise_error
-        end
+          let(:part) { Praxis::MultipartPart.new('done', {'Status' => 200, 'Content-Type' => 'application/special'}) }
 
-        context 'with invalid part' do
-          let(:part) { Praxis::MultipartPart.new('done', {'Status' => 200, "Location" => "somewhere"}) }
+          before do
+            response_definition.parts like: :ok, media_type: 'application/special'
+            response.add_part(part)
+          end
 
-          it 'validates' do
+          it 'validates each part' do
+            response_definition.parts
             expect {
               response_definition.validate_parts!(response)
-            }.to raise_error(Praxis::Exceptions::Validation)
+            }.to_not raise_error
           end
 
-        end
+          context 'with invalid part' do
+            let(:part) { Praxis::MultipartPart.new('done', {'Status' => 200, "Location" => "somewhere"}) }
 
+            it 'validates' do
+              expect {
+                response_definition.validate_parts!(response)
+              }.to raise_error(Praxis::Exceptions::Validation)
+            end
+
+          end
+        end
       end
     end
 

data/spec/praxis/response_spec.rb

@@ -62,7 +62,7 @@ describe Praxis::Response do
       it 'should raise an error' do
         expect {
           response.validate(action)
-        }.to raise_error(ArgumentError, /response definition with that name can be found/)
+        }.to raise_error(Praxis::Exceptions::Validation, /response definition with that name can be found/)
       end
     end
 
@@ -183,7 +183,7 @@ describe Praxis::Response do
         expect(preamble).to eq("a preamble")
         expect(parts).to have(1).item
 
-        _part_name, part_response = parts.first
+        part_response = parts.first
         expect(part_response.headers['Status']).to eq(part.headers['Status'].to_s)
         expect(part_response.headers['Location']).to eq(part.headers['Location'])
         expect(part_response.body).to eq('not so ok')

data/spec/praxis/responses/validation_error_spec.rb

@@ -2,9 +2,10 @@ require 'spec_helper'
 
 
 describe Praxis::Responses::ValidationError do
-  
+
+  let(:summary){ "Something happened here" }
   context 'a basic response' do
-    subject(:response) { Praxis::Responses::ValidationError.new }
+    subject(:response) { Praxis::Responses::ValidationError.new(summary: summary) }
     it 'always sets the json content type' do
       expect(response.name).to be(:validation_error)
       expect(response.status).to be(400)
@@ -12,51 +13,67 @@ describe Praxis::Responses::ValidationError do
       expect(response.headers).to have_key('Content-Type')
       expect(response.headers['Content-Type']).to eq('application/json')
       expect(response.instance_variable_get(:@errors)).to be(nil)
-      expect(response.instance_variable_get(:@exception)).to be(nil)      
+      expect(response.instance_variable_get(:@exception)).to be(nil)
     end
   end
-  
+
   context '.format!' do
     let(:errors) { [1,2] }
     let(:cause){ Exception.new( "cause message") }
     let(:exception_message){ "exception message" }
     let(:exception){ nil }
-    subject(:response) { Praxis::Responses::ValidationError.new(errors: errors, exception: exception) }
+    subject(:response) { Praxis::Responses::ValidationError.new(summary: summary, errors: errors, exception: exception) }
     before do
       expect(response.body).to be_empty
     end
     context 'when errors' do
       it 'it fills the errors key' do
         response.format!
-        expect(response.body).to eq({name: 'ValidationError', 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)}
       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)
       end
+
+      context 'that has a message' do
+        it 'fills the errors array with the exception message' do
+          expect(response.body).to have_key(:errors)
+          expect(response.body[:errors]).to eq([exception.message])
+        end
+      end
+
+      context 'that does not contain a message' do
+        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}
-        it 'it fills the message' do
-          expect(response.body).to eq({name: 'ValidationError', message: exception_message} )
+        it 'does not include it in the output' do
+          expect(response.body).to_not have_key(:cause)
         end
       end
-  
+
       context 'with a cause' do
-        it 'it fills the message' do
-          expect(response.body.keys).to eq([:name,:message,:cause])
-          expect(response.body[:name]).to eq('ValidationError')
-          expect(response.body[:message]).to eq(exception_message)
+        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 })
         end
       end
     end
-    
+
   end
-  
+
   context 'its response template' do
     let(:template){ Praxis::ApiDefinition.instance.responses[:validation_error] }
     it 'is registered with the ApiDefinition' do