data_objects 0.10.3 → 0.10.4.rc1

data/lib/data_objects/spec/{typecast → shared/typecast}/other_spec.rb

@@ -10,20 +10,22 @@ class ::CustomTextType
 
 end
 
-shared 'supporting other (unknown) type' do
+shared_examples_for 'supporting other (unknown) type' do
 
-  setup_test_environment
-
-  before do
-    @connection = DataObjects::Connection.new(CONFIG.uri)
-  end
-
-  after do
-    @connection.close
+  before :all do
+    setup_test_environment
   end
 
   describe 'writing an object of unknown type' do
 
+    before do
+      @connection = DataObjects::Connection.new(CONFIG.uri)
+    end
+
+    after do
+      @connection.close
+    end
+
     before do
       @command = @connection.create_command("SELECT ad_description FROM widgets WHERE ad_description = ?")
       @command.set_types(::CustomTextType)

data/lib/data_objects/spec/{typecast → shared/typecast}/range_spec.rb

@@ -1,6 +1,8 @@
-shared 'supporting Range' do
+shared_examples_for 'supporting Range' do
 
-  setup_test_environment
+  before :all do
+    setup_test_environment
+  end
 
   before do
     @connection = DataObjects::Connection.new(CONFIG.uri)

data/lib/data_objects/spec/{typecast → shared/typecast}/string_spec.rb

@@ -1,8 +1,10 @@
 # encoding: utf-8
 
-shared 'supporting String' do
+shared_examples_for 'supporting String' do
 
-  setup_test_environment
+  before :all do
+    setup_test_environment
+  end
 
   before do
     @connection = DataObjects::Connection.new(CONFIG.uri)
@@ -27,7 +29,7 @@ shared 'supporting String' do
       end
 
       it 'should return the correctly typed result' do
-        @values.first.should.be.kind_of(String)
+        @values.first.should be_kind_of(String)
       end
 
       it 'should return the correct result' do
@@ -51,7 +53,7 @@ shared 'supporting String' do
       end
 
       it 'should return the correctly typed result' do
-        @values.first.should.be.kind_of(String)
+        @values.first.should be_kind_of(String)
       end
 
       it 'should return the correct result' do
@@ -76,7 +78,7 @@ shared 'supporting String' do
 
     it 'should return the correct entry' do
       # Some of the drivers starts autoincrementation from 0 not 1
-      @values.first.should.satisfy { |val| val == 1 or val == 2 }
+      @values.first.should satisfy { |val| val == 1 or val == 2 }
     end
 
   end
@@ -94,7 +96,7 @@ shared 'supporting String' do
 
       it 'should write a multibyte String' do
         @command = @connection.create_command('INSERT INTO users (name) VALUES(?)')
-        should.not.raise(DataObjects::DataError) { @command.execute_non_query(name) }
+        expect { @command.execute_non_query(name) }.not_to raise_error(DataObjects::DataError)
       end
 
       it 'should read back the multibyte String' do
@@ -107,7 +109,7 @@ shared 'supporting String' do
 
       it 'should write a multibyte String (without query parameters)' do
         @command = @connection.create_command("INSERT INTO users (name) VALUES(#{@n}\'#{name}\')")
-        should.not.raise(DataObjects::DataError) { @command.execute_non_query }
+        expect { @command.execute_non_query }.not_to raise_error(DataObjects::DataError)
       end
 
       it 'should read back the multibyte String (without query parameters)' do
@@ -137,7 +139,7 @@ shared 'supporting String' do
 
     it 'should return the correct entry' do
       # Some of the drivers starts autoincrementation from 0 not 1
-      @values.first.should.satisfy { |val| val == 1 or val == 2 }
+      @values.first.should satisfy { |val| val == 1 or val == 2 }
     end
 
   end

data/lib/data_objects/spec/{typecast → shared/typecast}/time_spec.rb

@@ -1,6 +1,8 @@
-shared 'supporting Time' do
+shared_examples_for 'supporting Time' do
 
-  setup_test_environment
+  before :all do
+    setup_test_environment
+  end
 
   before do
     @connection = DataObjects::Connection.new(CONFIG.uri)
@@ -27,7 +29,7 @@ shared 'supporting Time' do
       end
 
       it 'should return the correctly typed result' do
-        @values.first.should.be.kind_of(Time)
+        @values.first.should be_kind_of(Time)
       end
 
       it 'should return the correct result' do
@@ -51,11 +53,11 @@ shared 'supporting Time' do
       end
 
       it 'should return a nil class' do
-        @values.first.should.be.kind_of(NilClass)
+        @values.first.should be_kind_of(NilClass)
       end
 
       it 'should return nil' do
-        @values.first.should.be.nil
+        @values.first.should be_nil
       end
 
     end
@@ -76,9 +78,45 @@ shared 'supporting Time' do
 
     it 'should return the correct entry' do
        #Some of the drivers starts autoincrementation from 0 not 1
-       @values.first.should.satisfy { |val| val == 1 or val == 0 }
+       @values.first.should satisfy { |val| val == 1 or val == 0 }
     end
 
   end
 
 end
+
+shared_examples_for 'supporting sub second Time' do
+
+  before :all do
+    setup_test_environment
+  end
+
+  before do
+    @connection = DataObjects::Connection.new(CONFIG.uri)
+    @connection.create_command(<<-EOF).execute_non_query(Time.parse('2010-12-15 14:32:08.49377-08'))
+      update widgets set release_timestamp = ? where id = 1
+    EOF
+    @connection.create_command(<<-EOF).execute_non_query(Time.parse('2010-12-15 14:32:28.942694-08'))
+      update widgets set release_timestamp = ? where id = 2
+    EOF
+
+    @command = @connection.create_command("SELECT release_timestamp FROM widgets WHERE id < ? order by id")
+    @command.set_types(Time)
+    @reader = @command.execute_reader(3)
+    @reader.next!
+    @values = @reader.values
+  end
+
+  after do
+    @connection.close
+  end
+
+  it 'should handle variable subsecond lengths properly' do
+    @values.first.should == Time.at(1292452328, 493770)
+
+    @reader.next!
+    @values = @reader.values
+    @values.first.should == Time.at(1292452348, 942694)
+  end
+
+end

data/lib/data_objects/transaction.rb

@@ -72,6 +72,15 @@ module DataObjects
       DataObjects::SavePoint.new(uri, connection)
     end
 
+    # SavePoints can only occur in the context of a Transaction, thus they
+    # re-use TXN's connection (which was acquired from the connection pool
+    # legitimately via DO::Connection.new).  We no-op #close in SP because
+    # calling DO::Connection#close will release the connection back into the
+    # pool (before the top-level Transaction might be done with it).
+    def close
+        # no-op
+    end
+
     def begin
       run %{SAVEPOINT "#{@id}"}
     end

data/lib/data_objects/uri.rb

@@ -13,18 +13,75 @@ module DataObjects
   # path:: The name or path to the database
   # query:: Parameters for the connection, for example encoding=utf8
   # fragment:: Not currently known to be in use, but available to the adapters
-  class URI < Struct.new(:scheme, :user, :password, :host, :port, :path, :query, :fragment)
+  class URI
+    attr_reader :scheme, :subscheme, :user, :password, :host, :port, :path, :query, :fragment
+
     # Make a DataObjects::URI object by parsing a string. Simply delegates to Addressable::URI::parse.
     def self.parse(uri)
       return uri if uri.kind_of?(self)
-      uri = Addressable::URI::parse(uri) unless uri.kind_of?(Addressable::URI)
-      self.new(uri.scheme, uri.user, uri.password, uri.host, uri.port, uri.path, uri.query_values, uri.fragment)
+
+      if uri.kind_of?(Addressable::URI)
+        scheme = uri.scheme
+      else
+        if uri[0,4] == 'jdbc'
+          scheme    = uri[0,4]
+          uri       = Addressable::URI::parse(uri[5, uri.length])
+          subscheme = uri.scheme
+        else
+          uri       = Addressable::URI::parse(uri)
+          scheme    = uri.scheme
+          subscheme = nil
+        end
+      end
+
+      self.new(
+                :scheme     => scheme,
+                :subscheme  => subscheme,
+                :user       => uri.user,
+                :password   => uri.password,
+                :host       => uri.host,
+                :port       => uri.port,
+                :path       => uri.path,
+                :query      => uri.query_values,
+                :fragment   => uri.fragment,
+                :relative   => !!uri.to_s.index('//') # basic (naive) check for relativity / opaqueness
+              )
+    end
+
+    def initialize(*args)
+      if (component = args.first).kind_of?(Hash)
+        @scheme     = component[:scheme]
+        @subscheme  = component[:subscheme]
+        @user       = component[:user]
+        @password   = component[:password]
+        @host       = component[:host]
+        @port       = component[:port]
+        @path       = component[:path]
+        @query      = component[:query]
+        @fragment   = component[:fragment]
+        @relative   = component[:relative]
+      elsif args.size > 1
+        warn "DataObjects::URI.new with arguments is deprecated, use a Hash of URI components (#{caller.first})"
+        @scheme, @user, @password, @host, @port, @path, @query, @fragment = *args
+      else
+        raise ArgumentError, "argument should be a Hash of URI components, was: #{args.inspect}"
+      end
+    end
+
+    def opaque?
+      !@relative
+    end
+
+    def relative?
+      @relative
     end
 
     # Display this URI object as a string
     def to_s
       string = ""
-      string << "#{scheme}://"   if scheme
+      string << "#{scheme}:"     if scheme
+      string << "#{subscheme}:"  if subscheme
+      string << '//'             if relative?
       if user
         string << "#{user}"
         string << ":#{password}" if password
@@ -51,5 +108,6 @@ module DataObjects
     def hash
       to_s.hash
     end
+
   end
 end

data/lib/data_objects/version.rb

@@ -1,3 +1,3 @@
 module DataObjects
-  VERSION = '0.10.3'
+  VERSION = '0.10.4.rc1'
 end

data/spec/command_spec.rb

@@ -12,13 +12,13 @@ describe DataObjects::Command do
 
   %w{connection execute_non_query execute_reader set_types}.each do |meth|
     it "should respond to ##{meth}" do
-      @command.should.respond_to(meth.intern)
+      @command.should respond_to(meth.intern)
     end
   end
 
   %w{execute_non_query execute_reader set_types}.each do |meth|
     it "should raise NotImplementedError on ##{meth}" do
-      should.raise(NotImplementedError) { @command.send(meth.intern, nil) }
+      lambda { @command.send(meth.intern, nil) }.should raise_error(NotImplementedError)
     end
   end
 

data/spec/connection_spec.rb

@@ -1,41 +1,61 @@
 require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+require 'stringio'
 
 describe DataObjects::Connection do
-  before do
-    @connection = DataObjects::Connection.new('mock://localhost')
-  end
+  subject { connection }
 
-  after do
-    @connection.release
-  end
+  let(:connection) { described_class.new(uri) }
 
-  %w{dispose create_command}.each do |meth|
-    it "should respond to ##{meth}" do
-      @connection.should.respond_to(meth.intern)
-    end
-  end
+  after { connection.close }
+
+  context 'should define a standard API' do
+    let(:uri)   { 'mock://localhost'      }
+
+    it { should respond_to(:dispose)        }
+    it { should respond_to(:create_command) }
 
-  it "should have #to_s that returns the connection uri string" do
-    @connection.to_s.should == 'mock://localhost'
+    its(:to_s)  { should == 'mock://localhost' }
   end
 
-  describe "initialization" do
+  describe 'initialization' do
 
-    it "should accept a connection uri as a Addressable::URI" do
-      c = DataObjects::Connection.new(Addressable::URI::parse('mock://localhost/database'))
-      # relying on the fact that mock connection sets @uri
-      c.to_s.should == 'mock://localhost/database'
+    context 'with a connection uri as a Addressable::URI' do
+      let(:uri)  { Addressable::URI::parse('mock://localhost/database') }
+
+      it { should be_kind_of(DataObjects::Mock::Connection) }
+      it { should be_kind_of(DataObjects::Pooling)          }
+
+      its(:to_s) { should == 'mock://localhost/database' }
     end
 
-    it "should return the Connection specified by the scheme" do
-      c = DataObjects::Connection.new(Addressable::URI.parse('mock://localhost/database'))
-      c.should.be.kind_of(DataObjects::Mock::Connection)
-      c.should.be.kind_of(DataObjects::Pooling)
+    [
+      'java:comp/env/jdbc/DataSource?driver=mock2',
+      Addressable::URI.parse('java:comp/env/jdbc/DataSource?driver=mock2')
+    ].each do |jndi_url|
+    context 'should return the Connection specified by the scheme without pooling' do
+      let(:uri)  { jndi_url }
+
+      it { should be_kind_of(DataObjects::Mock2::Connection) }
+      it { should_not be_kind_of(DataObjects::Pooling)       }
     end
+  end
 
-    it "should return the Connection specified by the scheme without pooling" do
-      c = DataObjects::Connection.new(Addressable::URI.parse('java://jdbc/database?scheme=mock2'))
-      c.should.not.be.kind_of(DataObjects::Pooling)
+    %w(
+      jdbc:mock:memory::
+      jdbc:mock://host/database
+      jdbc:mock://host:6969/database
+      jdbc:mock:thin:host:database
+      jdbc:mock:thin:@host.domain.com:6969:database
+      jdbc:mock://server:6969/database;property=value;
+      jdbc:mock://[1111:2222:3333:4444:5555:6666:7777:8888]/database
+    ).each do |jdbc_url|
+      context "with JDBC URL '#{jdbc_url}'" do
+        let(:uri)  { jdbc_url }
+
+        it { should be_kind_of(DataObjects::Mock::Connection) }
+      end
     end
+
   end
+
 end

data/spec/pooling_spec.rb

@@ -64,7 +64,7 @@ describe "DataObjects::Pooling" do
     end
   end
 
-  after do
+  after :each do
     DataObjects::Pooling.lock.synchronize do
       DataObjects::Pooling.pools.each do |pool|
         pool.lock.synchronize do
@@ -95,24 +95,24 @@ describe "DataObjects::Pooling" do
   it "should track the initialized pools" do
     bob = Person.new('Bob') # Ensure the pool is "primed"
     bob.name.should == 'Bob'
-    bob.instance_variable_get(:@__pool).should.not.be.nil
+    bob.instance_variable_get(:@__pool).should_not be_nil
     Person.__pools.size.should == 1
     bob.release
     Person.__pools.size.should == 1
 
-    DataObjects::Pooling::pools.should.not.be.empty
+    DataObjects::Pooling::pools.should_not be_empty
 
     sleep(1.2)
 
     # NOTE: This assertion is commented out, as our MockConnection objects are
     #       currently in the pool.
-    DataObjects::Pooling::pools.should.be.empty
-    bob.name.should == nil
+    # DataObjects::Pooling::pools.should be_empty
+    bob.name.should be_nil
   end
 
   it "should allow you to overwrite Class#new" do
     bob = Overwriter.new('Bob')
-    bob.should.be.overwritten
+    bob.should be_overwritten
     bob.release
   end
 
@@ -127,7 +127,7 @@ describe "DataObjects::Pooling" do
       bob = Person.new('Bob')
       t1.join
       bob.release
-    end.should.not.raise(DataObjects::Pooling::InvalidResourceError)
+    end.should_not raise_error(DataObjects::Pooling::InvalidResourceError)
   end
 
   it "should allow you to flush a pool" do
@@ -141,7 +141,7 @@ describe "DataObjects::Pooling" do
     Overwriter.__pools[['Bob']].flush!
     Overwriter.__pools[['Bob']].size.should == 0
 
-    bob.name.should.be.nil
+    bob.name.should be_nil
   end
 
   it "should wake up the scavenger thread when exiting" do
@@ -149,7 +149,7 @@ describe "DataObjects::Pooling" do
     bob.release
     DataObjects.exiting = true
     sleep(0.1)
-    DataObjects::Pooling.scavenger?.should.be.false
+    DataObjects::Pooling.scavenger?.should be_false
   end
 
   it "should be able to detach an instance from the pool" do