praxis 0.11.2 → 0.13.0

data/spec/praxis/request_stage_spec.rb

@@ -1,93 +1,173 @@
 require 'spec_helper'
 
 describe Praxis::RequestStages::RequestStage do
-  # Ugly, but clear and easy to test the shortcuts
-  $before_controller_callback = Proc.new { nil }
-  $after_controller_callback = Proc.new { nil }
-  $before_show_controller_callback = Proc.new { Praxis::Responses::Unauthorized.new }
-
-  class MyController
-    include Praxis::Controller
-    before( :action , &$before_controller_callback) 
-    after( :action , &$after_controller_callback) 
-    before( actions: [:show], &$before_show_controller_callback) 
+
+  let(:controller_class) do
+    Class.new do
+      include Praxis::Controller
+    end
   end
-  class MyStage < Praxis::RequestStages::RequestStage
+
+  let(:stage_class) { Class.new(Praxis::RequestStages::RequestStage) }
+
+  let(:request) { instance_double("Praxis::Request") }
+  let(:controller){ controller_class.new(request) }
+
+
+  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(:before_callbacks) { double('before_callbacks') }
+  let(:after_callbacks) { double('after_callbacks') }
+  let(:controller_before_callbacks) { double('controller_before_callbacks') }
+  let(:controller_after_callbacks) { double('controller_after_callbacks') }
+
+  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
   end
-  
-  let(:controller){ MyController.new( double("request") ) }
-  let(:action_name) { :unknown }
-  let(:action){ double("action", name: action_name )}
-  let(:context){ double("context", controller: controller , action: action )}
-  subject(:stage) { MyStage.new(:action, context) }
-
-  context ".run" do
-    context 'for an abstract stage' do
-      subject(:stage) {Praxis::RequestStages::RequestStage.new(:action, context)}
-      it 'complains about having to implement execute' do
-        expect{stage.run}.to raise_error(NotImplementedError,/Subclass must implement Stage#execute/)
-      end
+
+  context 'for an abstract stage' do
+    subject(:stage) { Praxis::RequestStages::RequestStage.new(:action, context) }
+    it 'raises NotImplementedError for undefined #execute' do
+      expect {
+        stage.execute
+      }.to raise_error(NotImplementedError,/Subclass must implement Stage#execute/)
     end
-    
-    it "sets up and execute callbacks" do
-      expect(stage).to receive(:setup!)
-      expect(stage).to receive(:setup_deferred_callbacks!)
-      expect(stage).to receive(:execute)
-      expect(stage).to receive(:execute_callbacks).twice
-      expect(stage).to receive(:execute_controller_callbacks).twice
-      stage.run
+  end
+
+  context 'execute_controller_callbacks' do
+  end
+
+  context 'execute_with_around' do
+  end
+
+  context "#execute" do
+    before do
+      stage.stages.push(substage_1, substage_2, substage_3)
     end
-        
-    
-    context 'when before controller callbacks return a Response' do
-      let(:action_name) { :show }
-      
-      after do
-        stage.run
-      end
-      it 'only calls the before callbacks' do
-        expect(stage).to receive(:execute_callbacks).once.and_call_original
-        expect(stage).to receive(:execute_controller_callbacks).once.and_call_original
+
+    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
+        expect(stage.execute).to be(nil)
       end
-      it 'stops executing any other ones in the before chain' do
-        expect($before_controller_callback).to receive(:call).once
+    end
+
+    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)
       end
-      it 'does not call "execute"' do
-        expect(stage).to_not receive(:execute)
+
+      it "runs no further stages after that" do
+        expect(substage_3).to_not receive(:run)
+        stage.execute
       end
-      it 'does not execute any "after" callbacks either' do
-        expect($after_controller_callback).to_not receive(:call)
+
+      it 'assigns the response to controller.response' do
+        stage.execute
+
+        expect(controller.response).to be(response)
       end
+
     end
   end
 
-  context ".execute" do
-    let(:double_stage_ok){ double("ok stage") }
+  context "#run" do
 
-    context 'when all stages suceed' do
+    let(:before_callbacks) { double('before_callbacks') }
+    let(:after_callbacks) { double('after_callbacks') }
+
+    let(:controller_before_callbacks) { double('controller_before_callbacks') }
+    let(:controller_after_callbacks) { double('controller_after_callbacks') }
+
+    after do
+      stage.run
+    end
+
+    context 'callback execution' do
       before do
-        expect(double_stage_ok).to receive(:run).twice
-        stage.instance_variable_set(:@stages, [double_stage_ok, double_stage_ok])
-      end
-      
-      it "runs them all" do
-        stage.execute
+        allow(stage).to receive(:before_callbacks).once.and_return(before_callbacks)
+        allow(stage).to receive(:after_callbacks).once.and_return(after_callbacks)
+
+        allow(controller_class).to receive(:before_callbacks).once.and_return(controller_before_callbacks)
+        allow(controller_class).to receive(:after_callbacks).once.and_return(controller_after_callbacks)
       end
-      it 'returns nil' do
-        expect( stage.execute ).to be(nil)
+
+      it "sets up and executes callbacks" do
+        expect(stage).to receive(:setup!)
+        expect(stage).to receive(:setup_deferred_callbacks!)
+        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 one stage returns a Response' do
-      it "runs no further stages after that" do
-        double_stage_fail = double("fail stage")
-        expect(double_stage_ok).to receive(:run).once
-        expect(double_stage_fail).to receive(:run).once.and_return(Praxis::Responses::Ok.new)
-        stage.instance_variable_set(:@stages, [double_stage_ok, double_stage_fail, double_stage_ok])
-        stage.execute
+
+    context 'when the before execute_controller_callbacks return a Response' do
+      let(:action_name) { :show }
+      let(:response) { Praxis::Responses::Unauthorized.new }
+
+      before 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
+
+      it 'does not execute any "after" callbacks' 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)
+      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)
+        end
+
+        it 'runs no after callbacks (including from the controller) ' do
+          expect(stage).to_not receive(:after_callbacks)
+          expect(controller_class).to_not receive(:after_callbacks)
+        end
+
+        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
+        end
+
+      end
+    end
   end
 
 
+
 end

data/spec/praxis/resource_definition_spec.rb

@@ -12,8 +12,7 @@ describe Praxis::ResourceDefinition do
   its(:routing_config) { should be_kind_of(Proc) }
 
   its(:actions) { should have(2).items }
-
-
+  its(:metadata) { should_not have_key(:doc_visibility) }
 
   context '.describe' do
     subject(:describe) { resource_definition.describe }
@@ -22,6 +21,7 @@ describe Praxis::ResourceDefinition do
     its([:media_type]) { should eq(resource_definition.media_type.name) }
 
     its([:actions]) { should have(2).items }
+    its([:metadata]) { should be_kind_of(Hash) }
   end
 
   context '.action' do
@@ -97,4 +97,20 @@ describe Praxis::ResourceDefinition do
     end
 
   end
+
+  context 'with nodoc! called' do
+    before do
+      resource_definition.nodoc!      
+    end
+
+    it 'has the :doc_visibility option set' do
+      expect(resource_definition.metadata[:doc_visibility]).to be(:none)
+    end
+
+    it 'is exposed in the describe' do
+      expect(resource_definition.describe[:metadata][:doc_visibility]).to be(:none)
+    end
+
+  end
+
 end

data/spec/praxis/restful_routing_config_spec.rb

@@ -88,7 +88,7 @@ describe Praxis::Skeletor::RestfulRoutingConfig do
     let(:route_prefix) { nil }
 
     it 'call the add_route with the correct parameters' do
-      helper_verbs = [:get, :put, :post, :delete, :head, :options, :patch ]
+      helper_verbs = [:get, :put, :post, :delete, :head, :options, :patch, :any]
       helper_verbs.each do |verb|
         path = "/path_for_#{verb}"
         options = {option: verb}

data/spec/praxis/router_spec.rb

@@ -14,11 +14,11 @@ describe Praxis::Router do
         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(:request){ double("request", version: request_version, env: env ) }
       context 'with matching versions' do
         let(:request_version) { "1.0" }
@@ -42,13 +42,14 @@ describe Praxis::Router do
 
     end
   end
+
   describe Praxis::Router::RequestRouter do
 
     let(:request) {double("request", route_params: '', path: 'path')}
     let(:callback) {double("callback")}
-  
+
     subject(:request_router) {Praxis::Router::RequestRouter.new}
-    
+
     context ".invoke" do
       it "update request and call request for callback" do
         allow(request).to receive(:route_params=)
@@ -91,64 +92,141 @@ describe Praxis::Router do
       end
       router.add_route(target ,route)
     end
-    
+
     it "raises warning when options are specified in route" do
       expect(router.add_route(proc {'target'},route)).to eq(['path'])
     end
   end
 
   context ".call" do
-    let(:env){ {"PATH_INFO"=>"/"} }
+    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) }
     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(double("P"),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
-    
-    it "calls the route with params request" do
-      expect(router.call(request)).to eq(router_response)
+
+    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
+          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)
+          expect(response_code).to be(404)
+        end
+      end
     end
     
+    context 'for routes with wildcards (a POST and a * route)' do
+      before do
+        router.add_route(double("*"),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        
+      end
+      
+      context 'and an incoming PUT request' do
+        let(:request_verb) { 'PUT' }      
+        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
+          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 }
+        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
+          expect(router.call(request)).to eq(router_response_for_wildcard)
+        end
+      end
+    end
+
     context "when not_found is returned" do
+      let(:request_verb) { 'DELETE' }      
       let(:router_response){ :not_found }
-      before{ request.instance_variable_set(:@unmatched_versions, unmatched_versions) }
 
-      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", }, ["NotFound"]])
-          end
+
+      it 'sets X-Cascade: pass by default' do
+        _, headers, _ = router.call(request)
+        expect(headers).to have_key('X-Cascade')
+        expect(headers['X-Cascade']).to eq('pass')
+      end
+
+      context 'with X-Cascade disabled' do
+        let(:config) { Praxis::Application.instance.config.praxis } 
+        before do
+          expect(config).to receive(:x_cascade).and_return(false)
         end
-        
-        context 'and some controllers matching the path' do
-          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".')
-          end
+
+        it 'does not set X-Cascade: pass' do
+          _, headers, _ = router.call(request)
+          expect(headers).to_not have_key("X-Cascade")
         end
+
       end
-      
-      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"]) }          
-          
-          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)
-            expect(code).to eq(404)
-            expect(headers['Content-Type']).to eq('text/plain')
-            expect(body.first).to eq("NotFound. Your request speficied API version = \"#{request_version}\". Available versions = \"1.0\", \"2.0\".")
+
+      context 'with versioning' do
+        before do
+          request.instance_variable_set(:@unmatched_versions, unmatched_versions)
+        end
+
+        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"]])
+            end
+          end
+
+          context 'and some controllers matching the path' do
+            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".')
+            end
+          end
+        end
+
+        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"]) }
+
+            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)
+              expect(code).to eq(404)
+              expect(headers['Content-Type']).to eq('text/plain')
+              expect(body.first).to eq("NotFound. Your request speficied API version = \"#{request_version}\". Available versions = \"1.0\", \"2.0\".")
+            end
           end
         end
       end
+
+
     end
   end
 end

data/spec/spec_app/design/resources/instances.rb

@@ -130,7 +130,7 @@ module ApiResources
 
     action :terminate do
       routing do
-        post '/:id/terminate'
+        any '/:id/terminate'
       end
       
       requires_ability :terminate

data/spec/support/spec_media_types.rb

@@ -3,11 +3,13 @@ class Person < Praxis::MediaType
     attribute :id, Integer
     attribute :name, String, example: /[:name:]/
     attribute :href, String, example: proc { |person| "/people/#{person.id}" }
+    attribute :links, Praxis::Collection.of(String)
   end
 
   view :default do
     attribute :id
     attribute :name
+    attribute :links
   end
 
   view :link do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: praxis
 version: !ruby/object:Gem::Version
-  version: 0.11.2
+  version: 0.13.0
 platform: ruby
 authors:
 - Josep M. Blanquer
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-19 00:00:00.000000000 Z
+date: 2015-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -53,20 +53,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3'
-- !ruby/object:Gem::Dependency
-  name: ruport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1'
 - !ruby/object:Gem::Dependency
   name: mime
   requirement: !ruby/object:Gem::Requirement
@@ -87,42 +73,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.3'
 - !ruby/object:Gem::Dependency
   name: praxis-blueprints
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: attributor
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.4.0
+        version: 2.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.4.0
+        version: 2.5.0
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement