data_objects 0.2.0 → 0.9.2

data/spec/reader_spec.rb

@@ -0,0 +1,18 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+describe DataObjects::Reader do
+
+  it "should define a standard API" do
+    connection = DataObjects::Connection.new('mock://localhost')
+
+    command = connection.create_command("SELECT * FROM example")
+
+    reader = command.execute_reader
+
+    reader.should respond_to(:close)
+    reader.should respond_to(:next!)
+    reader.should respond_to(:values)
+    reader.should respond_to(:fields)
+  end
+
+end

data/spec/result_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+describe DataObjects::Result do
+
+  it "should define a standard API" do
+    connection = DataObjects::Connection.new('mock://localhost')
+
+    command = connection.create_command("SELECT * FROM example")
+
+    result = command.execute_non_query
+
+    # In case the driver needs to access the command or connection to load additional data.
+    result.instance_variables.should include('@command')
+
+    # Affected Rows:
+    result.should respond_to(:to_i)
+    result.to_i.should == 0
+
+    # The id of the inserted row.
+    result.should respond_to(:insert_id)
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+require 'spec'
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'data_objects'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'do_mock'))

data/spec/support/pooling_spec.rb

@@ -0,0 +1,374 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'data_objects', 'support', 'pooling')
+require 'timeout'
+
+# This implements dispose
+# and works perfectly with
+# pooling.
+class DisposableResource
+  include Object::Pooling
+  attr_reader :name
+
+  def initialize(name = "")
+    @name = name
+  end
+
+  def dispose
+    @name = nil
+  end
+end
+
+# This baby causes exceptions
+# to be raised when you use
+# it with pooling.
+class UndisposableResource
+end
+
+describe Object::Pooling::ResourcePool do
+  before :each do
+    @pool = Object::Pooling::ResourcePool.new(7, DisposableResource, :expiration_period => 50)
+  end
+
+  it "responds to flush!" do
+    @pool.should respond_to(:flush!)
+  end
+
+  it "responds to aquire" do
+    @pool.should respond_to(:aquire)
+  end
+
+  it "responds to release" do
+    @pool.should respond_to(:release)
+  end
+
+  it "responds to :available?" do
+    @pool.should respond_to(:available?)
+  end
+
+  it "has a size limit" do
+    @pool.size_limit.should == 7
+  end
+
+  it "has initial size of zero" do
+    @pool.size.should == 0
+  end
+
+  it "has a set of reserved resources" do
+    @pool.instance_variable_get("@reserved").should be_empty
+  end
+
+  it "has a set of available resources" do
+    @pool.instance_variable_get("@available").should be_empty
+  end
+
+  it "knows class of resources (objects) it works with" do
+    @pool.class_of_resources.should == DisposableResource
+  end
+
+  it "raises exception when given anything but class for resources class" do
+    lambda {
+      @pool = Object::Pooling::ResourcePool.new(7, "Hooray!", {})
+    }.should raise_error(ArgumentError, /class/)
+  end
+
+  it "requires class of resources (objects) it works with to have a dispose instance method" do
+    lambda {
+      @pool = Object::Pooling::ResourcePool.new(3, UndisposableResource, {})
+    }.should raise_error(ArgumentError, /dispose/)
+  end
+
+  it "may take initialization arguments" do
+    @pool = Object::Pooling::ResourcePool.new(7, DisposableResource, { :initialization_args => ["paper"] })
+    @pool.instance_variable_get("@initialization_args").should == ["paper"]
+  end
+
+  it "may take expiration period option" do
+    @pool = Object::Pooling::ResourcePool.new(7, DisposableResource, { :expiration_period => 100 })
+    @pool.expiration_period.should == 100
+  end
+
+  it "has default expiration period of one minute" do
+    @pool = Object::Pooling::ResourcePool.new(7, DisposableResource, {})
+    @pool.expiration_period.should == 60
+  end
+
+  it "spawns a thread to dispose objects haven't been used for a while" do
+    @pool = Object::Pooling::ResourcePool.new(7, DisposableResource, {})
+    @pool.instance_variable_get("@pool_expiration_thread").should be_an_instance_of(Thread)
+  end
+end
+
+
+
+describe "Aquire from contant size pool" do
+  before :each do
+    DisposableResource.initialize_pool(2)
+  end
+
+  after :each do
+    DisposableResource.instance_variable_set("@__pool", nil)
+  end
+
+  it "increased size of the pool" do
+    @time = DisposableResource.pool.aquire
+    DisposableResource.pool.size.should == 1
+  end
+
+  it "places initialized instance in the reserved set" do
+    @time = DisposableResource.pool.aquire
+    DisposableResource.pool.instance_variable_get("@reserved").size.should == 1
+  end
+
+  it "raises an exception when pool size limit is hit" do
+    @t1 = DisposableResource.pool.aquire
+    @t2 = DisposableResource.pool.aquire
+
+    lambda { DisposableResource.pool.aquire }.should raise_error(RuntimeError)
+  end
+
+  it "returns last released resource" do
+    @t1 = DisposableResource.pool.aquire
+    @t2 = DisposableResource.pool.aquire
+    DisposableResource.pool.release(@t1)
+
+    DisposableResource.pool.aquire.should == @t1
+  end
+
+  it "really truly returns last released resource" do
+    @t1 = DisposableResource.pool.aquire
+    DisposableResource.pool.release(@t1)
+
+    @t2 = DisposableResource.pool.aquire
+    DisposableResource.pool.release(@t2)
+
+    @t3 = DisposableResource.pool.aquire
+    DisposableResource.pool.release(@t3)
+
+    DisposableResource.pool.aquire.should == @t1
+    @t1.should == @t3
+  end
+
+  it "sets allocation timestamp on resource instance" do
+    @t1 = DisposableResource.new
+    @t1.instance_variable_get("@__pool_aquire_timestamp").should be_close(Time.now, 2)
+  end
+end
+
+
+
+describe "Releasing from contant size pool" do
+  before :each do
+    DisposableResource.initialize_pool(2)
+  end
+
+  after :each do
+    DisposableResource.instance_variable_set("@__pool", nil)
+  end
+
+  it "decreases size of the pool" do
+    @t1 = DisposableResource.pool.aquire
+    @t2 = DisposableResource.pool.aquire
+    DisposableResource.pool.release(@t1)
+
+    DisposableResource.pool.size.should == 1
+  end
+
+  it "raises an exception on attempt to releases object not in pool" do
+    @t1 = DisposableResource.new
+    @t2 = Set.new
+
+    DisposableResource.pool.release(@t1)
+    lambda { DisposableResource.pool.release(@t2) }.should raise_error(RuntimeError)
+  end
+
+  it "disposes released object" do
+    @t1 = DisposableResource.pool.aquire
+
+    @t1.should_receive(:dispose)
+    DisposableResource.pool.release(@t1)
+  end
+
+  it "removes released object from reserved set" do
+    @t1 = DisposableResource.pool.aquire
+
+    lambda {
+      DisposableResource.pool.release(@t1)
+    }.should change(DisposableResource.pool.instance_variable_get("@reserved"), :size).by(-1)
+  end
+
+  it "returns released object back to available set" do
+    @t1 = DisposableResource.pool.aquire
+
+    lambda {
+      DisposableResource.pool.release(@t1)
+    }.should change(DisposableResource.pool.instance_variable_get("@available"), :size).by(1)
+  end
+
+  it "updates aquire timestamp on already allocated resource instance" do
+    # aquire it once
+    @t1 = DisposableResource.new
+    # wait a bit
+    sleep 3
+
+    # check old timestamp
+    @t1.instance_variable_get("@__pool_aquire_timestamp").should be_close(Time.now, 4)
+
+    # re-aquire
+    DisposableResource.pool.release(@t1)
+    @t1 = DisposableResource.new
+    # see timestamp is updated
+    @t1.instance_variable_get("@__pool_aquire_timestamp").should be_close(Time.now, 2)
+  end
+end
+
+
+
+describe Object::Pooling::ResourcePool, "#available?" do
+  before :each do
+    DisposableResource.initialize_pool(2)
+    DisposableResource.new
+  end
+
+  after :each do
+    DisposableResource.instance_variable_set("@__pool", nil)
+  end
+
+  it "returns true when pool has available instances" do
+    DisposableResource.pool.should be_available
+  end
+
+  it "returns false when pool is exhausted" do
+    # aquires the last available resource
+    DisposableResource.new
+    DisposableResource.pool.should_not be_available
+  end
+end
+
+
+
+describe "Flushing of contant size pool" do
+  before :each do
+    DisposableResource.initialize_pool(2)
+
+    @t1 = DisposableResource.new
+    @t2 = DisposableResource.new
+
+    # sanity check
+    DisposableResource.pool.instance_variable_get("@reserved").should_not be_empty
+  end
+
+  after :each do
+    DisposableResource.instance_variable_set("@__pool", nil)
+  end
+
+  it "disposes all pooled objects" do
+    [@t1, @t2].each { |instance| instance.should_receive(:dispose) }
+
+    DisposableResource.pool.flush!
+  end
+
+  it "empties reserved set" do
+    DisposableResource.pool.flush!
+
+    DisposableResource.pool.instance_variable_get("@reserved").should be_empty
+  end
+
+  it "returns all instances to available set" do
+    DisposableResource.pool.flush!
+
+    DisposableResource.pool.instance_variable_get("@available").size.should == 2
+  end
+end
+
+
+
+describe "Poolable resource class" do
+  before :each do
+    DisposableResource.initialize_pool(3, :initialization_args => ["paper"])
+  end
+
+  after :each do
+    DisposableResource.instance_variable_set("@__pool", nil)
+  end
+
+  it "aquires new instances from pool" do
+    @instance_one = DisposableResource.new
+
+    DisposableResource.pool.aquired?(@instance_one).should be(true)
+  end
+
+  it "flushed existing pool on re-initialization" do
+    DisposableResource.pool.should_receive(:flush!)
+    DisposableResource.initialize_pool(5)
+  end
+
+  it "replaces pool on re-initialization" do
+    DisposableResource.initialize_pool(5)
+    DisposableResource.pool.size_limit.should == 5
+  end
+
+  it "passes initialization parameters to newly created resource instances" do
+    DisposableResource.new.name.should == "paper"
+  end
+end
+
+
+
+describe "Pooled object", "on initialization" do
+  after :each do
+    DisposableResource.instance_variable_set("@__pool", nil)
+  end
+
+  it "does not flush pool" do
+    # using pool here initializes the pool first
+    # so we use instance variable directly
+    DisposableResource.instance_variable_get("@__pool").should_not_receive(:flush!)
+    DisposableResource.initialize_pool(23)
+  end
+
+  it "flushes pool first when re-initialized" do
+    DisposableResource.initialize_pool(5)
+    DisposableResource.pool.should_receive(:flush!)
+    DisposableResource.initialize_pool(23)
+  end
+end
+
+
+
+describe Object::Pooling::ResourcePool, "#time_to_dispose?" do
+  before :each do
+    DisposableResource.initialize_pool(7, :expiration_period => 2)
+  end
+
+  after :each do
+    DisposableResource.instance_variable_set("@__pool", nil)
+  end
+
+  it "returns true when object's last aquisition time is greater than limit" do
+    @t1 = DisposableResource.new
+    DisposableResource.pool.time_to_release?(@t1).should be(false)
+
+    sleep 3
+    DisposableResource.pool.time_to_release?(@t1).should be(true)
+  end
+end
+
+
+
+describe Object::Pooling::ResourcePool, "#dispose_outdated" do
+  before :each do
+    DisposableResource.initialize_pool(7, :expiration_period => 2)
+  end
+
+  after :each do
+    DisposableResource.instance_variable_set("@__pool", nil)
+  end
+
+  it "releases and thus disposes outdated instances" do
+    @t1 = DisposableResource.new
+    DisposableResource.pool.should_receive(:time_to_release?).with(@t1).and_return(true)
+    DisposableResource.pool.should_receive(:release).with(@t1)
+
+    DisposableResource.pool.release_outdated
+  end
+end

data/spec/transaction_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+describe DataObjects::Transaction do
+
+  before :each do
+    @connection = mock("connection")
+    DataObjects::Connection.should_receive(:new).with("mock://mock/mock").once.and_return(@connection)
+    @transaction = DataObjects::Transaction.new("mock://mock/mock")
+  end
+
+  it "should have a HOST constant" do
+    DataObjects::Transaction::HOST.should_not == nil?
+  end
+
+  describe "#initialize" do
+    it "should provide a connection" do
+      @transaction.connection.should == @connection
+    end
+    it "should provide an id" do
+      @transaction.id.should_not == nil
+    end
+    it "should provide a unique id" do
+      DataObjects::Connection.should_receive(:new).with("mock://mock/mock2").once.and_return(@connection)
+      @transaction.id.should_not == DataObjects::Transaction.new("mock://mock/mock2").id
+    end
+  end
+  describe "#close" do
+    it "should close its connection" do
+      @connection.should_receive(:close).once
+      @transaction.close
+    end
+  end
+  [:begin, :commit, :rollback, :rollback_prepared, :prepare].each do |meth|
+    it "should raise NotImplementedError on #{meth}" do
+      lambda do @transaction.send(meth) end.should raise_error(NotImplementedError)
+    end
+  end
+
+end