praxis 0.10.1 → 0.11pre

data/lib/praxis/version.rb

@@ -1,3 +1,3 @@
 module Praxis
-  VERSION = '0.10.1'
+  VERSION = '0.11pre'
 end

data/praxis.gemspec

@@ -28,8 +28,10 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'mime', '~> 0'
   spec.add_dependency 'praxis-mapper', '~> 3.1'
   spec.add_dependency 'praxis-blueprints', '~> 1.1'
-  spec.add_dependency 'attributor', '~> 2.2'
+  spec.add_dependency 'attributor', '~> 2.3.0'
   spec.add_dependency 'thor', '~> 0'
+  spec.add_dependency 'terminal-table', '~> 1.4'
+  spec.add_dependency 'harness', '~> 2'
 
   spec.add_development_dependency 'bundler', '~> 1.6'
   spec.add_development_dependency 'rake', '~> 0.9'
@@ -47,4 +49,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'simplecov', '~> 0'
   spec.add_development_dependency 'fuubar', '~> 2'
   spec.add_development_dependency 'yard', '~> 0'
+  spec.add_development_dependency 'sqlite3', '~> 1'
 end

data/spec/functional_spec.rb

@@ -1,17 +1,32 @@
 require 'spec_helper'
 
-describe 'Functional specs' , focus: true do
+describe 'Functional specs' do
 
   def app
     Praxis::Application.instance
   end
 
+  let(:session) { double("session", valid?: true)}
+
   context 'index' do
+
     context 'with an incorrect response_content_type param' do
+      around do |example|
+        logger = app.logger
+        app.logger = Logger.new(StringIO.new)
+
+        example.call
+
+        app.logger = logger
+      end
+
       it 'fails to validate the response' do
-        get '/clouds/1/instances?response_content_type=somejunk&api_version=1.0', nil, 'HTTP_FOO' => "bar"
+        get '/clouds/1/instances?response_content_type=somejunk&api_version=1.0', nil, 'HTTP_FOO' => "bar", 'global_session' => session
+        expect(last_response.status).to eq(400)
         response = JSON.parse(last_response.body)
-        expect(response['name']).to eq('Praxis::Exceptions::Validation')
+
+        expect(response['name']).to eq('ValidationError')
+
         expect(response["message"]).to match(/Bad Content-Type/)
       end
 
@@ -22,10 +37,10 @@ describe 'Functional specs' , focus: true do
         before do
           expect(Praxis::Application.instance.config).to receive(:praxis).and_return(praxis_config)
         end
-        
+
         it 'fails to validate the response' do
           expect {
-            get '/clouds/1/instances?response_content_type=somejunk&api_version=1.0'
+            get '/clouds/1/instances?response_content_type=somejunk&api_version=1.0',nil,  'global_session' => session
           }.to_not raise_error
         end
 
@@ -35,18 +50,20 @@ describe 'Functional specs' , focus: true do
   end
 
   it 'works' do
-    get '/clouds/1/instances/2?junk=foo&api_version=1.0'
+    get '/clouds/1/instances/2?junk=foo&api_version=1.0', nil, 'global_session' => session
     expect(last_response.status).to eq(200)
-    expect(JSON.parse(last_response.body)).to eq({"cloud_id" => 1, "id"=>2, "junk"=>"foo", 
+    expect(JSON.parse(last_response.body)).to eq({"cloud_id" => 1, "id"=>2, "junk"=>"foo",
                                                   "other_params"=>{
                                                     "some_date"=>"2012-12-21T00:00:00+00:00",
-                                                    "fail_filter"=>nil}, 
+                                                  "fail_filter"=>false},
                                                   "payload"=>{"something"=>nil, "optional"=>"not given"}})
-    expect(last_response.headers).to eq({"Content-Type"=>"application/vnd.acme.instance", "Content-Length"=>"213"})
-  end
+    expect(last_response.headers).
+      to eq({"Content-Type"=>"application/vnd.acme.instance",
+             "Content-Length"=>"214", 'Spec-Middleware' => 'used'})
+      end
 
   it 'returns early when making the before filter break' do
-    get '/clouds/1/instances/2?junk=foo&api_version=1.0&fail_filter=true'
+    get '/clouds/1/instances/2?junk=foo&api_version=1.0&fail_filter=true', nil, 'global_session' => session
     expect(last_response.status).to eq(401)
   end
 
@@ -66,7 +83,7 @@ describe 'Functional specs' , focus: true do
     let(:body) { form.body.to_s }
 
     it 'works' do
-      post '/clouds/1/instances?api_version=1.0', body, 'CONTENT_TYPE' => content_type
+      post '/clouds/1/instances?api_version=1.0', body, 'CONTENT_TYPE' => content_type, 'global_session' => session
 
       _reponse_preamble, response = Praxis::MultipartParser.parse(last_response.headers, last_response.body)
       expect(response).to have(1).item
@@ -103,7 +120,7 @@ describe 'Functional specs' , focus: true do
 
     context 'with a valid payload' do
       before do
-        post '/clouds/1/instances/2/files?api_version=1.0', body, 'CONTENT_TYPE' => content_type
+        post '/clouds/1/instances/2/files?api_version=1.0', body, 'CONTENT_TYPE' => content_type, 'global_session' => session
       end
 
       subject(:response) { JSON.parse(last_response.body) }
@@ -131,9 +148,9 @@ describe 'Functional specs' , focus: true do
       end
 
       let(:body) { form.body.to_s }
-      
+
       it 'returns an error' do
-        post '/clouds/1/instances/2/files?api_version=1.0', body, 'CONTENT_TYPE' => content_type
+        post '/clouds/1/instances/2/files?api_version=1.0', body, 'CONTENT_TYPE' => content_type, 'global_session' => session
         response = JSON.parse(last_response.body)
 
         expect(response['name']).to eq('ValidationError')
@@ -141,7 +158,7 @@ describe 'Functional specs' , focus: true do
       end
 
     end
-    
+
     context 'with an extra key in the form' do
       let(:form) do
         form_data = MIME::Multipart::FormData.new
@@ -161,29 +178,32 @@ describe 'Functional specs' , focus: true do
 
       let(:body) { form.body.to_s }
       subject(:response) { JSON.parse(last_response.body) }
-      
+
       before do
-        post '/clouds/1/instances/2/files?api_version=1.0', body, 'CONTENT_TYPE' => content_type
+        post '/clouds/1/instances/2/files?api_version=1.0', body, 'CONTENT_TYPE' => content_type, 'global_session' => session
       end
       its(:keys){ should eq(['destination_path','file','options'])}
       its(['options']){ should eq({"extra_thing"=>"I am extra"})}
     end
 
+
+
+
   end
 
 
   context 'not found and API versions' do
     context 'when no version is speficied' do
       it 'it tells you which available api versions would match' do
-        get '/clouds/1/instances/2?junk=foo'
-        
+        get '/clouds/1/instances/2?junk=foo',nil, 'global_session' => session
+
         expect(last_response.status).to eq(404)
         expect(last_response.headers["Content-Type"]).to eq("text/plain")
         expect(last_response.body).to eq("NotFound. Your request did not specify an API version. Available versions = \"1.0\".")
       end
       it 'it just gives you a simple not found when nothing would have matched' do
-        get '/foobar?junk=foo'
-        
+        get '/foobar?junk=foo', nil, 'global_session' => session
+
         expect(last_response.status).to eq(404)
         expect(last_response.headers["Content-Type"]).to eq("text/plain")
         expect(last_response.body).to eq("NotFound")
@@ -192,40 +212,75 @@ describe 'Functional specs' , focus: true do
 
     context 'when some version is speficied, but wrong' do
       it 'it tells you which possible correcte api versions exist' do
-        get '/clouds/1/instances/2?junk=foo&api_version=50.0'
-        
+        get '/clouds/1/instances/2?junk=foo&api_version=50.0', nil, 'global_session' => session
+
         expect(last_response.status).to eq(404)
         expect(last_response.headers["Content-Type"]).to eq("text/plain")
         expect(last_response.body).to eq("NotFound. Your request speficied API version = \"50.0\". Available versions = \"1.0\".")
       end
     end
-    
+
   end
 
   context 'volumes' do
     context 'when no authorization header is passed' do
       it 'works as expected' do
-        get '/volumes/123?api_version=1.0&junk=stuff'#, nil, 'AUTHORIZATION' => 'foobar'
+        get '/v1.0/volumes/123?junk=stuff', nil, 'global_session' => session
         expect(last_response.status).to eq(200)
         expect(JSON.parse(last_response.body)).to eq({"id"=>123,
                                                       "other_params"=>{
                                                         "junk"=>"stuff",
-                                                        "some_date"=>"2012-12-21T00:00:00+00:00"}
-                                                     })
+                                                      "some_date"=>"2012-12-21T00:00:00+00:00"}
+                                                      })
         expect(last_response.headers["Content-Type"]).to eq("application/vnd.acme.volume")
-      end      
+      end
     end
     context 'when an authorization header is passed' do
       it 'returns 401 when it does not match "secret" ' do
-        get '/volumes/123?api_version=1.0&junk=stuff', nil, 'HTTP_AUTHORIZATION' => 'foobar'
+        get '/v1.0/volumes/123?junk=stuff', nil, 'HTTP_AUTHORIZATION' => 'foobar', 'global_session' => session
         expect(last_response.status).to eq(401)
         expect(last_response.body).to match(/Authentication info is invalid/)
       end
       it 'succeeds as expected when it matches "secret" ' do
-        get '/volumes/123?api_version=1.0&junk=stuff', nil, 'HTTP_AUTHORIZATION' => 'the secret'
+        get '/v1.0/volumes/123?junk=stuff', nil, 'HTTP_AUTHORIZATION' => 'the secret', 'global_session' => session
+        expect(last_response.status).to eq(200)
+      end
+
+    end
+
+    context 'index action with no args defined' do
+      it 'dispatches successfully' do
+        get '/v1.0/volumes', nil, 'HTTP_AUTHORIZATION' => 'the secret', 'global_session' => session
         expect(last_response.status).to eq(200)
       end
-      
     end
   end
+
+  context 'auth_plugin' do
+    it 'can terminate' do
+      post '/clouds/23/instances/1/terminate?api_version=1.0', nil, 'global_session' => session
+      expect(last_response.status).to eq(200)
+    end
+
+    it 'can not stop' do
+      post '/clouds/23/instances/1/stop?api_version=1.0', nil, 'global_session' => session
+      expect(last_response.status).to eq(403)
+    end
+  end
+
+  context 'with mismatch between Content-Type and payload' do
+    let(:body) { '{}' }
+    let(:content_type) { 'application/x-www-form-urlencoded' }
+
+    before do
+      post '/clouds/1/instances/2/terminate?api_version=1.0', body, 'CONTENT_TYPE' => content_type, 'global_session' => session
+    end
+
+    it 'returns a useful error message' do
+      body = JSON.parse(last_response.body)
+      expect(body['name']).to eq('ValidationError')
+      expect(body['message']).to match("For request Content-Type: 'application/x-www-form-urlencoded'")
+    end
+  end
+
 end

data/spec/praxis/action_definition_spec.rb

@@ -12,14 +12,16 @@ describe Praxis::ActionDefinition do
       media_type 'application/json'
       version '1.0'
       routing { prefix '/api/hello_world' }
-      payload { attribute :inherited, String }
-      headers { header "Inherited", String }
-      params  { attribute :inherited, String }
+      action_defaults do
+        payload { attribute :inherited, String }
+        headers { header "Inherited", String }
+        params  { attribute :inherited, String }
+      end
     end
   end
 
   subject(:action) do
-    described_class.new('foo', resource_definition) do
+    Praxis::ActionDefinition.new('foo', resource_definition) do
       routing { get '/:one' }
       payload { attribute :two, String }
       headers { header "X_REQUESTED_WITH", 'XMLHttpRequest' }
@@ -44,7 +46,7 @@ describe Praxis::ActionDefinition do
       action.response :ok
       action.response :internal_server_error
     end
-    
+
     it { should be_kind_of Hash }
     it { should include :ok }
     it { should include :internal_server_error }
@@ -64,9 +66,8 @@ describe Praxis::ActionDefinition do
         attribute :more, Attributor::Integer
       end
 
-      expect(subject.params.attributes.keys).to match_array([
-        :one, :inherited, :more
-      ])
+      attributes = subject.params.attributes.keys
+      expect(attributes).to match_array([:one, :inherited, :more])
     end
   end
 
@@ -77,18 +78,18 @@ describe Praxis::ActionDefinition do
       end
 
       expect(subject.payload.attributes.keys).to match_array([
-        :two, :inherited, :more
+                                                               :two, :inherited, :more
       ])
     end
   end
 
   describe '#headers' do
-    it 'is backed by a Hash' do 
+    it 'is backed by a Hash' do
       expect(subject.headers.type < Attributor::Hash).to be(true)
     end
 
     it 'is has case_sensitive_load enabled' do
-      expect(subject.headers.type.options[:case_insensitive_load]).to be(true) 
+      expect(subject.headers.type.options[:case_insensitive_load]).to be(true)
     end
 
     it 'merges in more headers' do
@@ -97,7 +98,7 @@ describe Praxis::ActionDefinition do
       end
 
       expect(subject.headers.attributes.keys).to match_array([
-        "X_REQUESTED_WITH", "Inherited", "more"
+                                                               "X_REQUESTED_WITH", "Inherited", "more"
       ])
     end
   end

data/spec/praxis/bootloader_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Praxis::Bootloader do
   let(:application) do
-    instance_double("Praxis::Application", config: "config", root: "root", plugins: [])
+    instance_double("Praxis::Application", config: "config", root: "root", plugins: {})
   end
 
   subject(:bootloader) {Praxis::Bootloader.new(application)}
@@ -10,7 +10,7 @@ describe Praxis::Bootloader do
   context 'attributes' do
     its(:application) {should be(application)}
     it 'stages' do
-      init_stages = [:environment, :initializers, :lib, :design, :app, :routing, :warn_unloaded_files]
+      init_stages = [:environment, :plugins, :initializers, :lib, :design, :app, :routing, :warn_unloaded_files]
       expect(bootloader.stages.map {|s| s.name}).to eq(init_stages)
     end
     its(:config) {should be(application.config)}
@@ -49,10 +49,17 @@ describe Praxis::Bootloader do
   end
 
   context ".use" do
+    let(:plugin) do
+      Class.new(Praxis::Plugin) do
+        def config_key
+          :foo
+        end
+      end
+    end
+
     it "plugin add to application" do
-      bootloader.use(Praxis::Plugin)
-      new_plugin = Praxis::Plugin.new(bootloader.application)
-      expect(bootloader.application.plugins.last.class).to be(Praxis::Plugin)
+      bootloader.use(plugin)
+      expect(bootloader.application.plugins[:foo].class).to be(plugin)
     end
   end
 end

data/spec/praxis/notifications_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Praxis::Notifications do
+
+  let(:events) { [] }
+
+  before do
+    Praxis::Notifications.subscribe('render') do |name, start, finish, id, payload|
+      events << payload
+    end
+
+    Praxis::Notifications.instrument('render', extra: :information) do
+    end
+
+    Praxis::Notifications.instrument('render', extra: :single)
+  end
+
+  it 'works' do
+    expect(events).to have(2).items
+    expect(events).to match [{extra: :information}, {extra: :single}]
+  end
+
+end

data/spec/praxis/plugin_concern_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Praxis::PluginConcern do
+
+  it 'works' do
+    expect(Praxis::Request.instance_methods).to include(:user_abilities)
+  end
+
+  context 'ActionDefinition' do
+    subject(:action) { ApiResources::Instances.actions[:terminate] }
+    its(:required_abilities) { should match_array [:terminate, :read] }
+
+    context '#describe' do
+      subject(:describe) { action.describe }
+      it { should have_key :required_abilities}
+      its([:required_abilities]) { should match_array action.required_abilities}
+    end
+
+  end
+
+end

data/spec/praxis/request_spec.rb

@@ -31,8 +31,63 @@ 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")
+    end
+  end
+  
+  context 'loading api version' do
+    let(:request) { Praxis::Request.new(env) }
+    subject(:version){ request.version( version_options ) }
+    context 'using X-Api-Header' do
+      let(:env){ {'HTTP_X_API_VERSION' => "5.0", "PATH_INFO" => "/something"} }
+      let(:version_options){ {using: :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} }
+      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') }  
+    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} }
+        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} }
+        it { should eq('n/a') }
+      end
+    end
+    
+    context 'using defaults' do
+      subject(:version){ request.version }
+      context 'would succeed if passed through the header' do
+        let(:env){ {'HTTP_X_API_VERSION' => "5.0", "PATH_INFO" => "/something"} }
+        it { should eq('5.0') }
+      end
+      context 'would succeed if passed through params' do
+        let(:env) { Rack::MockRequest.env_for('/instances/1?junk=foo&api_version=5.0') }
+        it { should eq('5.0') }
+      end
+    end
+  end
 
-  context 'with a multipart requset' do
+  context 'with a multipart request' do
     let(:form) do
       form_data = MIME::Multipart::FormData.new