sqlpostgres 1.2.4

data/test/Test.rb

@@ -0,0 +1,62 @@
+require 'Assert'
+require 'TestUtil'
+
+class Test
+  
+  include Assert
+  include TestUtil
+
+  private
+  
+  def allInstanceMethods
+    self.class.public_instance_methods(false) + 
+      self.class.private_instance_methods(false)
+  end
+  
+  public
+  
+  def doRun
+    testForTestDb
+    allInstanceMethods.each { |methodName|
+      case methodName
+      when /^skip_test/
+        $stderr.puts "Warning: Commented out test #{methodName}"
+      when /^test/
+        aMethod = method(methodName)
+        if aMethod.arity == 0
+          #$stderr.puts methodName
+          setup
+          begin
+            aMethod.call
+          ensure
+            tearDown
+          end
+        end
+      end
+    }
+  end
+  
+  def run
+    begin
+      doRun
+    rescue Exception => e
+      $stderr.puts "#{e.class}: #{e}", e.backtrace
+      exit 1
+    end
+  end
+  
+  private
+
+  def setup
+  end
+  
+  def tearDown
+  end
+  
+end
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/test/TestConfig.rb

@@ -0,0 +1,21 @@
+module TestConfig
+
+  # The path to the library
+
+  LIB_PATH = "../lib/sqlpostgres"
+
+  # The name of the database to use for testing.
+
+  TEST_DB_NAME = "sqlpostgres_test"
+
+  # The prefix for temporary database objects.
+
+  TEST_DB_PREFIX = "SQLPOSTGRES_TEST_"
+
+end
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/test/TestSetup.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'bundler/setup'
+$:.unshift(File.join(File.dirname(__FILE__), "../lib"))
+require "sqlpostgres"
+require 'TestConfig'
+require 'Test'
+require 'TestUtil'
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/test/TestUtil.rb

@@ -0,0 +1,92 @@
+module TestUtil
+
+  require 'TestConfig'
+
+  include TestConfig
+  include SqlPostgres
+
+  def testDbArgs
+    {'db_name'=>TEST_DB_NAME}
+  end
+
+  def testForTestDb
+    begin
+      Connection.new(testDbArgs)
+    rescue PGError => message
+      puts "Creating test database"
+      system("psql -c 'create database #{TEST_DB_NAME}' template1 > /dev/null 2>&1")
+    end
+  end
+
+  def removeTestDb
+    puts "Removing test database"
+    system("psql -c 'drop database #{TEST_DB_NAME}' template1 > /dev/null 2>&1")
+  end
+
+  def makeTestConnection
+    if block_given?
+      Connection.open(testDbArgs) do |connection|
+        yield(connection)
+      end
+    else
+      Connection.new(testDbArgs)
+    end
+  end
+
+  def setDefaultConnection(connection)
+    oldDefault = Connection.default
+    Connection.default = connection
+    begin
+      yield
+    ensure
+      Connection.default = oldDefault
+    end
+  end
+
+  def testTableName(suffix)
+    [TEST_DB_PREFIX, suffix].join('')
+  end
+  
+  def table1
+    testTableName("foo")
+  end
+
+  def table2
+    testTableName("bar")
+  end
+
+  def table3 
+    testTableName("baz")
+  end
+
+  def allCharactersExceptNull
+    allCharacters(1)
+  end
+
+  def allCharacters(floor = 0)
+    s = (floor..255).to_a.collect do |i|
+      i.chr
+    end.join
+    if s.respond_to?(:force_encoding)
+      s = s.force_encoding('ASCII-8BIT')
+    end
+    s
+  end
+
+  def setenv(name, value)
+    old_value = ENV[name]
+    ENV[name] = value
+    begin
+      yield
+    ensure
+      ENV[name] = old_value
+    end
+  end
+
+end
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/test/Transaction.test.rb

@@ -0,0 +1,275 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+$:.unshift(File.dirname(__FILE__))
+require 'TestSetup'
+
+require 'MockPGconn'
+
+class TransactionTest < Test
+
+  include SqlPostgres
+  include TestUtil
+
+  def testSuccess
+    Connection.mockPgClass do
+      connection = Connection.new
+      assertEquals(MockPGconn.state[:statements], nil)
+      Transaction.new(connection) do
+        connection.exec("foo")
+        assertEquals(MockPGconn.state[:statements], 
+                     ["begin transaction", "foo"])
+      end
+      assertEquals(MockPGconn.state[:statements], 
+                   ["begin transaction", "foo", "end transaction"])
+    end
+  end
+
+  def testManualCommit
+    Connection.mockPgClass do
+      connection = Connection.new
+      assertEquals(MockPGconn.state[:statements], nil)
+      Transaction.new(connection) do
+        connection.exec("foo")
+        assertEquals(MockPGconn.state[:statements], 
+                     ["begin transaction", "foo"])
+      end
+      assertEquals(MockPGconn.state[:statements], 
+                   ["begin transaction", "foo", "end transaction"])
+    end
+  end
+
+  def testSuccess_Real
+    makeTestConnection do |connection|
+      connection.exec("create temporary table #{table1} (i int)")
+      Transaction.new(connection) do
+        connection.exec("insert into #{table1} values (1)")
+      end
+      assertEquals(connection.query("select i from #{table1}"), [["1"]])
+    end
+  end
+
+  def testSuccess_Real_DefaultConnection
+    makeTestConnection do |connection|
+      setDefaultConnection(connection) do
+        connection.exec("create temporary table #{table1} (i int)")
+        Transaction.new do
+          connection.exec("insert into #{table1} values (1)")
+        end
+        assertEquals(connection.query("select i from #{table1}"), 
+                     [["1"]])
+      end
+    end
+  end
+
+  def testRuntimeError
+    Connection.mockPgClass do
+      connection = Connection.new
+      assertEquals(MockPGconn.state[:statements], nil)
+      assertException(RuntimeError, "Oh no!") do
+        Transaction.new(connection) do
+          connection.exec("foo")
+          assertEquals(MockPGconn.state[:statements], 
+                       ["begin transaction", "foo"])
+          raise "Oh no!"
+        end
+      end
+      assertEquals(MockPGconn.state[:statements], 
+                   ["begin transaction", "foo", "abort transaction"])
+    end
+  end
+
+  class Sorry < Exception
+  end
+
+  def testException
+    Connection.mockPgClass do
+      connection = Connection.new
+      assertEquals(MockPGconn.state[:statements], nil)
+      assertException(Sorry, "Oh no!") do
+        Transaction.new(connection) do
+          connection.exec("foo")
+          assertEquals(MockPGconn.state[:statements], 
+                       ["begin transaction", "foo"])
+          raise Sorry, "Oh no!"
+        end
+      end
+      assertEquals(MockPGconn.state[:statements], 
+                   ["begin transaction", "foo", "abort transaction"])
+    end
+  end
+
+  def testException
+    Connection.mockPgClass do
+      connection = Connection.new
+      assertEquals(MockPGconn.state[:statements], nil)
+      assertException(Sorry, "Oh no!") do
+        Transaction.new(connection) do
+          connection.exec("foo")
+          assertEquals(MockPGconn.state[:statements], 
+                       ["begin transaction", "foo"])
+          raise Sorry, "Oh no!"
+        end
+      end
+      assertEquals(MockPGconn.state[:statements], 
+                   ["begin transaction", "foo", "abort transaction"])
+    end
+  end
+
+  def testRuntimeError_Real
+    makeTestConnection do |connection|
+      connection.exec("create temporary table #{table1} (i int)")
+      assertException(RuntimeError, "Oh no!") do
+        Transaction.new(connection) do
+          connection.exec("insert into #{table1} values (1)")
+          assertEquals(connection.query("select i from #{table1}"),
+                       [["1"]])
+          raise "Oh no!"
+        end
+      end
+      assertEquals(connection.query("select i from #{table1}"), [])
+    end
+  end
+
+  def testManualCommit
+    Connection.mockPgClass do
+      connection = Connection.new
+      assertEquals(MockPGconn.state[:statements], nil)
+      Transaction.new(connection) do |transaction|
+        connection.exec("foo")
+        transaction.commit
+        assertEquals(MockPGconn.state[:statements], 
+                     ["begin transaction", "foo", "end transaction"])
+      end
+      assertEquals(MockPGconn.state[:statements], 
+                   ["begin transaction", "foo", "end transaction"])
+    end
+  end
+
+  def testManualCommitTwice
+    Connection.mockPgClass do
+      connection = Connection.new
+      assertEquals(MockPGconn.state[:statements], nil)
+      Transaction.new(connection) do |transaction|
+        connection.exec("foo")
+        transaction.commit
+        transaction.commit
+        assertEquals(MockPGconn.state[:statements], 
+                     ["begin transaction", "foo", "end transaction"])
+      end
+      assertEquals(MockPGconn.state[:statements], 
+                   ["begin transaction", "foo", "end transaction"])
+    end
+  end
+
+  def testManualAbortAfterCommit
+    Connection.mockPgClass do
+      connection = Connection.new
+      assertEquals(MockPGconn.state[:statements], nil)
+      Transaction.new(connection) do |transaction|
+        connection.exec("foo")
+        transaction.commit
+        transaction.abort
+        assertEquals(MockPGconn.state[:statements], 
+                     ["begin transaction", "foo", "end transaction"])
+      end
+      assertEquals(MockPGconn.state[:statements], 
+                   ["begin transaction", "foo", "end transaction"])
+    end
+  end
+
+  def testManualCommitWithException
+    Connection.mockPgClass do
+      connection = Connection.new
+      assertEquals(MockPGconn.state[:statements], nil)
+      begin
+        Transaction.new(connection) do |transaction|
+          connection.exec("foo")
+          transaction.commit
+          assertEquals(MockPGconn.state[:statements], 
+                       ["begin transaction", "foo", "end transaction"])
+          raise Sorry
+        end
+      rescue Sorry => e
+      end
+      assertEquals(MockPGconn.state[:statements], 
+                   ["begin transaction", "foo", "end transaction"])
+    end
+  end
+
+  def testManualAbort
+    Connection.mockPgClass do
+      connection = Connection.new
+      assertEquals(MockPGconn.state[:statements], nil)
+      Transaction.new(connection) do |transaction|
+        connection.exec("foo")
+        transaction.abort
+        assertEquals(MockPGconn.state[:statements], 
+                     ["begin transaction", "foo", "abort transaction"])
+      end
+      assertEquals(MockPGconn.state[:statements], 
+                   ["begin transaction", "foo", "abort transaction"])
+    end
+  end
+
+  def testManualAbortTwice
+    Connection.mockPgClass do
+      connection = Connection.new
+      assertEquals(MockPGconn.state[:statements], nil)
+      Transaction.new(connection) do |transaction|
+        connection.exec("foo")
+        transaction.abort
+        transaction.abort
+        assertEquals(MockPGconn.state[:statements], 
+                     ["begin transaction", "foo", "abort transaction"])
+      end
+      assertEquals(MockPGconn.state[:statements], 
+                   ["begin transaction", "foo", "abort transaction"])
+    end
+  end
+
+  def testManualCommitAfterAbort
+    Connection.mockPgClass do
+      connection = Connection.new
+      assertEquals(MockPGconn.state[:statements], nil)
+      Transaction.new(connection) do |transaction|
+        connection.exec("foo")
+        transaction.abort
+        transaction.commit
+        assertEquals(MockPGconn.state[:statements], 
+                     ["begin transaction", "foo", "abort transaction"])
+      end
+      assertEquals(MockPGconn.state[:statements], 
+                   ["begin transaction", "foo", "abort transaction"])
+    end
+  end
+
+  def testManualAbortWithException
+    Connection.mockPgClass do
+      connection = Connection.new
+      assertEquals(MockPGconn.state[:statements], nil)
+      begin
+        Transaction.new(connection) do |transaction|
+          connection.exec("foo")
+          transaction.abort
+          assertEquals(MockPGconn.state[:statements], 
+                       ["begin transaction", "foo", "abort transaction"])
+          raise Sorry
+        end
+      rescue Sorry => e
+      end
+      assertEquals(MockPGconn.state[:statements], 
+                   ["begin transaction", "foo", "abort transaction"])
+    end
+  end
+
+end
+
+TransactionTest.new.run if $0 == __FILE__
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End: