praxis 0.22.pre.2 → 2.0.pre.1

data/spec/praxis/mapper/selector_generator_spec.rb

@@ -0,0 +1,301 @@
+# require 'spec_helper'
+
+# describe Praxis::Mapper::SelectorGenerator do
+#   let(:properties) { {} }
+#   let(:resource) { BlogResource }
+#   subject(:generator) {Praxis::Mapper::SelectorGenerator.new }
+
+#   before do
+#     generator.add(resource,properties)
+#   end
+
+#   let(:expected_selectors) { {} }
+
+#   context 'for a simple field' do
+#     let(:properties) { {id: true} }
+#     let(:expected_selectors) do
+#       {
+#         BlogModel => {
+#           select: Set.new([:id]),
+#           track: Set.new()
+#         }
+#       }
+#     end
+
+#     it 'generates the correct set of selectors' do
+#       generator.selectors.should eq expected_selectors
+#     end
+#   end
+
+#   context 'for a simple property' do
+#     let(:properties) { {display_name: true} }
+#     let(:expected_selectors) do
+#       {
+#         BlogModel => {
+#           select: Set.new([:name]),
+#           track: Set.new()
+#         }
+#       }
+#     end
+#     it 'generates the correct set of selectors' do
+#       generator.selectors.should eq expected_selectors
+#     end
+#   end
+
+#   context 'for an association' do
+#     let(:properties) { {owner: true} }
+#     let(:expected_selectors) do
+#       {
+#         BlogModel => {
+#           select: Set.new([:owner_id]),
+#           track: Set.new([:owner])
+#         }
+#       }
+#     end
+#     it 'generates the correct set of selectors' do
+#       generator.selectors.should eq expected_selectors
+#     end
+
+#     context 'that is many_to_many' do
+#       let(:properties) { {commented_posts: true} }
+#       let(:resource) { UserResource }
+#       let(:expected_selectors) do
+#         {
+#           CommentModel => {
+#             select: Set.new([:author_id, :post_id]),
+#             track: Set.new([:post])
+#           },
+#           UserModel => {
+#             select: Set.new([]),
+#             track: Set.new([:comments])
+#           }
+#         }
+#       end
+#       it 'generates the correct set of selectors' do
+#         generator.selectors.should eq expected_selectors
+#       end
+#     end
+
+#     context 'that is many_to_many without a :through option' do
+#       let(:properties) { {other_commented_posts: { id: true} } }
+#       let(:resource) { UserResource }
+#       let(:expected_selectors) do
+#         {
+#           PostModel => {
+#             select: Set.new([:id]),
+#             track: Set.new([])
+#           },
+#           UserModel => {
+#             select: Set.new([]),
+#             track: Set.new([:other_commented_posts])
+#           }
+#         }
+#       end
+#       it 'generates the correct set of selectors' do
+#         generator.selectors.should eq expected_selectors
+#       end
+#     end
+
+
+#     context 'that uses a composite key' do
+#       let(:properties) { {composite_model: {id: true, type: true} } }
+#       let(:resource) { OtherResource }
+#       let(:expected_selectors) do
+#         {
+#           OtherModel => {
+#             select: Set.new([:composite_id,:composite_type]),
+#             track: Set.new([:composite_model])
+#           },
+#           CompositeIdModel => {
+#             select: Set.new([:id,:type]),
+#             track: Set.new
+#           }
+#         }
+#       end
+#       it 'generates the correct set of selectors' do
+#         generator.selectors.should eq expected_selectors
+#       end
+#     end
+#   end
+
+#   context 'for a property that specifies a field from an association' do
+#     let(:properties) { {owner_email: true} }
+#     let(:expected_selectors) do
+#       {
+#         BlogModel => {
+#           select: Set.new([:owner_id]),
+#           track: Set.new([:owner])
+#         },
+#         UserModel => {
+#           select: Set.new([:email]),
+#           track: Set.new()
+#         }
+#       }
+#     end
+
+#     it 'generates the correct set of selectors' do
+#       generator.selectors.should eq expected_selectors
+#     end
+#   end
+
+#   context 'for a simple property that requires all fields' do
+#     let(:properties) { {everything: true} }
+#     let(:expected_selectors) do
+#       {
+#         BlogModel => {
+#           select: true,
+#           track: Set.new()
+#         }
+#       }
+#     end
+#     it 'generates the correct set of selectors' do
+#       generator.selectors.should eq expected_selectors
+#     end
+#   end
+
+#   context 'for property that uses an associated property' do
+#     let(:properties) { {owner_full_name: true} }
+#     let(:expected_selectors) do
+#       {
+#         BlogModel => {
+#           select: Set.new([:owner_id]),
+#           track: Set.new([:owner])
+#         },
+#         UserModel => {
+#           select: Set.new([:first_name, :last_name]),
+#           track: Set.new()
+#         }
+#       }
+#     end
+#     it 'generates the correct set of selectors' do
+#       generator.selectors.should eq expected_selectors
+#     end
+#   end
+
+
+#   context 'for a property that requires all fields from an association' do
+#     let(:properties) { {everything_from_owner: true} }
+#     let(:expected_selectors) do
+#       {
+#         BlogModel => {
+#           select: Set.new([:owner_id]),
+#           track: Set.new([:owner])
+#         },
+#         UserModel => {
+#           select: true,
+#           track: Set.new()
+#         }
+#       }
+#     end
+#     it 'generates the correct set of selectors' do
+#       generator.selectors.should eq expected_selectors
+#     end
+#   end
+
+#   context 'using a property that specifies a :through option' do
+#     let(:properties) { {recent_posts: {author: {full_name: true}}} }
+#     let(:resource) { UserResource }
+#     let(:expected_selectors) do
+#       {
+#         PostModel => {
+#           select: Set.new([:author_id, :created_at]),
+#           track: Set.new([:author])
+#         },
+#         UserModel => {
+#           select: Set.new([:first_name, :last_name]),
+#           track: Set.new([:posts])
+#         }
+#       }
+#     end
+#     it 'generates the correct set of selectors' do
+#       generator.selectors.should eq expected_selectors
+#     end
+#   end
+
+#   context 'with a property with a circular definition (ie, includes its own field)' do
+#     let(:resource) { PostResource }
+
+#     let(:properties) { {id: true, slug: true} }
+#     let(:expected_selectors) do
+#       {
+#         PostModel => {
+#           select: Set.new([:id, :slug, :title]),
+#           track: Set.new
+#         }
+#       }
+#     end
+#     it 'generates the correct set of selectors' do
+#       generator.selectors.should eq expected_selectors
+#     end
+#   end
+
+#   context 'with a property without the :through option' do
+#     let(:resource) { UserResource }
+#     let(:properties) { {blogs_summary: {size: true}} }
+#     let(:expected_selectors) do
+#      {
+#        BlogModel => {
+#          select: Set.new([:owner_id]),
+#          track: Set.new()
+#        },
+#        UserModel => {
+#          select: Set.new([:id]),
+#          track: Set.new([:blogs])
+#        }
+#      }
+#     end
+#     it 'ignores any subsequent fields when generating selectors' do
+#       generator.selectors.should eq expected_selectors
+#     end
+#   end
+
+#   context 'for a property with no dependencies' do
+#     let(:properties) { {id: true, kind: true} }
+#     let(:expected_selectors) do
+#       {
+#         BlogModel => {
+#           select: Set.new([:id]),
+#           track: Set.new()
+#         }
+#       }
+#     end
+#     it 'generates the correct set of selectors' do
+#       generator.selectors.should eq expected_selectors
+#     end
+#   end
+
+#   context 'with large set of properties' do
+
+#     let(:properties) do
+#       {
+#         display_name: true,
+#         owner: {
+#           id: true,
+#           full_name: true,
+#           blogs_summary: {href: true, size: true},
+#           main_blog: {id: true},
+#         },
+#         administrator: {id: true, full_name: true}
+#       }
+#     end
+
+#     let(:expected_selectors) do
+#       {
+#         BlogModel=> {
+#           select: Set.new([:id, :name, :owner_id, :administrator_id]),
+#           track: Set.new([:owner, :administrator])
+#         },
+#         UserModel=> {
+#           select: Set.new([:id, :first_name, :last_name, :main_blog_id]),
+#           track: Set.new([:blogs, :main_blog])
+#         }
+#       }
+#     end
+
+#     it 'generates the correct set of selectors' do
+#       generator.selectors.should eq(expected_selectors)
+#     end
+
+#   end
+
+# end

data/spec/praxis/middleware_app_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Praxis::MiddlewareApp do
 
-  let(:init_args){ { root: 'here', name: 'middleware_app_spec', skip_registration: true} }
+  let(:init_args){ { root: 'here'} }
   let(:middleware) { Praxis::MiddlewareApp.for( init_args ) }
   let(:instance){ middleware.new(target)}
 
@@ -29,22 +29,28 @@ describe Praxis::MiddlewareApp do
     end
     
     context '.call' do
-      let(:the_instance) { double("The instance", setup: nil) }
       let(:env){ {} }
       let(:praxis_response){ [200,{}] }
       subject(:response){ instance.call(env) }
       before do
         # always invokes the praxis app
-        expect( Praxis::Application ).to receive(:new).once.and_return(the_instance)
-        expect( the_instance ).to receive(:call).with( env ).once.and_return(praxis_response)
-        allow( the_instance ).to receive(:setup).and_return(the_instance)
+        expect( Praxis::Application.instance ).to receive(:call).with( env ).once.and_return(praxis_response)
       end
 
-      it 'does not explicitly call setup in the initialization (the app needs to do it at the right time)' do
-        expect( the_instance ).to_not receive(:setup)
-        subject
+      context 'when it has not been setup yet' do
+        it 'initializes the application singleton with the passed parameters' do
+          expect( Praxis::Application.instance ).to receive(:setup).with( init_args ).once
+          subject
+        end
+      end
+      context 'when it has already been setup' do
+        it 'does NOT call instance setup' do
+          middleware.setup
+          expect( Praxis::Application.instance ).to_not receive(:setup)
+          subject
+        end
       end
-      
+
       context 'properly handled (non-404 and 405) responses from praxis' do
         it 'are returned straight through' do
           expect( response ).to be(praxis_response)

data/spec/praxis/request_spec.rb

@@ -12,17 +12,7 @@ describe Praxis::Request do
     env['HTTP_AUTHORIZATION'] = 'Secret'
     env
   end
-  let(:application) do
-    app = Praxis::Application.new(skip_registration: true)
-    app.versioning_scheme = [:header, :params]
-    app.handler 'json' , Praxis::Handlers::JSON
-    app.handler 'x-www-form-urlencoded', Praxis::Handlers::WWWForm
-    app.api_definition.info do # applies to all API infos
-      base_path "/api"
-    end
-    app
-  end
-  
+
   let(:action) { Instances.definition.actions[:show] }
 
   let(:context) do
@@ -34,7 +24,7 @@ describe Praxis::Request do
   end
 
   subject(:request) do
-    request = Praxis::Request.new(env, application: application)
+    request = Praxis::Request.new(env)
     request.action = action
     request
   end
@@ -47,10 +37,10 @@ describe Praxis::Request do
   context 'path versioning' do
     before do
       allow(
-        application
+        Praxis::Application.instance
       ).to receive(:versioning_scheme).and_return(:path)
       allow(
-        application.api_definition.info
+        Praxis::ApiDefinition.instance.info
       ).to receive(:base_path).and_return('/api/v:api_version')
 
     end
@@ -74,7 +64,7 @@ describe Praxis::Request do
     let(:versioning_scheme){ Praxis::Request::VERSION_USING_DEFAULTS }
     before do
       allow(
-        application
+        Praxis::Application.instance
       ).to receive(:versioning_scheme).and_return(versioning_scheme)
     end
 
@@ -94,7 +84,7 @@ describe Praxis::Request do
 
       before do
         allow(
-          application.api_definition.info
+          Praxis::ApiDefinition.instance.info
         ).to receive(:base_path).and_return('/v:api_version')
       end
       it { should eq('5.0') }
@@ -219,7 +209,7 @@ describe Praxis::Request do
       let(:parsed_result){ double("parsed") }
 
       before do
-        application.handler 'xml', Praxis::Handlers::XML
+        Praxis::Application.instance.handler 'xml', Praxis::Handlers::XML
       end
 
       after do

data/spec/praxis/request_stages/validate_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Praxis::RequestStages::Validate do
-  let(:dispatcher) { Praxis::Dispatcher.new(application: APP) }
+  let(:dispatcher) { Praxis::Dispatcher.new }
 
   # Instances controller is defined in the 'app' folder and is already in scope. Using this
   # controller for the specs instead of creating a simple controller.

data/spec/praxis/resource_definition_spec.rb

@@ -101,13 +101,12 @@ describe Praxis::ResourceDefinition do
 
       end
     end
-    let(:praxis_application) do
-      app = Praxis::Application.new(skip_registration: true)
-      app.versioning_scheme = [:header, :params]
-      app.handler 'json' , Praxis::Handlers::JSON
-      app.handler 'x-www-form-urlencoded', Praxis::Handlers::WWWForm
-      app.api_definition.instance_eval do |api_def|
-        api_def.info do
+
+    let(:non_singleton_api) do
+      api_def=Praxis::ApiDefinition.__send__(:new)
+      api_def.instance_eval do |api|
+
+        api.info do
           base_path '/api/:base_param'
           base_params do
             attribute :base_param, String
@@ -117,23 +116,22 @@ describe Praxis::ResourceDefinition do
           end
         end
 
-        api_def.info '1.0' do
+        api.info '1.0' do
           base_params do
             attribute :app_name, String
           end
         end
-        api_def.info '2.0' do
+        api.info '2.0' do
           base_params do
             attribute :v2_param, String
           end
         end
-
       end
-      app
+      api_def
     end
 
     before do
-      allow(Praxis::Application).to receive(:instance).and_return(praxis_application)
+      allow(Praxis::ApiDefinition).to receive(:instance).and_return(non_singleton_api)
     end
 
     it 'are applied to actions' do

data/spec/praxis/response_definition_spec.rb

@@ -1,24 +1,7 @@
 require "spec_helper"
 
 describe Praxis::ResponseDefinition do
-  let(:praxis_app) do
-    app = Praxis::Application.new(skip_registration: true)
-    app.versioning_scheme = [:header, :params]
-    app.handler 'json' , Praxis::Handlers::JSON
-    app.handler 'x-www-form-urlencoded', Praxis::Handlers::WWWForm
-    app.handler 'xml', Praxis::Handlers::XML
-    app.api_definition.instance_eval do |api_def|
-      api_def.info do
-        base_path "/api"
-        produces 'json','xml'
-      end
-    end
-    app
-  end
-  
-  
-  
-  subject(:response_definition) { Praxis::ResponseDefinition.new(name, praxis_app, &block) }
+  subject(:response_definition) { Praxis::ResponseDefinition.new(name, &block) }
   let(:name) { 'response_name' }
 
   let(:block) do
@@ -499,7 +482,7 @@ describe Praxis::ResponseDefinition do
   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',praxis_app) do
+        Praxis::ResponseDefinition.new('response name') do
           description "testing"
         end
       end.to raise_error(Praxis::Exceptions::InvalidConfiguration)
@@ -513,7 +496,7 @@ describe Praxis::ResponseDefinition do
     let(:parts) { nil }
 
     let(:response) do
-      Praxis::ResponseDefinition.new(:custom, praxis_app) do
+      Praxis::ResponseDefinition.new(:custom) do
         status 300
       end
     end
@@ -541,8 +524,8 @@ describe Praxis::ResponseDefinition do
         its(['xml', :content_type]) { should eq('application/vnd.acme.instance+xml') }
 
         it 'properly encodes the example bodies' do
-          json = praxis_app.handlers['json'].parse(examples['json'][:body])
-          xml = praxis_app.handlers['xml'].parse(examples['xml'][:body])
+          json = Praxis::Application.instance.handlers['json'].parse(examples['json'][:body])
+          xml = Praxis::Application.instance.handlers['xml'].parse(examples['xml'][:body])
           expect(json).to eq xml
         end
 

data/spec/praxis/response_spec.rb

@@ -49,14 +49,7 @@ describe Praxis::Response do
   end
 
   subject(:response) { Praxis::Responses::Ok.new(status: response_status, headers: response_headers) }
-  let(:application) do
-    double("PraxisApp", handlers: handlers, config: praxis_config)
-  end
-  let(:handlers) do
-    {'json' => Praxis::Handlers::JSON.new }
-  end
-  let(:praxis_config){ double(praxis: double("...") )  }
-  
+
   describe '#validate' do
     before do
       allow(action).to receive(:responses).and_return({response_spec.name => response_spec })
@@ -93,7 +86,7 @@ describe Praxis::Response do
       before { response.body = response_body_entity }
 
       it 'leaves well enough alone' do
-        response.encode!(handlers: handlers)
+        response.encode!
         expect(response.body).to eq(response_body_entity)
       end
     end
@@ -102,7 +95,7 @@ describe Praxis::Response do
       before { response.body = response_body_structured_data }
 
       it 'encodes using a suitable handler' do
-        response.encode!(handlers: handlers)
+        response.encode!
         expect(JSON.load(response.body)).to eq(response_body_structured_data)
       end
     end
@@ -115,7 +108,7 @@ describe Praxis::Response do
           'Location'     => '/api/resources/123' }
       }
       it 'still defaults to the default handler' do
-        response.encode!(handlers: handlers)
+        response.encode!
         expect(JSON.load(response.body)).to eq(response_body_structured_data)
       end
     end
@@ -165,7 +158,7 @@ describe Praxis::Response do
         response.status = 500
       end
 
-      let!(:finished_response) { response.finish(application: application) }
+      let!(:finished_response) { response.finish }
 
       it 'returns status, headers, body' do
         expect(finished_response).to eq([response.status, response.headers, response.body])

data/spec/praxis/responses/internal_server_error_spec.rb

@@ -17,12 +17,15 @@ describe Praxis::Responses::InternalServerError do
 
 
   context '.format!' do
-    let(:app){ double("PraxisApp", config: double(praxis: config)) }
     let(:error) { double('error', message: 'error message', backtrace: [1, 2], cause: cause) }
 
     let(:show_exceptions) { true }
     let(:config) { double("config", show_exceptions: show_exceptions) }
 
+    before do
+      allow(Praxis::Application.instance.config).to receive(:praxis).and_return(config)
+    end
+
     context 'with show_exceptions false' do
     end
 
@@ -50,7 +53,7 @@ describe Praxis::Responses::InternalServerError do
     subject(:response) { Praxis::Responses::InternalServerError.new(error: error) }
     before do
       expect(response.body).to be_nil
-      response.format!(config: app.config)
+      response.format!
     end
 
   end

data/spec/praxis/router_spec.rb

@@ -1,11 +1,6 @@
 require 'spec_helper'
 
 describe Praxis::Router do
-  let(:application) do
-    app = Praxis::Application.new(skip_registration: true)
-    app.versioning_scheme = [:header, :params]
-    app
-  end
   describe Praxis::Router::VersionMatcher do
     let(:resource_definition){ double("resource_definition", version_options: { using: [:header, :params] }) }
     let(:action){ double("action", resource_definition: resource_definition ) }
@@ -22,7 +17,7 @@ describe Praxis::Router do
 
     context '.call' do
       let(:env){ {"HTTP_X_API_VERSION" => request_version } }
-      let(:request) {Praxis::Request.new(env,application: application)}
+      let(:request) {Praxis::Request.new(env)}
 
       context 'with matching versions' do
         let(:request_version) { "1.0" }
@@ -72,6 +67,7 @@ describe Praxis::Router do
     end
   end
 
+  let(:application) { instance_double('Praxis::Application')}
   subject(:router) {Praxis::Router.new(application)}
 
   context "attributes" do
@@ -108,7 +104,7 @@ describe Praxis::Router do
     let(:request_verb) { 'POST' }
     let(:request_path_info) { '/' }
     let(:request_version){ nil }
-    let(:request) {Praxis::Request.new(env, application: application)}
+    let(:request) {Praxis::Request.new(env)}
     let(:router_response){ 1 }
     let(:router_response_for_post){ "POST result" }
     let(:router_response_for_wildcard){ "* result" }
@@ -189,7 +185,7 @@ describe Praxis::Router do
       end
 
       context 'with X-Cascade disabled' do
-        let(:config) { application.config.praxis }
+        let(:config) { Praxis::Application.instance.config.praxis }
         before do
           expect(config).to receive(:x_cascade).and_return(false)
         end

data/spec/spec_app/app/models/person.rb

@@ -1,3 +1,3 @@
-class PersonModel < Praxis::Mapper::Model
-  table_name 'people'
-end
+# class PersonModel #< Praxis::Mapper::Model
+#   # table_name 'people'
+# end