data_objects 0.10.3 → 0.10.4.rc1

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2007 - 2010 Yehuda Katz, Dirkjan Bussink
+Copyright (c) 2007 - 2011 Yehuda Katz, Dirkjan Bussink
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.markdown

@@ -1,4 +1,4 @@
-# do_derby
+# data_objects
 
 * <http://dataobjects.info>
 

data/Rakefile

@@ -1,5 +1,7 @@
 require 'pathname'
-require 'rubygems'
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
 require 'rake'
 require 'rake/clean'
 
@@ -14,36 +16,8 @@ SUDO     = WINDOWS ? '' : ('sudo' unless ENV['SUDOLESS'])
 
 CLEAN.include(%w[ pkg/ **/*.rbc ])
 
-begin
-  gem 'jeweler', '~> 1.4'
-  require 'jeweler'
-
-  Jeweler::Tasks.new do |gem|
-    gem.name        = 'data_objects'
-    gem.version     = DataObjects::VERSION
-    gem.summary     = 'DataObjects basic API and shared driver specifications'
-    gem.description = 'Provide a standard and simplified API for communicating with RDBMS from Ruby'
-    gem.platform    = Gem::Platform::RUBY
-    gem.files       = FileList["lib/**/*.rb", "spec/**/*.rb", "tasks/**/*.rake",
-                        "LICENSE", "Rakefile", "*.{markdown,rdoc,txt,yml}"]
-    gem.test_files  = FileList['spec/**/*.rb']
-
-    gem.add_dependency 'addressable', '~>2.1'
-
-    gem.add_development_dependency 'bacon', '~>1.1'
-    gem.add_development_dependency 'mocha', '~>0.9'
-    gem.add_development_dependency 'yard',  '~>0.5'
-
-    gem.rubyforge_project = 'dorb'
-
-    gem.authors     = ['Dirkjan Bussink']
-    gem.email       = 'd.bussink@gmail.com'
-    gem.homepage    = 'http://github.com/datamapper/do'
-  end
 
-  Jeweler::GemcutterTasks.new
+Rake::Task['build'].clear_actions if Rake::Task.task_defined?('build')
+task :build => [ :java, :gem ]
 
-  FileList['tasks/**/*.rake'].each { |task| import task }
-rescue LoadError
-  puts 'Jeweler (or a dependency) not available. Install it with: gem install jeweler'
-end
+FileList['tasks/**/*.rake'].each { |task| import task }

data/lib/data_objects/connection.rb

@@ -17,13 +17,16 @@ module DataObjects
       case uri.scheme.to_sym
       when :java
         warn 'JNDI URLs (connection strings) are only for use with JRuby' unless RUBY_PLATFORM =~ /java/
-        driver_name = uri.query.delete("scheme")
+
+        driver   = uri.query.delete('scheme')
+        driver   = uri.query.delete('driver')
+
         conn_uri = uri.to_s.gsub(/\?$/, '')
       when :jdbc
         warn 'JDBC URLs (connection strings) are only for use with JRuby' unless RUBY_PLATFORM =~ /java/
 
-        path = uri.path.sub(/jdbc:/, '')
-        driver_name = if path.split(':').first == 'sqlite'
+        path = uri.subscheme
+        driver = if path.split(':').first == 'sqlite'
           'sqlite3'
         elsif path.split(':').first == 'postgresql'
           'postgres'
@@ -38,15 +41,15 @@ module DataObjects
                          # java.sql.DriverManager.getConnection to throw a
                          # 'No suitable driver found for...' exception.
       else
-        driver_name = uri.scheme
+        driver   = uri.scheme
         conn_uri = uri
       end
 
       # Exceptions to how a driver class is determined for a given URI
-      driver_class = if driver_name == 'sqlserver'
+      driver_class = if driver == 'sqlserver'
         'SqlServer'
       else
-        driver_name.capitalize
+        driver.capitalize
       end
 
       clazz = DataObjects.const_get(driver_class)::Connection

data/lib/data_objects/pooling.rb

@@ -197,7 +197,7 @@ module DataObjects
         lock.synchronize do
           instance.instance_variable_set(:@__allocated_in_pool, Time.now)
           @used.delete(instance.object_id)
-          @available.push(instance)
+          @available.push(instance) unless @available.include?(instance)
           wait.signal
         end
         nil

data/lib/data_objects/spec/lib/pending_helpers.rb

@@ -0,0 +1,11 @@
+module DataObjects::Spec
+  module PendingHelpers
+    def pending_if(message, boolean)
+      if boolean
+        pending(message) { yield }
+      else
+        yield
+      end
+    end
+  end
+end

data/lib/data_objects/spec/setup.rb

@@ -0,0 +1,5 @@
+RSpec::Matchers.define :be_array_case_insensitively_equal_to do |attribute|
+  match do |model|
+    model.map { |f| f.downcase } == attribute
+  end
+end

data/lib/data_objects/spec/{command_spec.rb → shared/command_spec.rb}

@@ -1,8 +1,10 @@
 WINDOWS = Gem.win_platform? || (JRUBY && ENV_JAVA['os.name'] =~ /windows/i)
 
-shared 'a Command' do
+shared_examples_for 'a Command' do
 
-  setup_test_environment
+  before :all do
+    setup_test_environment
+  end
 
   before do
     @connection = DataObjects::Connection.new(CONFIG.uri)
@@ -14,9 +16,9 @@ shared 'a Command' do
     @connection.close
   end
 
-  it 'should be a kind of Command' do @command.should.be.kind_of(DataObjects::Command) end
+  it { @command.should be_kind_of(DataObjects::Command) }
 
-  it 'should respond to #execute_non_query' do @command.should.respond_to(:execute_non_query) end
+  it { @command.should respond_to(:execute_non_query) }
 
   describe 'execute_non_query' do
 
@@ -27,17 +29,17 @@ shared 'a Command' do
       end
 
       it 'should raise an error on an invalid query' do
-        should.raise(DataObjects::SQLError) { @invalid_command.execute_non_query }
+        expect { @invalid_command.execute_non_query }.to raise_error(DataObjects::SQLError)
       end
 
       it 'should raise an error with too few binding parameters' do
-        lambda { @command.execute_non_query("Too", "Many") }.should.raise(ArgumentError).
-          message.should.match(/Binding mismatch: 2 for 1/)
+        expect { @command.execute_non_query("Too", "Many") }.to raise_error(ArgumentError,
+          /Binding mismatch: 2 for 1/)
       end
 
       it 'should raise an error with too many binding parameters' do
-        lambda { @command.execute_non_query }.should.raise(ArgumentError).
-          message.should.match(/Binding mismatch: 0 for 1/)
+        expect { @command.execute_non_query }.to raise_error(ArgumentError,
+          /Binding mismatch: 0 for 1/)
       end
 
     end
@@ -45,7 +47,7 @@ shared 'a Command' do
     describe 'with a valid statement' do
 
       it 'should not raise an error with an explicit nil as parameter' do
-        should.not.raise(ArgumentError) { @command.execute_non_query(nil) }
+        expect { @command.execute_non_query(nil) }.not_to raise_error(ArgumentError)
       end
 
     end
@@ -57,14 +59,14 @@ shared 'a Command' do
       end
 
       it 'should not raise an error' do
-        should.not.raise(ArgumentError) { @command_with_quotes.execute_non_query }
+        expect { @command_with_quotes.execute_non_query }.not_to raise_error(ArgumentError)
       end
 
     end
 
   end
 
-  it 'should respond to #execute_reader' do @command.should.respond_to(:execute_reader) end
+  it { @command.should respond_to(:execute_reader) }
 
   describe 'execute_reader' do
 
@@ -76,17 +78,17 @@ shared 'a Command' do
 
       it 'should raise an error on an invalid query' do
         # FIXME JRuby (and MRI): Should this be an ArgumentError or DataObjects::SQLError?
-        should.raise(ArgumentError, DataObjects::SQLError) { @invalid_reader.execute_reader }
+        expect { @invalid_reader.execute_reader }.to raise_error # (ArgumentError, DataObjects::SQLError)
       end
 
       it 'should raise an error with too few binding parameters' do
-        lambda { @reader.execute_reader("Too", "Many") }.should.raise(ArgumentError).
-          message.should.match(/Binding mismatch: 2 for 1/)
+        expect { @reader.execute_reader("Too", "Many") }.to raise_error(ArgumentError,
+          /Binding mismatch: 2 for 1/)
       end
 
       it 'should raise an error with too many binding parameters' do
-        lambda { @reader.execute_reader }.should.raise(ArgumentError).
-          message.should.match(/Binding mismatch: 0 for 1/)
+        expect { @reader.execute_reader }.to raise_error(ArgumentError,
+          /Binding mismatch: 0 for 1/)
       end
 
     end
@@ -94,7 +96,7 @@ shared 'a Command' do
     describe 'with a valid reader' do
 
       it 'should not raise an error with an explicit nil as parameter' do
-        should.not.raise(ArgumentError) { @reader.execute_reader(nil) }
+        expect { @reader.execute_reader(nil) }.not_to raise_error(ArgumentError)
       end
 
     end
@@ -106,7 +108,7 @@ shared 'a Command' do
       end
 
       it 'should not raise an error' do
-        should.not.raise(ArgumentError) { @reader_with_quotes.execute_reader(nil) }
+        expect { @reader_with_quotes.execute_reader(nil) }.not_to raise_error(ArgumentError)
       end
 
     end
@@ -114,7 +116,7 @@ shared 'a Command' do
 
   end
 
-  it 'should respond to #set_types' do @command.should.respond_to(:set_types) end
+  it { @command.should respond_to(:set_types) }
 
   describe 'set_types' do
 
@@ -125,7 +127,7 @@ shared 'a Command' do
       end
 
       it 'should raise an error when types are set' do
-        should.raise(ArgumentError) { @command.execute_non_query }
+        expect { @command.execute_non_query }.to raise_error(ArgumentError)
       end
 
     end
@@ -134,14 +136,14 @@ shared 'a Command' do
 
       it 'should raise an error with too few types' do
         @reader.set_types(String)
-        lambda { @reader.execute_reader("One parameter") }.should.raise(ArgumentError).
-          message.should.match(/Field-count mismatch. Expected 1 fields, but the query yielded 2/)
+        expect { @reader.execute_reader("One parameter") }.to raise_error(ArgumentError,
+          /Field-count mismatch. Expected 1 fields, but the query yielded 2/)
       end
 
       it 'should raise an error with too many types' do
         @reader.set_types(String, String, BigDecimal)
-        lambda { @reader.execute_reader("One parameter") }.should.raise(ArgumentError).
-          message.should.match(/Field-count mismatch. Expected 3 fields, but the query yielded 2/)
+        expect { @reader.execute_reader("One parameter") }.to raise_error(ArgumentError,
+          /Field-count mismatch. Expected 3 fields, but the query yielded 2/)
       end
 
     end
@@ -150,33 +152,33 @@ shared 'a Command' do
 
       it 'should not raise an error with correct number of types' do
         @reader.set_types(String, String)
-        should.not.raise(ArgumentError) { @result = @reader.execute_reader('Buy this product now!') }
-        should.not.raise(DataObjects::SQLError) { @result.next! }
-        should.not.raise(DataObjects::DataError) { @result.values }
+        expect { @result = @reader.execute_reader('Buy this product now!') }.not_to raise_error(ArgumentError)
+        expect { @result.next!  }.not_to raise_error(DataObjects::DataError)
+        expect { @result.values }.not_to raise_error(DataObjects::DataError)
         @result.close
       end
 
       it 'should also support old style array argument types' do
         @reader.set_types([String, String])
-        should.not.raise(ArgumentError) { @result = @reader.execute_reader('Buy this product now!') }
-        should.not.raise(DataObjects::DataError) { @result.next! }
-        should.not.raise(DataObjects::DataError) { @result.values }
+        expect { @result = @reader.execute_reader('Buy this product now!') }.not_to raise_error(ArgumentError)
+        expect { @result.next!  }.not_to raise_error(DataObjects::DataError)
+        expect { @result.values }.not_to raise_error(DataObjects::DataError)
         @result.close
       end
 
       it 'should allow subtype types' do
         class MyString < String; end
         @reader.set_types(MyString, String)
-        should.not.raise(ArgumentError) { @result = @reader.execute_reader('Buy this product now!') }
-        should.not.raise(DataObjects::DataError) { @result.next! }
-        should.not.raise(DataObjects::DataError) { @result.values }
+        expect { @result = @reader.execute_reader('Buy this product now!') }.not_to raise_error(ArgumentError)
+        expect { @result.next!  }.not_to raise_error(DataObjects::DataError)
+        expect { @result.values }.not_to raise_error(DataObjects::DataError)
         @result.close
       end
     end
 
   end
 
-  it 'should respond to #to_s' do @command.should.respond_to(:to_s) end
+  it { @command.should respond_to(:to_s) }
 
   describe 'to_s' do
 
@@ -185,9 +187,11 @@ shared 'a Command' do
 
 end
 
-shared 'a Command with async' do
+shared_examples_for 'a Command with async' do
 
-  setup_test_environment
+  before :all do
+    setup_test_environment
+  end
 
   describe 'running queries in parallel' do
 
@@ -198,16 +202,20 @@ shared 'a Command with async' do
       @start = Time.now
       4.times do |i|
         threads << Thread.new do
-          connection = DataObjects::Connection.new(CONFIG.uri)
-          command = connection.create_command(CONFIG.sleep)
-          if CONFIG.sleep =~ /^SELECT/i
-            reader = command.execute_reader
-            reader.next!
-            reader.close
-          else
-            result = command.execute_non_query
+          begin
+            connection = DataObjects::Connection.new(CONFIG.uri)
+            command = connection.create_command(CONFIG.sleep)
+            if CONFIG.sleep =~ /^SELECT/i
+              reader = command.execute_reader
+              reader.next!
+              reader.close
+            else
+              result = command.execute_non_query
+            end
+          ensure
+            # Always make sure the connection gets released back into the pool.
+            connection.close
           end
-          connection.close
         end
       end
 
@@ -215,10 +223,6 @@ shared 'a Command with async' do
       @finish = Time.now
     end
 
-    after do
-      @connection.close
-    end
-
     it "should finish within 2 seconds" do
       pending_if("Ruby on Windows doesn't support asynchronous operations", WINDOWS) do
         (@finish - @start).should < 2

data/lib/data_objects/spec/shared/connection_spec.rb

@@ -0,0 +1,245 @@
+shared_examples_for 'a Connection' do
+
+  before :all do
+    setup_test_environment
+  end
+
+  before do
+    @connection = DataObjects::Connection.new(CONFIG.uri)
+  end
+
+  after do
+    @connection.close
+  end
+
+  it { @connection.should be_kind_of(DataObjects::Connection) }
+  it { @connection.should be_kind_of(DataObjects::Pooling) }
+
+  it { @connection.should respond_to(:dispose) }
+  it 'should respond to #create_command' do @connection.should respond_to(:create_command)          end
+
+  describe 'create_command' do
+    it 'should be a kind of Command' do
+      @connection.create_command('This is a dummy command').should be_kind_of(DataObjects::Command)
+    end
+  end
+
+  describe 'various connection URIs' do
+    def test_connection(conn)
+      reader = conn.create_command(CONFIG.testsql || "SELECT 1").execute_reader
+      reader.next!
+      reader.values[0]
+    end
+
+    it 'should open with an uri object' do
+      uri = DataObjects::URI.new(
+              @driver,
+              @user,
+              @password,
+              @host,
+              @port && @port.to_i,
+              @database,
+              nil, nil
+            )
+      conn = DataObjects::Connection.new(uri)
+      test_connection(conn).should == 1
+      conn.close
+    end
+
+    it 'should work with non-JDBC URLs' do
+      conn = DataObjects::Connection.new("#{CONFIG.uri.sub(/jdbc:/, '')}")
+      test_connection(conn).should == 1
+      conn.close
+    end
+
+  end
+
+  describe 'dispose' do
+
+    describe 'on open connection' do
+
+      it 'dispose should be true' do
+        conn = DataObjects::Connection.new(CONFIG.uri)
+        conn.detach
+        conn.dispose.should be_true
+        conn.close
+      end
+
+    end
+
+    describe 'on closed connection' do
+
+      before do
+        @closed_connection = DataObjects::Connection.new(CONFIG.uri)
+        @closed_connection.detach
+        @closed_connection.dispose
+      end
+
+      after do
+        @closed_connection.close
+        @closed_connection = nil
+      end
+
+      it { @closed_connection.dispose.should be_false }
+
+      it 'should raise an error on creating a command' do
+        expect {
+          @closed_connection.create_command("INSERT INTO non_existent_table (tester) VALUES (1)").execute_non_query
+        }.to raise_error(DataObjects::ConnectionError)
+      end
+    end
+
+  end
+
+end
+
+shared_examples_for 'a Connection with authentication support' do
+
+  before :all do
+    %w[ @driver @user @password @host @port @database ].each do |ivar|
+      raise "+#{ivar}+ should be defined in before block" unless instance_variable_get(ivar)
+    end
+  end
+
+  describe 'with an invalid URI' do
+
+    # FIXME JRuby (and MRI): Should these be ArgumentError or DataObjects::SQLError?
+
+    def connecting_with(uri)
+      lambda { DataObjects::Connection.new(uri) }
+    end
+
+    it 'should raise an error if no database specified' do
+      connecting_with("#{@driver}://#{@user}:#{@password}@#{@host}:#{@port}").should raise_error #(ArgumentError, DataObjects::Error)
+    end
+
+    it 'should raise an error if bad username is given' do
+      connecting_with("#{@driver}://thisreallyshouldntexist:#{@password}@#{@host}:#{@port}#{@database}").should raise_error #(ArgumentError, DataObjects::Error)
+    end
+
+    it 'should raise an error if bad password is given' do
+      connecting_with("#{@driver}://#{@user}:completelyincorrectpassword:#{@host}:#{@port}#{@database}").should raise_error #(ArgumentError, DataObjects::Error)
+    end
+
+    it 'should raise an error if an invalid port is given' do
+      connecting_with("#{@driver}://#{@user}:#{@password}:#{@host}:648646543#{@database}").should raise_error #(ArgumentError, DataObjects::Error)
+    end
+
+    it 'should raise an error if an invalid database is given' do
+      connecting_with("#{@driver}://#{@user}:#{@password}:#{@host}:#{@port}/someweirddatabase").should raise_error #(ArgumentError, DataObjects::Error)
+    end
+
+    it 'should raise an error with a meaningless URI' do
+      connecting_with("#{@driver}://peekaboo$2!@#4543").should raise_error(Addressable::URI::InvalidURIError)
+    end
+
+  end
+
+end
+
+def test_connection(conn)
+  reader = conn.create_command(CONFIG.testsql || "SELECT 1").execute_reader
+  reader.next!
+  result = reader.values[0]
+  result
+ensure
+  reader.close
+  conn.close
+end
+
+shared_examples_for 'a Connection with JDBC URL support' do
+
+  it 'should work with JDBC URLs' do
+    conn = DataObjects::Connection.new(CONFIG.jdbc_uri || "jdbc:#{CONFIG.uri.sub(/jdbc:/, '')}")
+    test_connection(conn).should == 1
+  end
+
+end if defined? JRUBY_VERSION
+
+shared_examples_for 'a Connection with SSL support' do
+
+  if DataObjectsSpecHelpers.test_environment_supports_ssl?
+    describe 'connecting with SSL' do
+
+      it 'should connect securely' do
+        conn = DataObjects::Connection.new("#{CONFIG.uri}?#{CONFIG.ssl}")
+        conn.secure?.should be_true
+        conn.close
+      end
+
+    end
+  end
+
+  describe 'connecting without SSL' do
+
+    it 'should not connect securely' do
+      conn = DataObjects::Connection.new(CONFIG.uri)
+      conn.secure?.should be_false
+      conn.close
+    end
+
+  end
+
+end
+
+shared_examples_for 'a Connection via JDNI' do
+
+  if defined? JRUBY_VERSION
+    require 'java'
+    begin
+      require 'do_jdbc/spec/lib/tyrex-1.0.3.jar'
+      require 'do_jdbc/spec/lib/javaee-api-6.0.jar'
+      require 'do_jdbc/spec/lib/commons-dbcp-1.2.2.jar'
+      require 'do_jdbc/spec/lib/commons-pool-1.3.jar'
+    rescue LoadError
+      pending 'JNDI specs currently require manual download of Tyrex and Apache Commons JARs'
+      break
+    end
+
+    describe 'connecting with JNDI' do
+
+      before(:all) do
+        java_import java.lang.System
+        java_import javax.naming.Context
+        java_import javax.naming.NamingException
+        java_import javax.naming.Reference
+        java_import javax.naming.StringRefAddr
+        java_import 'tyrex.naming.MemoryContext'
+        java_import 'tyrex.tm.RuntimeContext'
+
+        System.set_property(Context.INITIAL_CONTEXT_FACTORY, 'tyrex.naming.MemoryContextFactory')
+        ref  = Reference.new('javax.sql.DataSource',
+                             'org.apache.commons.dbcp.BasicDataSourceFactory', nil)
+        ref.add(StringRefAddr.new('driverClassName',  CONFIG.jdbc_driver))
+        ref.add(StringRefAddr.new('url',              (CONFIG.jdbc_uri || CONFIG.uri)))
+        ref.add(StringRefAddr.new('username',         CONFIG.user))
+        ref.add(StringRefAddr.new('password',         CONFIG.pass))
+
+        @root = MemoryContext.new(nil)
+        ctx   = @root.createSubcontext('comp')
+        ctx   = ctx.createSubcontext('env')
+        ctx   = ctx.createSubcontext('jdbc')
+        ctx.bind('mydb', ref)
+      end
+
+      before do
+        runCtx = RuntimeContext.newRuntimeContext(@root, nil)
+        RuntimeContext.setRuntimeContext(runCtx)
+      end
+
+      after do
+        RuntimeContext.unsetRuntimeContext()
+      end
+
+      it 'should connect' do
+        begin
+          c = DataObjects::Connection.new("java:comp/env/jdbc/mydb?driver=#{CONFIG.driver}")
+          c.should_not be_nil
+          test_connection(c).should == 1
+        ensure
+          c.close if c
+        end
+      end
+    end
+  end
+end