praxis 0.9 → 0.10.0

data/spec/praxis/media_type_collection_spec.rb

@@ -7,6 +7,18 @@ describe Praxis::MediaTypeCollection do
 
   let(:snapshots) { example.snapshots }
 
+  subject(:media_type_collection) do
+    Class.new(Praxis::MediaTypeCollection) do
+      member_type Volume
+    end
+  end
+   
+  context '.member_type' do
+    its(:member_type){ should be(Volume) }
+    its(:member_attribute){ should be_kind_of(Attributor::Attribute) }
+    its('member_attribute.type'){ should be(Volume) }
+  end
+  
   context '.load' do
     let(:volume_data) do
       {
@@ -66,13 +78,7 @@ describe Praxis::MediaTypeCollection do
 
   context '#render' do
 
-    context 'for views that are not defined on on the collection' do
-      subject(:output) { snapshots.render(:default) }
-
-      it { should eq(snapshots.collect(&:render)) }
-    end
-
-    context 'for defined views' do
+    context 'for standard views' do
       subject(:output) { snapshots.render(:link) }
 
       its([:name]) { should eq(snapshots.name)}
@@ -80,6 +86,13 @@ describe Praxis::MediaTypeCollection do
       its([:href]) { should eq(snapshots.href)}
     end
 
+    context 'for member views' do
+      subject(:output) { snapshots.render(:default) }
+
+      it { should eq(snapshots.collect(&:render)) }
+    end
+
+
   end
 
   context '#validate' do

data/spec/praxis/request_spec.rb

@@ -7,10 +7,11 @@ describe Praxis::Request do
     env['rack.input'] = rack_input
     env['CONTENT_TYPE'] = 'application/x-www-form-urlencoded'
     env['HTTP_VERSION'] = 'HTTP/1.1'
+    env['HTTP_AUTHORIZATION'] = 'Secret'
     env
   end
 
-  let(:action) { Instances.actions[:show] }
+  let(:action) { Instances.definition.actions[:show] }
 
   let(:context) do
     {
@@ -63,6 +64,19 @@ describe Praxis::Request do
 
   end
 
+  context '#load_headers' do
+
+    it 'is done preserving the original case' do
+      request.load_headers(context[:headers])
+      expect(request.headers).to match({"Authorization" => "Secret"})
+    end
+
+    it 'performs it using the memoized rack keys from the action (Hacky but...performance is important)' do
+      expect(action).to receive(:precomputed_header_keys_for_rack).and_call_original
+      request.load_headers(context[:headers])
+    end
+  end
+  
   context "performs request validation" do
     before(:each) do
       request.load_headers(context[:headers])

data/spec/praxis/request_stage_spec.rb

@@ -0,0 +1,93 @@
+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) 
+  end
+  class MyStage < Praxis::RequestStages::RequestStage
+  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
+    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 '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
+      end
+      it 'stops executing any other ones in the before chain' do
+        expect($before_controller_callback).to receive(:call).once
+      end
+      it 'does not call "execute"' do
+        expect(stage).to_not receive(:execute)
+      end
+      it 'does not execute any "after" callbacks either' do
+        expect($after_controller_callback).to_not receive(:call)
+      end
+    end
+  end
+
+  context ".execute" do
+    let(:double_stage_ok){ double("ok stage") }
+
+    context 'when all stages suceed' 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
+      end
+      it 'returns nil' do
+        expect( stage.execute ).to be(nil)
+      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
+      end
+    end
+
+  end
+
+
+end

data/spec/praxis/request_stages_action_spec.rb

@@ -0,0 +1,61 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Praxis::RequestStages::Action do
+
+  let(:controller) do
+    Class.new do
+      include Praxis::Controller
+    end.new(request)
+  end
+  
+  let(:action) { double("action", name: "foo") }  
+  let(:response){ Praxis::Responses::Ok.new }
+  let(:app){ double("App", controller: controller, action:action, request: request)}
+  let(:action_stage){ Praxis::RequestStages::Action.new(action.name,app) }  
+
+  let(:request) do
+    env = Rack::MockRequest.env_for('/instances/1?cloud_id=1&api_version=1.0')
+    env['rack.input'] = StringIO.new('something=given')
+    env['HTTP_VERSION'] = 'HTTP/1.1'
+    env['HTTP_HOST'] = 'rightscale'
+    request = Praxis::Request.new(env)
+    request.action = action
+    request
+  end
+
+
+  context '.execute' do
+    before do
+      expect(controller).to receive(action_stage.name).with(request.params_hash).and_return(controller_response)
+    end
+    let(:controller_response){ controller.response }
+    it 'should always call the right controller method' do
+      action_stage.execute
+    end
+    it 'should save the request reference inside the response' do
+      action_stage.execute
+      expect(controller.response.request).to eq(request)
+    end
+
+    context 'if the controller method returns a string' do
+      let(:controller_response){ "this is the body"}
+      it 'set the response body with it (and save the request too)' do
+        action_stage.execute
+        expect(controller.response.body).to eq("this is the body")
+      end
+    end
+    context 'if the controller method returns a response object' do
+      let(:controller_response){ Praxis::Responses::Created.new }
+      it 'set that response in the controller' do
+        action_stage.execute
+        expect(controller.response).to eq(controller_response)
+      end
+    end
+    context 'if the controller method returns neither a string or a response' do
+      let(:controller_response){ nil }
+      it 'an error is raised ' do
+        expect{ action_stage.execute }.to raise_error(/Only Response objects or Strings allowed/)
+      end
+    end
+  end
+end

data/spec/praxis/request_stages_validate_spec.rb

@@ -7,7 +7,7 @@ describe Praxis::RequestStages::Validate do
   # controller for the specs instead of creating a simple controller.
   let(:controller) { Instances }
 
-  let(:action) { controller.actions[:show] }
+  let(:action) { controller.definition.actions[:show] }
 
   let(:request) do
     env = Rack::MockRequest.env_for('/instances/1?cloud_id=1&api_version=1.0')

data/spec/praxis/responses/internal_server_error_spec.rb

@@ -0,0 +1,51 @@
+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
+      expect(response.name).to be(:internal_server_error)
+      expect(response.status).to be(500)
+      expect(response.body).to be_empty
+      expect(response.headers).to have_key('Content-Type')
+      expect(response.headers['Content-Type']).to eq('application/json')
+      expect(response.instance_variable_get(:@error)).to be(nil)
+    end
+  end
+
+  context '.format!' do
+    let(:error) { double('error', message: 'error message', backtrace: [1, 2], cause: cause) }
+    subject(:response) { Praxis::Responses::InternalServerError.new(error: error) }
+    before do
+      expect(response.body).to be_empty
+      response.format!
+    end
+
+    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})
+      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[:name]).to eq(error.class.name)
+        expect(response.body[:message]).to eq(error.message)
+        expect(response.body[:backtrace]).to eq(error.backtrace)
+        expect(response.body[:cause]).to eq({ name: cause.class.name, message: cause.message, backtrace: cause.backtrace })
+      end
+    end
+  end
+
+  context 'its response template' do
+    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
+  end
+end

data/spec/praxis/responses/validation_error_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+
+describe Praxis::Responses::ValidationError do
+  
+  context 'a basic response' do
+    subject(:response) { Praxis::Responses::ValidationError.new }
+    it 'always sets the json content type' do
+      expect(response.name).to be(:validation_error)
+      expect(response.status).to be(400)
+      expect(response.body).to be_empty
+      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)      
+    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) }
+    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})
+      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!
+      end
+      context 'without cause' do
+        let(:cause){ nil}
+        it 'it fills the message' do
+          expect(response.body).to eq({name: 'ValidationError', message: exception_message} )
+        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)
+          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
+      expect(template).to be_kind_of(Praxis::ResponseTemplate)
+    end
+  end
+end

data/spec/praxis/router_spec.rb

@@ -72,9 +72,14 @@ describe Praxis::Router do
   end
 
   context ".add_route" do
+    before do
+      expect(router).to receive(:warn).with("other conditions not supported yet")
+    end
+
     let(:route){ double('route', options: [1], version: 1, verb: 'verb', path: 'path')}
     let(:target){ double('target') }
     let(:verb_router){ double('verb_router') }
+
     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")
@@ -86,7 +91,6 @@ describe Praxis::Router do
     end
     
     it "raises warning when options are specified in route" do
-      expect(router).to receive(:warn).with("other conditions not supported yet")
       expect(router.add_route(proc {'target'},route)).to eq(['path'])
     end
   end

data/spec/spec_app/app/concerns/authenticated.rb

@@ -0,0 +1,15 @@
+module Concerns
+  module Authenticated
+    extend ActiveSupport::Concern
+    include Praxis::Callbacks
+    
+    included do
+      before :action do |controller|
+        auth_data = controller.request.headers['Authorization']
+        if auth_data && auth_data !~ /secret/ 
+          Praxis::Responses::Unauthorized.new(body: 'Authentication info is invalid')
+        end
+      end
+    end
+  end
+end

data/spec/spec_app/app/concerns/basic_api.rb

@@ -0,0 +1,12 @@
+require_relative 'authenticated'
+require_relative 'log_wrapper'
+
+module Concerns
+  module BasicApi
+    extend ActiveSupport::Concern
+
+    # Basic Api controllers will need the Authenticated and LogWrapper concerns
+    include Concerns::Authenticated
+    include Concerns::LogWrapper
+  end
+end

data/spec/spec_app/app/concerns/log_wrapper.rb

@@ -0,0 +1,14 @@
+module Concerns
+  module LogWrapper
+    extend ActiveSupport::Concern
+    include Praxis::Callbacks
+    
+    included do
+      before :around do |controller, callee|
+        # Log something at the beginning
+        callee.call
+        # Log something at the end
+      end
+    end
+  end
+end

data/spec/spec_app/app/controllers/base_class.rb

@@ -0,0 +1,14 @@
+class BaseClass
+  # Do NOT use a controller inherited base class to add concerns!
+  # If you do that, you'd be sharing state (i.e. overriding/adding) from  concerns across controllers
+  # which will probably lead to sharing issues you didn't expect.
+  # For example: any controller adding after/before/around filters will be visible
+  # to any other controllers sharing the concern.
+  # Include a concern to all of them instead 
+  
+  # Inheritance of classes should be independent from the concerns.
+  # I.e., you can use class inheritance in cases where it makes sense from an OO point of view
+  # but for the most part, you can probably share code through modules/concerns too.
+  def this_is_shared
+  end
+end

data/spec/spec_app/app/controllers/instances.rb

@@ -1,14 +1,39 @@
-class Instances
+class Instances < BaseClass
   include Praxis::Controller
 
   implements ApiResources::Instances
-
+  include Concerns::BasicApi
+  
   before :validate, actions: [:index]  do |controller|
     #p [:before, :validate, :params_and_headers, controller.request.action.name]
   end
 
-  before actions: [:show] do
+  before actions: [:show] do |controller|
     #puts "before action"
+    if controller.request.params.fail_filter
+      Praxis::Responses::Unauthorized.new
+    end
+  end
+
+  around :validate, actions: [:show] do |controller, blk|
+    #puts "Before validate decorator (for show)"
+    blk.call
+    #puts "After validate decorator"
+  end
+  around :action do |controller, blk|
+    #puts "Decorator one (all actions) start"
+    blk.call
+    #puts "Decorator one end"
+  end
+  around :action, actions: [:show] do |controller, blk|
+    #puts "Decorator two (show action) start"
+    blk.call
+    #puts "Decorator two end"
+  end
+  around :action, actions: [:index] do |controller, blk|
+    #puts "Decorator three (index action) start"
+    blk.call
+    #puts "Decorator three end"
   end
 
   def index(response_content_type:, **params)
@@ -31,7 +56,7 @@ class Instances
       headers = {
         'Status' => '201',
         'Content-Type' => Instance.identifier,
-        'Location' => self.class.action(:show).primary_route.path.expand(cloud_id: cloud_id, id: instance.id)
+        'Location' => self.class.definition.actions[:show].primary_route.path.expand(cloud_id: cloud_id, id: instance.id)
       }
 
       part = Praxis::MultipartPart.new(part_body, headers)
@@ -51,7 +76,8 @@ class Instances
 
     result = {
       destination_path: destination_path,
-      file: file.dump
+      file: file.dump,
+      options: request.payload['options'].dump
     }
 
     response.body = JSON.pretty_generate(result)

data/spec/spec_app/app/controllers/volumes.rb

@@ -0,0 +1,17 @@
+class Volumes < BaseClass
+  include Praxis::Controller
+
+  implements ApiResources::Volumes
+  include Concerns::BasicApi
+
+  before actions: [:show] do |controller|
+    #puts "before action for volumes"
+  end
+
+  def show(id:, **other_params)
+    response.body = { id: id, other_params: other_params }
+    response.headers['Content-Type'] = 'application/vnd.acme.volume'
+    response
+  end
+
+end

data/spec/spec_app/config/environment.rb

@@ -9,6 +9,7 @@ Praxis::Application.configure do |application|
       end
       map :app, 'app/' do
         map :models, 'models/**/*'
+        map :concerns, '**/concerns/**/*'
         map :controllers, '**/controllers/**/*'
         map :responses, '**/responses/**/*'
       end

data/spec/spec_app/design/api.rb

@@ -10,17 +10,17 @@ Praxis::ApiDefinition.define do
     media_type 'multipart/form-data'
   end
 
-  response_template :bulk_response do |media_type:, parts: |
+  response_template :bulk_response do |media_type: nil, parts: |
     status 200
     media_type 'multipart/form-data'
 
-    parts[:media_type] ||= media_type if parts.kind_of? Hash
+    parts[:media_type] ||= media_type if ( media_type && parts.kind_of?(Hash) )
     parts(parts)
   end
 
   trait :authenticated do
     headers do
-      header :host
+      key "Authorization", String, required: false
     end
   end
 

data/spec/spec_app/design/media_types/volume.rb

@@ -1,5 +1,5 @@
 class Volume < Praxis::MediaType
-  identifier 'application/json'
+  identifier 'application/vnd.acme.volume'
 
   attributes do
     attribute :id, Integer

data/spec/spec_app/design/media_types/volume_snapshot.rb

@@ -33,6 +33,7 @@ class VolumeSnapshot < Praxis::MediaType
       attribute :href
     end
 
+    member_view :default, using: :default
   end
 
 end

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

@@ -29,6 +29,11 @@ module ApiResources
       params do
         attribute :response_content_type, String, default: response_content_type
       end
+      headers do
+        # BOTH ARE EQUIVALENT
+        #key "FOO", String, required: true
+        header "FOO", /bar/
+      end
 
       response :ok, media_type: response_content_type
     end
@@ -45,6 +50,7 @@ module ApiResources
         attribute :id
         attribute :junk, String, default: ''
         attribute :some_date, DateTime, default: DateTime.parse('2012-12-21')
+        attribute :fail_filter, Attributor::Boolean, default: false
       end
       payload do
         attribute :something, String
@@ -64,7 +70,7 @@ module ApiResources
       response :bulk_response ,
                 parts: {
                   like: :created,
-                  media_type: Instance # Could be left blank and will inherit
+                  location: /\/instances\//
                 }
 
 # Using a block for parts to defin a sub-request
@@ -107,9 +113,10 @@ module ApiResources
         attribute :id
       end
 
-      payload Praxis::Multipart do
+      payload Praxis::Multipart, allow_extra: true do
         key 'destination_path', String, required: true
-        key 'file', Attributor::FileUpload, required: true
+        key 'file', Attributor::FileUpload, required: false
+        extra 'options'
       end
 
       response :ok, media_type: 'application/json'

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

@@ -0,0 +1,27 @@
+module ApiResources
+  class Volumes
+    include Praxis::ResourceDefinition
+
+    media_type Volume
+    version '1.0'
+
+    use :authenticated
+
+    action :show do
+      routing do
+        get '/:id'
+      end
+
+      response :ok
+
+      params do
+        attribute :id
+        attribute :junk, String, default: ''
+        attribute :some_date, DateTime, default: DateTime.parse('2012-12-21')
+      end
+      
+    end
+
+  end
+
+end

data/spec/support/spec_resource_definitions.rb

@@ -31,3 +31,35 @@ class PeopleResource
   end
 
 end
+
+class AddressResource
+  include Praxis::ResourceDefinition
+
+  description 'Address resource'
+
+  media_type Address
+
+  version '1.0'
+
+  routing do
+    prefix "/addresses"
+  end
+
+  action :index do
+    description 'index description'
+    routing do
+      get ''
+    end
+  end
+
+  action :show do
+    description 'show description'
+    routing do
+      get '/:id'
+    end
+    params do
+      attribute :id, Integer, required: true
+    end
+  end
+
+end