ninja-model 0.8.1 → 0.9.0

data/spec/ninja_model/adapters/adapter_pool_spec.rb

@@ -1,230 +0,0 @@
-require 'spec_helper'
-
-describe NinjaModel::Adapters::AdapterPool do
-  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) }
-
-  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
-
-  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
-  end
-
-  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
-
-  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
-
-  describe 'clear_stale_cached_instances!' do
-    let(:thread) { mock('Thread') }
-    before { Thread.stubs(:list).returns([thread]) }
-    it 'should reap any instances for dead threads' do
-      thread.stubs(:alive?).returns(false)
-      inst = subject.instance
-      subject.instance_variable_set("@assigned_instances".to_sym, {thread.object_id => inst})
-      subject.expects(:checkin).with(inst)
-      subject.send :clear_stale_cached_instances!
-    end
-    it 'should not reap instances for live threads' do
-      thread.stubs(:alive?).returns(true)
-      inst = subject.instance
-      subject.instance_variable_set("@assigned_instances".to_sym, {thread.object_id => inst})
-      subject.expects(:checkin).with(inst).never
-      subject.send :clear_stale_cached_instances!
-    end
-  end
-
-  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
-
-    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
-
-    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
-
-      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
-
-      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

data/spec/ninja_model/adapters_spec.rb

@@ -1,85 +0,0 @@
-require 'spec_helper'
-
-describe NinjaModel::Adapters do
-  class DummyAdapter < NinjaModel::Adapters::AbstractAdapter; end
-  class SmarterAdapter < NinjaModel::Adapters::AbstractAdapter; end
-  before {
-    NinjaModel::Base.register_adapter(:dummy, DummyAdapter)
-    NinjaModel::Base.register_adapter(:smarter, SmarterAdapter)
-  }
-  subject { Class.new(NinjaModel::Base) }
-  it { should respond_to(:register_adapter) }
-  it { should respond_to(:set_adapter) }
-
-  describe 'adapter' do
-    before { @klass = Class.new(NinjaModel::Base) }
-    subject { @klass.new }
-    it 'should call retrieve_adapter' do
-      @klass.expects(:retrieve_adapter)
-      subject.adapter
-    end
-  end
-
-  describe 'register_adapter' do
-    it 'should register with the adapter manager' do
-      subject.adapter_manager.class.expects(:register_adapter_class).with(:dummy, DummyAdapter)
-      subject.register_adapter(:dummy, DummyAdapter)
-    end
-  end
-
-  describe 'set_adapter' do
-    before {
-      @configuration = mock('Configuration') do
-        stubs(:specs).returns({'development' => {:adapter => :dummy}})
-      end
-      NinjaModel.stubs(:configuration).returns(@configuration)
-      @klass = Class.new(NinjaModel::Base)
-    }
-    subject { @klass }
-    context 'when nil is passed' do
-      it 'should return a DummyAdapter if Rails is available' do
-        @rails = Object.const_set('Rails', Class.new(Object))
-        @rails.stubs(:env).returns('development')
-        subject.set_adapter.spec.name.should eql(:dummy)
-        Object.send(:remove_const, :Rails)
-      end
-      it 'should raise AdapterNotSpecified is Rails is not available' do
-        lambda { subject.set_adapter }.should raise_error(NinjaModel::Adapters::AdapterNotSpecified)
-      end
-    end
-    it 'should return a DummyAdapter pool when "development" is passed' do
-      subject.set_adapter('development').spec.name.should eql(:dummy)
-    end
-    it 'should return a DummyAdapter pool when a dummy specification is passed' do
-      subject.set_adapter(:adapter => :dummy).spec.name.should eql(:dummy)
-    end
-    it 'should return a SmarterAdapter pool when a smarter specification is passed' do
-      subject.set_adapter(:adapter => :smarter).spec.name.should eql(:smarter)
-    end
-    it 'should raise AdapterNotSpecified if the configuration doesn\'t specify an adapter' do
-      lambda { subject.set_adapter({}) }.should raise_error(NinjaModel::Adapters::AdapterNotSpecified)
-    end
-    it 'should raise InvalidAdapter for an invalid adapter name' do
-      lambda { subject.set_adapter(:adapter => :bogus) }.should raise_error(NinjaModel::Adapters::InvalidAdapter)
-    end
-    it 'should raise InvalidSpecification for an invalid Rails.env' do
-      lambda { subject.set_adapter('foobar') }.should raise_error(NinjaModel::Adapters::InvalidSpecification)
-    end
-  end
-
-  describe 'retrieve_adapter' do
-    before { @klass = Class.new(NinjaModel::Base) }
-    it 'should call retrieve_adapter on the manager' do
-      @klass.adapter_manager.expects(:retrieve_adapter).with(@klass)
-      @klass.retrieve_adapter
-    end
-  end
-
-  describe 'shutdown_adapter' do
-    before { @klass = Class.new(NinjaModel::Base) }
-    it 'should call remove_adapter on the manager' do
-      @klass.adapter_manager.expects(:remove_adapter).with(@klass)
-      @klass.shutdown_adapter
-    end
-  end
-end