data_objects 0.10.0 → 0.10.1

data/lib/data_objects/reader.rb

@@ -2,6 +2,8 @@ module DataObjects
   # Abstract class to read rows from a query result
   class Reader
 
+    include Enumerable
+
     # Return the array of field names
     def fields
       raise NotImplementedError.new
@@ -27,5 +29,19 @@ module DataObjects
       raise NotImplementedError.new
     end
 
+    # Yield each row to the given block as a Hash
+    def each
+      begin
+        while next!
+          row = {}
+          fields.each_with_index { |field, index| row[field] = values[index] }
+          yield row
+        end
+      ensure
+        close
+      end
+      self
+    end
+
   end
 end

data/lib/data_objects/spec/bacon.rb

@@ -0,0 +1,9 @@
+#
+# Standard Bacon configuration for DataObjects spec suite
+#
+require 'bacon'
+require 'data_objects/spec/helpers/immediate_red_green_output'
+require 'data_objects/spec/helpers/pending'
+
+Bacon.extend Bacon::ImmediateRedGreenOutput
+Bacon.summary_on_exit

data/lib/data_objects/spec/command_spec.rb

@@ -1,45 +1,43 @@
-WINDOWS = Gem.win_platform?
+WINDOWS = Gem.win_platform? || (JRUBY && ENV_JAVA['os.name'] =~ /windows/i)
 
-share_examples_for 'a Command' do
+shared 'a Command' do
 
-  include DataObjectsSpecHelpers
+  setup_test_environment
 
-  before :all do
-    setup_test_environment
-  end
-
-  before :each do
+  before do
     @connection = DataObjects::Connection.new(CONFIG.uri)
     @command    = @connection.create_command("INSERT INTO users (name) VALUES (?)")
     @reader     = @connection.create_command("SELECT code, name FROM widgets WHERE ad_description = ?")
   end
 
-  after :each do
+  after do
     @connection.close
   end
 
-  it { @command.should be_kind_of(DataObjects::Command) }
+  it 'should be a kind of Command' do @command.should.be.kind_of(DataObjects::Command) end
 
-  it { @command.should respond_to(:execute_non_query) }
+  it 'should respond to #execute_non_query' do @command.should.respond_to(:execute_non_query) end
 
   describe 'execute_non_query' do
 
     describe 'with an invalid statement' do
 
-      before :each do
+      before do
         @invalid_command = @connection.create_command("INSERT INTO non_existent_table (tester) VALUES (1)")
       end
 
       it 'should raise an error on an invalid query' do
-        lambda { @invalid_command.execute_non_query }.should raise_error
+        should.raise(DataObjects::SQLError) { @invalid_command.execute_non_query }
       end
 
       it 'should raise an error with too few binding parameters' do
-        lambda { @command.execute_non_query("Too", "Many") }.should raise_error(ArgumentError, "Binding mismatch: 2 for 1")
+        lambda { @command.execute_non_query("Too", "Many") }.should.raise(ArgumentError).
+          message.should.match(/Binding mismatch: 2 for 1/)
       end
 
       it 'should raise an error with too many binding parameters' do
-        lambda { @command.execute_non_query }.should raise_error(ArgumentError, "Binding mismatch: 0 for 1")
+        lambda { @command.execute_non_query }.should.raise(ArgumentError).
+          message.should.match(/Binding mismatch: 0 for 1/)
       end
 
     end
@@ -47,45 +45,48 @@ share_examples_for 'a Command' do
     describe 'with a valid statement' do
 
       it 'should not raise an error with an explicit nil as parameter' do
-        lambda { @command.execute_non_query(nil) }.should_not raise_error
+        should.not.raise(ArgumentError) { @command.execute_non_query(nil) }
       end
 
     end
 
     describe 'with a valid statement and ? inside quotes' do
 
-      before :each do
+      before do
         @command_with_quotes = @connection.create_command("INSERT INTO users (name) VALUES ('will it work? ')")
       end
 
       it 'should not raise an error' do
-        lambda { @command_with_quotes.execute_non_query }.should_not raise_error
+        should.not.raise(ArgumentError) { @command_with_quotes.execute_non_query }
       end
 
     end
 
   end
 
-  it { @command.should respond_to(:execute_reader) }
+  it 'should respond to #execute_reader' do @command.should.respond_to(:execute_reader) end
 
   describe 'execute_reader' do
 
     describe 'with an invalid reader' do
 
-      before :each do
+      before do
         @invalid_reader = @connection.create_command("SELECT * FROM non_existent_widgets WHERE ad_description = ?")
       end
 
       it 'should raise an error on an invalid query' do
-        lambda { @invalid_reader.execute_reader }.should raise_error
+        # FIXME JRuby (and MRI): Should this be an ArgumentError or DataObjects::SQLError?
+        should.raise(ArgumentError, DataObjects::SQLError) { @invalid_reader.execute_reader }
       end
 
       it 'should raise an error with too few binding parameters' do
-        lambda { @reader.execute_reader("Too", "Many") }.should raise_error(ArgumentError, "Binding mismatch: 2 for 1")
+        lambda { @reader.execute_reader("Too", "Many") }.should.raise(ArgumentError).
+          message.should.match(/Binding mismatch: 2 for 1/)
       end
 
       it 'should raise an error with too many binding parameters' do
-        lambda { @reader.execute_reader }.should raise_error(ArgumentError, "Binding mismatch: 0 for 1")
+        lambda { @reader.execute_reader }.should.raise(ArgumentError).
+          message.should.match(/Binding mismatch: 0 for 1/)
       end
 
     end
@@ -93,19 +94,19 @@ share_examples_for 'a Command' do
     describe 'with a valid reader' do
 
       it 'should not raise an error with an explicit nil as parameter' do
-        lambda { @reader.execute_reader(nil) }.should_not raise_error
+        should.not.raise(ArgumentError) { @reader.execute_reader(nil) }
       end
 
     end
 
     describe 'with a valid reader and ? inside column alias' do
 
-      before :each do
+      before do
         @reader_with_quotes = @connection.create_command("SELECT code AS \"code?\", name FROM widgets WHERE ad_description = ?")
       end
 
       it 'should not raise an error' do
-        lambda { @reader_with_quotes.execute_reader(nil) }.should_not raise_error
+        should.not.raise(ArgumentError) { @reader_with_quotes.execute_reader(nil) }
       end
 
     end
@@ -113,18 +114,18 @@ share_examples_for 'a Command' do
 
   end
 
-  it { @command.should respond_to(:set_types) }
+  it 'should respond to #set_types' do @command.should.respond_to(:set_types) end
 
   describe 'set_types' do
 
     describe 'is invalid when used with a statement' do
 
-      before :each do
+      before do
         @command.set_types(String)
       end
 
       it 'should raise an error when types are set' do
-        lambda { @command.execute_non_query }.should raise_error
+        should.raise(ArgumentError) { @command.execute_non_query }
       end
 
     end
@@ -133,12 +134,14 @@ share_examples_for '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_error(ArgumentError, "Field-count mismatch. Expected 1 fields, but the query yielded 2")
+        lambda { @reader.execute_reader("One parameter") }.should.raise(ArgumentError).
+          message.should.match(/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_error(ArgumentError, "Field-count mismatch. Expected 3 fields, but the query yielded 2")
+        lambda { @reader.execute_reader("One parameter") }.should.raise(ArgumentError).
+          message.should.match(/Field-count mismatch. Expected 3 fields, but the query yielded 2/)
       end
 
     end
@@ -147,25 +150,33 @@ share_examples_for 'a Command' do
 
       it 'should not raise an error with correct number of types' do
         @reader.set_types(String, String)
-        lambda { @result = @reader.execute_reader('Buy this product now!') }.should_not raise_error
-        lambda { @result.next! }.should_not raise_error
-        lambda { @result.values }.should_not raise_error
+        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 }
         @result.close
       end
 
       it 'should also support old style array argument types' do
         @reader.set_types([String, String])
-        lambda { @result = @reader.execute_reader('Buy this product now!') }.should_not raise_error
-        lambda { @result.next! }.should_not raise_error
-        lambda { @result.values }.should_not raise_error
+        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 }
         @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 }
+        @result.close
+      end
     end
 
   end
 
-  it { @command.should respond_to(:to_s) }
+  it 'should respond to #to_s' do @command.should.respond_to(:to_s) end
 
   describe 'to_s' do
 
@@ -174,17 +185,13 @@ share_examples_for 'a Command' do
 
 end
 
-share_examples_for 'a Command with async' do
-
-  include DataObjectsSpecHelpers
+shared 'a Command with async' do
 
-  before :all do
-    setup_test_environment
-  end
+  setup_test_environment
 
   describe 'running queries in parallel' do
 
-    before :each do
+    before do
 
       threads = []
 
@@ -208,12 +215,12 @@ share_examples_for 'a Command with async' do
       @finish = Time.now
     end
 
-    after :each do
+    after do
       @connection.close
     end
 
     it "should finish within 2 seconds" do
-      pending_if("Ruby on Windows doesn't support asynchronious operations", WINDOWS) do
+      pending_if("Ruby on Windows doesn't support asynchronous operations", WINDOWS) do
         (@finish - @start).should < 2
       end
     end

data/lib/data_objects/spec/connection_spec.rb

@@ -1,27 +1,24 @@
-share_examples_for 'a Connection' do
+shared 'a Connection' do
 
-  include DataObjectsSpecHelpers
+  setup_test_environment
 
-  before :all do
-    setup_test_environment
-  end
-
-  before :each do
+  before do
     @connection = DataObjects::Connection.new(CONFIG.uri)
   end
 
-  after :each do
+  after do
     @connection.close
   end
 
-  it { @connection.should be_kind_of(DataObjects::Connection) }
-  it { @connection.should be_kind_of(Extlib::Pooling) }
+  it 'should be a kind of Connection' do @connection.should.be.kind_of(::DataObjects::Connection) end
+  it 'should be a kind of Pooling'    do @connection.should.be.kind_of(::DataObjects::Pooling)    end
 
-  it { @connection.should respond_to(:dispose) }
+  it 'should respond to #dispose'     do @connection.should.respond_to(:dispose) end
 
   describe 'dispose' do
 
     describe 'on open connection' do
+
       before do
         @open_connection = DataObjects::Connection.new("#{@driver}://#{@user}:#{@password}@#{@host}:#{@port}#{@database}")
         @open_connection.detach
@@ -31,10 +28,14 @@ share_examples_for 'a Connection' do
         @open_connection.close
       end
 
-      it { @open_connection.dispose.should be_true }
+      it 'dispose should be true' do
+        @open_connection.dispose.should.be.true
+      end
+
     end
 
     describe 'on closed connection' do
+
       before do
         @closed_connection = DataObjects::Connection.new("#{@driver}://#{@user}:#{@password}@#{@host}:#{@port}#{@database}")
         @closed_connection.detach
@@ -45,73 +46,124 @@ share_examples_for 'a Connection' do
         @closed_connection.close
       end
 
-      it { @closed_connection.dispose.should be_false }
+      it 'dispose should be false' do
+        @closed_connection.dispose.should.be.false
+      end
 
       it 'should raise an error on creating a command' do
-        lambda { @closed_connection.create_command("INSERT INTO non_existant_table (tester) VALUES (1)").execute_non_query }.should raise_error
+        should.raise(DataObjects::ConnectionError) {
+          @closed_connection.create_command("INSERT INTO non_existent_table (tester) VALUES (1)").execute_non_query
+        }
       end
     end
 
   end
 
-  it { @connection.should respond_to(:create_command) }
+  it 'should respond to #create_command' do @connection.should.respond_to(:create_command) end
 
   describe 'create_command' do
-    it { @connection.create_command('This is a dummy command').should be_kind_of(DataObjects::Command) }
+    it 'should be a kind of Command' do
+      @connection.create_command('This is a dummy command').should.be.kind_of(DataObjects::Command)
+    end
   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
 
-share_examples_for 'a Connection with authentication support' do
+    after do
+      @open_connection.close if @open_connection
+    end
 
-  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)
+    it 'should open with an uri object' do
+      uri = DataObjects::URI.new(
+              @driver,
+              @user,
+              @password,
+              @host,
+              @port.to_i,
+              @database,
+              nil, nil
+            )
+      test_connection(DataObjects::Connection.new(uri)).should == 1
     end
 
+    it 'should work with non-JDBC URLs' do
+      conn = DataObjects::Connection.new("#{CONFIG.uri.sub(/jdbc:/, '')}")
+      test_connection(conn).should == 1
+    end
+
+  end
+end
+
+shared 'a Connection with authentication support' 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
 
   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
+      connecting_with("#{@driver}://#{@user}:#{@password}@#{@host}:#{@port}").should.raise(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
+      connecting_with("#{@driver}://thisreallyshouldntexist:#{@password}@#{@host}:#{@port}#{@database}").should.raise(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
+      connecting_with("#{@driver}://#{@user}:completelyincorrectpassword:#{@host}:#{@port}#{@database}").should.raise(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
+      connecting_with("#{@driver}://#{@user}:#{@password}:#{@host}:648646543#{@database}").should.raise(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
+      connecting_with("#{@driver}://#{@user}:#{@password}:#{@host}:#{@port}/someweirddatabase").should.raise(ArgumentError, DataObjects::Error)
     end
 
     it 'should raise an error with a meaningless URI' do
-      connecting_with("#{@driver}://peekaboo$2!@#4543").should raise_error
+      connecting_with("#{@driver}://peekaboo$2!@#4543").should.raise(Addressable::URI::InvalidURIError)
     end
 
   end
 
 end
 
-share_examples_for 'a Connection with SSL support' do
+shared 'a Connection with JDBC URL support' do
+
+  def test_connection(conn)
+    reader = conn.create_command(CONFIG.testsql || "SELECT 1").execute_reader
+    reader.next!
+    reader.values[0]
+  end
+
+  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 JRUBY
+
+shared 'a Connection with SSL support' do
 
   if DataObjectsSpecHelpers.test_environment_supports_ssl?
     describe 'connecting with SSL' do
 
       it 'should connect securely' do
-        DataObjects::Connection.new("#{CONFIG.uri}?#{CONFIG.ssl}").secure?.should be_true
+        DataObjects::Connection.new("#{CONFIG.uri}?#{CONFIG.ssl}").secure?.should.be.true
       end
 
     end
@@ -120,9 +172,46 @@ share_examples_for 'a Connection with SSL support' do
   describe 'connecting without SSL' do
 
     it 'should not connect securely' do
-      DataObjects::Connection.new(CONFIG.uri).secure?.should be_false
+      DataObjects::Connection.new(CONFIG.uri).secure?.should.be.false
     end
 
   end
 
 end
+
+shared 'a Connection via JDNI' do
+
+  if JRUBY
+    describe 'connecting with JNDI' do
+
+      before do
+        begin
+          @jndi = Java::data_objects.JNDITestSetup.new("jdbc:#{CONFIG.uri}".gsub(/:sqlite3:/, ':sqlite:'), CONFIG.jdbc_driver, 'mydb')
+          @jndi.setup()
+        rescue
+          puts "use (after installation of maven) to test JNDI:"
+          puts "mvn rails:spec -Drails.fork=false"
+        end
+      end
+
+      after do
+        @jndi.teardown() unless @jndi.nil?
+      end
+
+      unless @jndi.nil?
+        it 'should connect' do
+          begin
+            c = DataObjects::Connection.new("java:comp/env/jdbc/mydb?scheme=#{CONFIG.scheme}")
+            c.should_not be_nil
+          rescue => e
+            if e.message =~ /java.naming.factory.initial/
+              puts "use (after installation of maven) to test JNDI:"
+              puts "mvn rails:spec -Drails.fork=false"
+            end
+          end
+        end
+      end
+
+    end
+  end
+end