ninja-model 0.4.2 → 0.5.1

data/lib/ninja_model/relation/spawn_methods.rb

@@ -29,7 +29,7 @@ module NinjaModel
       end
       merged_relation.predicates = merged_predicates
 
-      Relation::SINGLE_VALUE_ATTRS.reject { |m| m == :lock }.each do |method|
+      Relation::SINGLE_VALUE_ATTRS.each do |method|
         value = r.send(:"#{method}_value")
         merged_relation.send(:"#{method}_value=", value) unless value.nil?
       end

data/lib/ninja_model/validation.rb

@@ -1,13 +1,14 @@
-require 'active_model'
-
 module NinjaModel
-  module Validation
-    extend ActiveSupport::Concern
+  class Base
     include ActiveModel::Validations
+    define_model_callbacks :validation
+  end
+
+  module Validation
 
     def save(options={})
       run_callbacks :validation do
-        perform_validations(options) ? super : false
+        valid?(options.is_a?(Hash) ? options[:context] : nil) ? super : false
       end
     end
 
@@ -16,23 +17,5 @@ module NinjaModel
       output = super(context)
       errors.empty? && output
     end
-
-    protected
-
-    def perform_validations(options={})
-      perform_validation = case options
-        when Hash
-          options[:validate] != false
-        else
-          ActiveSupport::Deprecation.warn "save(#{options}) is deprecated, please give save(:validate => #{options}) instead", caller
-          options
-        end
-
-      if perform_validation
-        valid?(options.is_a?(Hash) ? options[:context] : nil)
-      else
-        true
-      end
-    end
   end
 end

data/lib/ninja_model/version.rb

@@ -1,3 +1,3 @@
 module NinjaModel
- VERSION = "0.4.2"
+ VERSION = "0.5.1"
 end

data/ninja-model.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ninja_model/version"
+
+Gem::Specification.new do |s|
+  s.name        = %q{ninja-model}
+  s.version     = NinjaModel::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.author      = %q{Josh Williams}
+  s.email       = %q{theprime@codingprime.com}
+  s.homepage    = %q{http://github.com/t3hpr1m3/ninja-model.git}
+  s.summary     = %q{Pseudo-ORM for Ruby}
+  s.description = %q{Pseudo-ORM for Ruby/Rails with an ActiveRecord-like interface}
+
+  s.rubyforge_project = s.name
+
+  s.files         = `git ls-files`.split("\n") - ["Gemfile.lock"]
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'activerecord', '~> 3.0.3'
+
+  s.add_development_dependency 'rspec',     '~> 2.2.0'
+  s.add_development_dependency 'mocha',     '~> 0.9.8'
+  s.add_development_dependency 'rcov',      '~> 0.9.9'
+  s.add_development_dependency 'nokogiri',  '~> 1.4.4'
+  s.add_development_dependency 'autotest',  '~> 4.4.6'
+end

data/spec/ninja_model/adapters/abstract_adapter_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe NinjaModel::Adapters::AbstractAdapter do
+  subject { NinjaModel::Adapters::AbstractAdapter.new({}) }
+  it { should respond_to(:reconnect!) }
+  it { should respond_to(:disconnect!) }
+  it { should respond_to(:reset!) }
+  it { should respond_to(:verify!) }
+  it { should respond_to(:create) }
+  it { should respond_to(:read) }
+  it { should respond_to(:update) }
+  it { should respond_to(:destroy) }
+  its(:adapter_name) { should eql('Abstract') }
+  its(:persistent_connection?) { should be_true }
+  its(:active?) { should be_false }
+  specify { subject.create({}).should be_false }
+  specify { subject.read({}).should be_nil }
+  specify { subject.update({}).should be_false }
+  specify { subject.destroy({}).should be_false }
+
+  it 'should be active after reconnect' do
+    subject.reconnect!
+    subject.active?.should be_true
+  end
+
+  describe 'verify!' do
+    it 'should call reconnect! when inactive' do
+      subject.stubs(:active?).returns(false)
+      subject.expects(:reconnect!)
+      subject.verify!
+    end
+
+    it 'should not call reconnect! when active' do
+      subject.stubs(:active?).returns(true)
+      subject.expects(:reconnect!).never
+      subject.verify!
+    end
+  end
+
+  it 'should be inactive after disconnect' do
+    subject.reconnect!
+    subject.disconnect!
+    subject.active?.should be_false
+  end
+end

data/spec/ninja_model/adapters/adapter_manager_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe NinjaModel::Adapters::AdapterManager do
+  class DummyAdapter < NinjaModel::Adapters::AbstractAdapter; end
+  class TestModel < NinjaModel::Base; end
+  class ChildModel < TestModel; end
+
+  before {
+    @manager = NinjaModel::Adapters::AdapterManager.new
+    @manager.class.register_adapter_class(:dummy, DummyAdapter)
+  }
+  subject { @manager }
+
+  it 'should remember registered adapters' do
+    subject.class.registered?(:dummy).should be_true
+  end
+
+  describe 'creating an adapter' do
+    before { @manager.create_adapter('TestModel', NinjaModel::Adapters::AdapterSpecification.new({}, :dummy)) }
+    it 'should add the adapter to the pool' do
+      @manager.retrieve_adapter_pool(TestModel).spec.name.should eql(:dummy)
+    end
+    it 'should return the adapter for descendent classes' do
+      @manager.retrieve_adapter_pool(ChildModel).spec.name.should eql(:dummy)
+    end
+  end
+
+  describe 'removing an adapter' do
+    before {
+      @spec = NinjaModel::Adapters::AdapterSpecification.new({:foo => 'bar'}, :dummy)
+      @manager.create_adapter('TestModel', @spec)
+    }
+    it 'should remove the adapter from the pool' do
+      @manager.remove_adapter(TestModel)
+      @manager.retrieve_adapter_pool(TestModel).should be_nil
+    end
+    it 'should cause retrieve_adapter to raise an error' do
+      @manager.remove_adapter(TestModel)
+      lambda { @manager.retrieve_adapter(TestModel) }.should raise_error(StandardError)
+    end
+    it 'should return the spec that created it' do
+      @manager.remove_adapter(TestModel).should eql({:foo => 'bar'})
+    end
+  end
+
+  describe 'release_active_adapters!' do
+    before {
+      @spec = NinjaModel::Adapters::AdapterSpecification.new({:foo => 'bar'}, :dummy)
+      @manager.create_adapter('TestModel', @spec)
+    }
+    it 'should call release_instance on all pools' do
+      @pool = @manager.adapter_pools['TestModel']
+      @pool.expects(:release_instance)
+      @manager.release_active_adapters!
+    end
+  end
+
+  describe 'release_all_adapters!' do
+    before {
+      @spec = NinjaModel::Adapters::AdapterSpecification.new({:foo => 'bar'}, :dummy)
+      @manager.create_adapter('TestModel', @spec)
+    }
+    it 'should call shutdown! on all pools' do
+      @pool = @manager.adapter_pools['TestModel']
+      @pool.expects(:shutdown!)
+      @manager.release_all_adapters!
+    end
+  end
+end

data/spec/ninja_model/adapters/adapter_pool_spec.rb

@@ -1,72 +1,234 @@
 require 'spec_helper'
-require 'ninja_model'
 
 describe NinjaModel::Adapters::AdapterPool do
-  before(:each) do
-    @spec = mock('AdapterSpecification') do
-      stubs(:adapter_method).returns(:dummy_adapter)
-      stubs(:config)
-    end
+  class DummyAdapter < NinjaModel::Adapters::AbstractAdapter; end
+  before {
+    @spec = NinjaModel::Adapters::AdapterSpecification.new({}, :dummy)
+    NinjaModel::Base.register_adapter(:dummy, DummyAdapter)
+    @pool = NinjaModel::Adapters::AdapterPool.new(@spec)
+  }
+  subject { @pool }
+  its(:spec) { should eql(@spec) }
+  its(:instances) { should be_empty }
+  its(:connected?) { should be_false }
+  its(:current_instance_id) { should eql(Thread.current.object_id) }
 
-    @adapter = mock('AbstractAdapter') do
-      stubs(:verify!)
+  describe 'obtaining an adapter instance' do
+    it 'should store the instance for a given thread' do
+      subject.instance
+      subject.expects(:checkout).never
+      subject.instance
     end
+  end
 
-    @pool = NinjaModel::Adapters::AdapterPool.new(@spec)
-    @thread = mock('thread') do
-      stubs('object_id').returns(123)
+  describe 'releasing an adapter instance' do
+    it 'should call checkout when obtaining another instance' do
+      subject.expects(:checkout).twice
+      subject.instance
+      subject.release_instance
+      subject.instance
     end
-    Thread.stubs(:current).returns(@thread)
-    NinjaModel::Base.stubs(:dummy_adapter).returns(@adapter)
   end
 
-  it 'should properly respond to connected?' do
-    @pool.connected?.should be_false
-    @pool.instance
-    @pool.connected?.should be_true
+  describe 'with_instance' do
+    it 'should yield an instance' do
+      @inst = nil
+      subject.with_instance do |inst|
+        @inst = inst
+      end
+      @inst.should be_kind_of(DummyAdapter)
+    end
+    it 'should release the instance when complete' do
+      subject.expects(:release_instance).with(subject.send :current_instance_id)
+      subject.with_instance do |inst|
+      end
+    end
   end
 
-  it 'should initialize from an AdapterSpecification' do
-    spec = mock('AdapterSpecification')
-    NinjaModel::Adapters::AdapterPool.new(spec).spec.should eql(spec)
+  describe 'shutdown!' do
+    it 'should checkin all assigned instances' do
+      @inst = subject.instance
+      subject.expects(:checkin).with(@inst)
+      subject.shutdown!
+    end
+    it 'should call disconnect on all instances' do
+      @inst = subject.instance
+      @inst.expects(:disconnect!)
+      subject.shutdown!
+    end
   end
 
-  it 'should return a valid instance_id' do
-    (@pool.send :current_instance_id).should eql(@thread.object_id)
+  describe 'clear_stale_cached_instances!' do
+    it 'should reap any instances for dead threads' do
+      @thread = mock('Thread') do
+        stubs(:object_id).returns(Thread.current.object_id)
+        stubs(:alive?).returns(false)
+      end
+      Thread.stubs(:list).returns([@thread])
+      @inst = subject.instance
+      subject.expects(:checkin).with(@inst)
+      subject.send :clear_stale_cached_instances!
+    end
+    it 'should not reap instances for live threads' do
+      @thread = mock('Thread') do
+        stubs(:object_id).returns(Thread.current.object_id)
+        stubs(:alive?).returns(true)
+      end
+      Thread.stubs(:list).returns([@thread])
+      @inst = subject.instance
+      subject.expects(:checkin).with(@inst).never
+      subject.send :clear_stale_cached_instances!
+    end
   end
 
-  describe 'when creating an instance' do
-    it 'should create a valid instance' do
-      (@pool.send :new_instance).should eql(@adapter)
+  describe 'checkout' do
+    subject { NinjaModel::Adapters::AdapterPool.new(@spec) }
+    context 'with no current instances' do
+      it 'should checkout a new instance' do
+        subject.expects(:checkout_new_instance).returns('foo')
+        subject.send(:checkout)
+      end
+      it 'should store the instance' do
+        subject.send(:checkout)
+        subject.instances.count.should eql(1)
+      end
     end
 
-    it 'should store the instance' do
-      @pool.stubs(:new_instance).returns(@adapter)
-      @pool.instance
-      @pool.instances.should include(@adapter)
+    context 'with 1 existing instance' do
+      context 'that is already assigned' do
+        it 'should checkout a new instance' do
+          threads = []
+          subject.expects(:new_instance).twice.returns(NinjaModel::Adapters::AdapterManager.registered[subject.spec.name].new(subject.spec.config))
+          2.times do |idx|
+            threads << Thread.new do
+              subject.send(:checkout)
+            end
+          end
+          threads.each { |t| t.join }
+        end
+      end
+      context 'that is not assigned' do
+        it 'should checkout the existing instance' do
+          subject.expects(:checkout_existing_instance).returns('existing')
+          subject.instance
+          subject.release_instance
+          subject.instances.count.should eql(1)
+          subject.send(:checkout)
+        end
+      end
     end
 
-    it 'should assign the instance to the current_thread' do
-      @pool.stubs(:new_instance).returns(@adapter)
-      @pool.instance
-      @pool.stubs(:checkout).returns("new_instance")
-      @pool.instance.should_not eql("new_instance")
-      @pool.instance.should eql(@adapter)
-    end
+    context 'with the maximum number of instances' do
+      context 'with an available instance' do
+        it 'should successfully check out an instance' do
+          subject.instance
+          threads = []
+          4.times do |idx|
+            threads << Thread.new do
+              subject.instance
+            end
+          end
+          threads.each { |t| t.join }
+          subject.release_instance
+          subject.send(:checkout).should_not be_nil
+        end
+      end
 
-    it 'should reuse an unallocated instance' do
-      @pool.stubs(:current_instance_id).returns(123)
-      inst = @pool.instance
-      @pool.release_instance(123)
-      @pool.instance.should eql(inst)
-    end
-  end
+      context 'with no available instances' do
+        it 'should raise a ConnectionTimeoutError' do
+          threads = []
+          5.times do |idx|
+            threads << Thread.new do
+              subject.instance
+            end
+          end
+          threads.each { |t| t.join }
+          subject.stubs(:clear_stale_cached_instances!)
+          lambda { subject.instance }.should raise_error(NinjaModel::ConnectionTimeoutError)
+        end
+      end
 
-  it 'should properly allocate/deallocate instances' do
-    @pool.stubs(:current_instance_id).returns(123)
-    @pool.expects(:checkout).returns(@adapter)
-    @pool.expects(:checkin)
-    @pool.with_instance do |instance|
+      context 'with instances that can be reaped' do
+        it 'should return an existing instance' do
+          threads = []
+          5.times do |idx|
+            threads << Thread.new do
+              subject.instance
+            end
+          end
+          threads.each { |t| t.join }
+          subject.expects(:checkout_existing_instance).returns('foo')
+          subject.instance
+        end
+      end
     end
+
   end
+#  before(:each) do
+#    @spec = mock('AdapterSpecification') do
+#      stubs(:adapter_method).returns(:dummy_adapter)
+#      stubs(:config)
+#    end
+#
+#    @adapter = mock('AbstractAdapter') do
+#      stubs(:verify!)
+#    end
+#
+#    @pool = NinjaModel::Adapters::AdapterPool.new(@spec)
+#    @thread = mock('thread') do
+#      stubs('object_id').returns(123)
+#    end
+#    Thread.stubs(:current).returns(@thread)
+#    NinjaModel::Base.stubs(:dummy_adapter).returns(@adapter)
+#  end
+#
+#  it 'should properly respond to connected?' do
+#    @pool.connected?.should be_false
+#    @pool.instance
+#    @pool.connected?.should be_true
+#  end
+#
+#  it 'should initialize from an AdapterSpecification' do
+#    spec = mock('AdapterSpecification')
+#    NinjaModel::Adapters::AdapterPool.new(spec).spec.should eql(spec)
+#  end
+#
+#  it 'should return a valid instance_id' do
+#    (@pool.send :current_instance_id).should eql(@thread.object_id)
+#  end
+#
+#  describe 'when creating an instance' do
+#    it 'should create a valid instance' do
+#      (@pool.send :new_instance).should eql(@adapter)
+#    end
+#
+#    it 'should store the instance' do
+#      @pool.stubs(:new_instance).returns(@adapter)
+#      @pool.instance
+#      @pool.instances.should include(@adapter)
+#    end
+#
+#    it 'should assign the instance to the current_thread' do
+#      @pool.stubs(:new_instance).returns(@adapter)
+#      @pool.instance
+#      @pool.stubs(:checkout).returns("new_instance")
+#      @pool.instance.should_not eql("new_instance")
+#      @pool.instance.should eql(@adapter)
+#    end
+#
+#    it 'should reuse an unallocated instance' do
+#      @pool.stubs(:current_instance_id).returns(123)
+#      inst = @pool.instance
+#      @pool.release_instance(123)
+#      @pool.instance.should eql(inst)
+#    end
+#  end
+#
+#  it 'should properly allocate/deallocate instances' do
+#    @pool.stubs(:current_instance_id).returns(123)
+#    @pool.expects(:checkout).returns(@adapter)
+#    @pool.expects(:checkin)
+#    @pool.with_instance do |instance|
+#    end
+#  end
 end