praxis 0.21 → 2.0.pre.3

data/spec/praxis/media_type_spec.rb

@@ -52,16 +52,6 @@ describe Praxis::MediaType do
     subject(:address_klass) { address.class }
 
     context '#identifier' do
-      context 'in praxis v0' do
-        it 'should be a kind of String' do
-          if Praxis::VERSION =~ /^0/
-            expect(subject.identifier).to be_kind_of(String)
-          else
-            raise 'Please remove this spec which is no longer pertinent'
-          end
-        end
-      end
-
       context 'in praxis v1.0 and beyond' do
         it 'should be a kind of Praxis::MediaTypeIdentifier' do
           pending('interface-breaking change') if Praxis::VERSION =~ /^0/

data/spec/praxis/middleware_app_spec.rb

@@ -2,35 +2,55 @@ require 'spec_helper'
 
 describe Praxis::MiddlewareApp do
 
-  context '.for' do
-    let(:init_args){ { root: 'here'} }
-    subject(:middleware) { Praxis::MiddlewareApp.for( init_args ) }
+  let(:init_args){ { root: 'here'} }
+  let(:middleware) { Praxis::MiddlewareApp.for( **init_args ) }
+  let(:instance){ middleware.new(target)}
 
-    it 'initializes the application singletone with the passed parameters' do
-      expect( Praxis::Application.instance ).to receive(:setup).with( init_args ).once
-      subject
+  context '.for' do
+    it 'does not initialize the Application instance yet' do
+      expect( Praxis::Application.instance ).to_not receive(:setup)
+      middleware
     end
     it 'returns its class' do
-      expect( subject ).to be( Praxis::MiddlewareApp )
+      expect( middleware ).to be < Praxis::MiddlewareApp 
     end
   end
 
   context 'instantiated' do
+    subject{ instance }
     let(:target_response){ [201,{}] }
     let(:target){ double("target app", call: target_response) }
-    subject(:instance){ Praxis::MiddlewareApp.new(target)}
     it 'saves the target app' do
       expect(subject.target).to be(target)
     end
+    it 'does not initialize the Application instance yet' do
+      expect( Praxis::Application.instance ).to_not receive(:setup)
+      subject
+    end
+    
     context '.call' do
       let(:env){ {} }
       let(:praxis_response){ [200,{}] }
-      subject(:response){ Praxis::MiddlewareApp.new(target).call(env) }
+      subject(:response){ instance.call(env) }
       before do
         # always invokes the praxis app
         expect( Praxis::Application.instance ).to receive(:call).with( env ).once.and_return(praxis_response)
       end
 
+      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_stages/action_spec.rb

@@ -26,7 +26,14 @@ describe Praxis::RequestStages::Action do
 
   context '.execute' do
     before do
-      expect(controller).to receive(action_stage.name).with(request.params_hash).and_return(controller_response)
+      expect(controller).to receive(action_stage.name) do |args|
+        if args
+          expect(args).to eq({})
+        else
+           expect(args).to eq(nil)
+        end
+      end.and_return(controller_response)
+        
     end
     let(:controller_response){ controller.response }
 

data/spec/praxis/response_definition_spec.rb

@@ -448,7 +448,7 @@ describe Praxis::ResponseDefinition do
         context 'with legacy multipart response' do
           subject(:response) { Praxis::Responses::Ok.new(status: response_status, headers: response_headers) }
 
-          let(:part) { Praxis::MultipartPart.new('done', {'Status' => 200, 'Content-Type' => 'application/special'},{}) }
+          let(:part) { Praxis::MultipartPart.new('done', {'Status' => 200, 'Content-Type' => 'application/special'},**{}) }
 
           before do
             response_definition.parts like: :ok, media_type: 'application/special'
@@ -463,7 +463,7 @@ describe Praxis::ResponseDefinition do
           end
 
           context 'with invalid part' do
-            let(:part) { Praxis::MultipartPart.new('done', {'Status' => 200, "Location" => "somewhere"},{}) }
+            let(:part) { Praxis::MultipartPart.new('done', {'Status' => 200, "Location" => "somewhere"}) }
 
             it 'validates' do
               expect {
@@ -494,6 +494,7 @@ describe Praxis::ResponseDefinition do
     let(:location) { %r{/my/url/} }
     let(:headers) { {'Header1' => 'Value1'} }
     let(:parts) { nil }
+    let(:parts_block) { nil }
 
     let(:response) do
       Praxis::ResponseDefinition.new(:custom) do
@@ -505,7 +506,9 @@ describe Praxis::ResponseDefinition do
     before do
       response.description(description) if description
       response.location(location) if location
-      response.parts(parts) if parts
+      if parts || parts_block
+        parts ? response.parts(nil, **parts, &parts_block) : response.parts(nil, &parts_block) 
+      end
       response.headers(headers) if headers
     end
 
@@ -572,7 +575,7 @@ describe Praxis::ResponseDefinition do
         its([:status]){ should == 200 }
       end
       context 'using a full response definition block' do
-        let(:parts) do
+        let(:parts_block) do
           Proc.new do
             status 234
             media_type 'custom_media'

data/spec/praxis/response_spec.rb

@@ -117,7 +117,7 @@ describe Praxis::Response do
   end
 
   context 'multipart responses' do
-    let(:part) { Praxis::MultipartPart.new('not so ok', {'Status' => 400, "Location" => "somewhere"}, {}) }
+    let(:part) { Praxis::MultipartPart.new('not so ok', {'Status' => 400, "Location" => "somewhere"}) }
 
     context '#add_part' do
 

data/spec/praxis/responses/internal_server_error_spec.rb

@@ -8,7 +8,7 @@ describe Praxis::Responses::InternalServerError do
     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.body).to be_nil
       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)
@@ -52,7 +52,7 @@ describe Praxis::Responses::InternalServerError do
 
     subject(:response) { Praxis::Responses::InternalServerError.new(error: error) }
     before do
-      expect(response.body).to be_empty
+      expect(response.body).to be_nil
       response.format!
     end
 

data/spec/praxis/responses/validation_error_spec.rb

@@ -9,7 +9,7 @@ describe Praxis::Responses::ValidationError do
     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.body).to be_nil
       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)
@@ -24,7 +24,7 @@ describe Praxis::Responses::ValidationError do
     let(:exception){ nil }
     subject(:response) { Praxis::Responses::ValidationError.new(summary: summary, errors: errors, exception: exception) }
     before do
-      expect(response.body).to be_empty
+      expect(response.body).to be_nil
     end
     context 'when errors' do
       it 'it fills the errors key' do

data/spec/praxis/router_spec.rb

@@ -6,7 +6,7 @@ describe Praxis::Router do
     let(:action){ double("action", resource_definition: resource_definition ) }
     let(:target){ double("target", action: action ) }
     let(:args){ {version: "1.0"} }
-    subject(:matcher){ Praxis::Router::VersionMatcher.new(target,args) }
+    subject(:matcher){ Praxis::Router::VersionMatcher.new(target,**args) }
 
     context '.initialize' do
       let(:args){ {} }

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

@@ -73,7 +73,7 @@ class Instances < BaseClass
 
       headers = {
         'Status' => '201',
-        'Content-Type' => Instance.identifier + '+json',
+        'Content-Type' => (Instance.identifier + '+json').to_s,
         'Location' => definition.to_href(cloud_id: cloud_id, id: instance.id)
       }
 

data/spec/spec_app/config/environment.rb

@@ -21,35 +21,17 @@ Praxis::Application.configure do |application|
   application.bootloader.use SimpleAuthenticationPlugin, config_file: 'config/authentication.yml'
   application.bootloader.use AuthorizationPlugin
 
-
-  adapter_name = 'sqlite'
-  db_name = ':memory:'
-  connection_opts = if RUBY_PLATFORM !~ /java/
-    { adapter: adapter_name , database: db_name }
-   else
-    require 'jdbc/sqlite3'
-    { adapter: 'jdbc', uri: "jdbc:#{adapter_name}:#{db_name}" }
-  end
-
-  application.bootloader.use Praxis::Plugins::PraxisMapperPlugin, {
-    config_data: {
-      repositories: { default: connection_opts },
-      log_stats: 'detailed'
-    }
-  }
-
   # enable "development-mode" options
   application.config.praxis.validate_responses = true
   application.config.praxis.validate_response_bodies = true
   application.config.praxis.show_exceptions = true
 
-  # FIXME: until we have a better way to unit test such a feature...
   # Silly callback code pieces to test that the deferred callbacks work even for sub-stages
-  application.bootloader.after :app, :models do
-    PersonModel.identity(:other_id)
+  application.bootloader.after :app, :controllers do
+    $after_app_controllers = :worked
   end
   application.bootloader.after :app do
-    raise "After sub-stage hooks not working!" unless PersonModel.identities.include? :other_id
+    raise "After sub-stage hooks not working!" unless $after_app_controllers == :worked
   end
 
 

data/spec/spec_helper.rb

@@ -19,26 +19,32 @@ require 'rack/test'
 require 'rspec/its'
 require 'rspec/collection_matchers'
 
-
-
 Dir["#{File.dirname(__FILE__)}/../lib/praxis/plugins/*.rb"].each do |file|
   require file
 end
 
+
 Dir["#{File.dirname(__FILE__)}/support/*.rb"].each do |file|
   require file
 end
 
+def suppress_output
+  original_stdout, original_stderr = $stdout.clone, $stderr.clone
+  $stderr.reopen File.new('/dev/null', 'w')
+  $stdout.reopen File.new('/dev/null', 'w')
+  yield
+ensure
+  $stdout.reopen original_stdout
+  $stderr.reopen original_stderr
+end
 
 RSpec.configure do |config|
   config.include Rack::Test::Methods
 
   config.before(:suite) do
+    Praxis::Mapper::Resource.finalize!
     Praxis::Blueprint.caching_enabled = true
     Praxis::Application.instance.setup(root:'spec/spec_app')
-
-    # create the table
-    setup_database!
   end
 
   config.before(:each) do
@@ -53,13 +59,3 @@ RSpec.configure do |config|
   end
 end
 
-# create the test db schema
-def setup_database!
-  mapper = Praxis::Application.instance.plugins[:praxis_mapper]
-  Sequel.connect(mapper.config.repositories["default"]['connection_settings'].dump) do |db|
-    db.create_table! :people do
-      primary_key :id
-      string :name
-    end
-  end
-end

data/spec/support/be_deep_equal_matcher.rb

@@ -0,0 +1,39 @@
+# Copied verbatim from: https://github.com/amogil/rspec-deep-ignore-order-matcher
+
+RSpec::Matchers.define :be_deep_equal do |expected|
+  match { |actual| match? actual, expected }
+
+  failure_message do |actual|
+    "expected that #{actual} would be deep equal with #{expected}"
+  end
+
+  failure_message_when_negated do |actual|
+    "expected that #{actual} would not be deep equal with #{expected}"
+  end
+
+  description do
+    "be deep equal with #{expected}"
+  end
+
+  def match?(actual, expected)
+    return arrays_match?(actual, expected) if expected.is_a?(Array) && actual.is_a?(Array)
+    return hashes_match?(actual, expected) if expected.is_a?(Hash) && actual.is_a?(Hash)
+    expected == actual
+  end
+
+  def arrays_match?(actual, expected)
+    exp = expected.clone
+    actual.each do |a|
+      index = exp.find_index { |e| match? a, e }
+      return false if index.nil?
+      exp.delete_at(index)
+    end
+    exp.empty?
+  end
+
+  def hashes_match?(actual, expected)
+    return false unless actual.keys.sort == expected.keys.sort
+    actual.each { |key, value| return false unless match? value, expected[key] }
+    true
+  end
+end

data/spec/support/spec_resources.rb

@@ -0,0 +1,124 @@
+require 'ostruct'
+
+require 'praxis/mapper/active_model_compat'
+class SimpleModel < OpenStruct
+  include Praxis::Mapper::ActiveModelCompat
+  def self._praxis_associations
+    {
+      parent: {
+        model: ParentModel,
+        primary_key: :id,
+        type: :many_to_one,
+        local_key_columns: [:parent_id],
+        remote_key_columns: [:id]
+      },
+      other_model: {
+        model: OtherModel,
+        primary_key: :id,
+        type: :many_to_one,
+        local_key_columns: [:other_model_id],
+        remote_key_columns: [:id]
+      }
+    }
+  end
+end
+
+class OtherModel < OpenStruct
+  include Praxis::Mapper::ActiveModelCompat
+  def self._praxis_associations
+    {
+      parent: {
+        model: ParentModel,
+        primary_key: :id,
+        type: :many_to_one,
+        local_key_columns: [:parent_id],
+        remote_key_columns: [:id]
+      },
+      simple_models: {
+        model: SimpleModel,
+        primary_key: :id,
+        type: :many_to_many,
+        local_key_columns: [:id],
+        remote_key_columns: [:id] # The through table is in the middle where the FKs are...
+      }
+    }
+  end
+end
+
+class ParentModel < OpenStruct
+  include Praxis::Mapper::ActiveModelCompat
+  def self._praxis_associations
+    {
+      simple_children: {
+        model: SimpleModel,
+        primary_key: :id,
+        type: :one_to_many,
+        local_key_columns: [:id],
+        remote_key_columns: [:parent_id]
+      }
+    }
+  end
+end
+
+class YamlArrayModel < OpenStruct
+  include Praxis::Mapper::ActiveModelCompat
+  def self._praxis_associations
+   {
+    parents: {
+      model: ParentModel,
+      primary_key: :id,
+      type: :one_to_many,
+      local_key_columns: [:id],
+      remote_key_columns: [:parent_id]
+    }
+  }
+  end
+end
+
+# A set of resource classes for use in specs
+class BaseResource < Praxis::Mapper::Resource
+  def href
+    base_href = '' # "/api"
+    base_href + "/#{self.class.collection_name}/#{self.id}"
+  end
+
+  property :href, dependencies: [:id]
+end
+
+class OtherResource < BaseResource
+  model OtherModel
+
+  property :display_name, dependencies: [:name]
+end
+
+class ParentResource < BaseResource
+  model ParentModel
+end
+
+class SimpleResource < BaseResource
+  model SimpleModel
+
+  resource_delegate :other_model => [:other_attribute]
+
+  def other_resource
+    self.other_model
+  end
+
+  property :aliased_method, dependencies: [:column1, :other_model]
+  property :other_resource, dependencies: [:other_model]
+
+  property :parent, dependencies: [:parent, :added_column]
+
+  property :name, dependencies: [:simple_name]
+  property :direct_other_name, dependencies: [ 'other_model.name' ]
+  property :aliased_other_name, dependencies: [ 'other_model.display_name' ]
+
+  property :everything, dependencies: [:*]
+  property :everything_from_parent, dependencies: ['parent.*']
+  property :circular_dep, dependencies: [ :circular_dep, :column1 ]
+  property :no_deps, dependencies: []
+end
+
+class YamlArrayResource < BaseResource
+  model YamlArrayModel
+end