sqlpostgres 1.2.4

data/test/Cursor.test.rb

@@ -0,0 +1,190 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+$:.unshift(File.dirname(__FILE__))
+require 'TestSetup'
+
+require 'MockPGconn'
+
+class CursorTest < Test
+
+  include SqlPostgres
+  include TestUtil
+
+  def testBasic
+    cursor_setup do |connection|
+      Transaction.new(connection) do
+        sql = Select.new
+        sql.select('i')
+        sql.from(table1)
+        cursor = Cursor.new('cursor1', sql, {}, connection)
+        assertEquals(cursor.fetch, [{'i'=>0}])
+        assertEquals(cursor.fetch, [{'i'=>1}])
+        assertEquals(cursor.fetch, [{'i'=>2}])
+        assertEquals(cursor.fetch, [{'i'=>3}])
+        assertEquals(cursor.fetch, [{'i'=>4}])
+        assertEquals(cursor.fetch, [])
+        cursor.close
+      end
+    end
+  end
+
+  def testInitWithClosure
+    cursor_setup do |connection|
+      Transaction.new(connection) do
+        sql = Select.new
+        sql.select('i')
+        sql.from(table1)
+        Cursor.new('cursor1', sql, {}, connection) do |cursor|
+          assertEquals(cursor.fetch, [{'i'=>0}])
+        end
+      end
+    end
+  end
+
+  def test_fetch_count
+    cursor_setup do |connection|
+      Transaction.new(connection) do
+        sql = Select.new
+        sql.select('i')
+        sql.from(table1)
+        cursor = Cursor.new('cursor1', sql, {}, connection)
+        assertEquals(cursor.fetch(2), [{'i'=>0}, {'i'=>1}])
+        assertEquals(cursor.fetch(2), [{'i'=>2}, {'i'=>3}])
+        assertEquals(cursor.fetch(2), [{'i'=>4}])
+        assertEquals(cursor.fetch(2), [])
+        cursor.close
+      end
+    end
+  end
+
+  def testHold
+    cursor_setup do |connection|
+      cursor = nil
+      Transaction.new(connection) do
+        sql = Select.new
+        sql.select('i')
+        sql.from(table1)
+        cursor = Cursor.new('cursor1', sql, {:hold=>true}, connection)
+      end
+      assertEquals(cursor.fetch, [{'i'=>0}])
+      cursor.close
+    end
+  end
+
+  def testDefaultHold
+    cursor_setup do |connection|
+      cursor = nil
+      Transaction.new(connection) do
+        sql = Select.new
+        sql.select('i')
+        sql.from(table1)
+        cursor = Cursor.new('cursor1', sql, {}, connection)
+      end
+      assertException(PGError, /cursor "cursor1" does not exist/)do
+        assertEquals(cursor.fetch, [{'i'=>0}])
+      end
+    end
+  end
+
+  def testNoHold
+    cursor_setup do |connection|
+      cursor = nil
+      Transaction.new(connection) do
+        sql = Select.new
+        sql.select('i')
+        sql.from(table1)
+        cursor = Cursor.new('cursor1', sql, {:hold=>false}, connection)
+      end
+      assertException(PGError, /cursor "cursor1" does not exist/)do
+        assertEquals(cursor.fetch, [{'i'=>0}])
+      end
+    end
+  end
+
+  def testNoScroll
+    cursor_setup do |connection|
+      cursor = nil
+      Transaction.new(connection) do
+        sql = select_too_complex_for_backwards_fetch_without_scroll_option
+        cursor = Cursor.new('cursor1', sql, {:scroll=>false}, connection)
+        assertException(PGError, /cursor can only scan forward/) do
+          cursor.fetch('PRIOR')
+        end
+      end
+    end
+  end
+
+  def testScroll
+    cursor_setup do |connection|
+      Transaction.new(connection) do
+        sql = select_too_complex_for_backwards_fetch_without_scroll_option
+        Cursor.new('cursor1', sql, {:scroll=>true}, connection) do |cursor|
+          assertEquals(cursor.fetch, [{'i'=>0}])
+          assertEquals(cursor.fetch, [{'i'=>2}])
+          assertEquals(cursor.fetch('PRIOR'), [{'i'=>0}])
+          assertEquals(cursor.fetch('PRIOR'), [])
+        end
+      end
+    end
+  end
+
+  def testDefaultScroll
+    cursor_setup do |connection|
+      Transaction.new(connection) do
+        sql = select_too_complex_for_backwards_fetch_without_scroll_option
+        cursor = Cursor.new('cursor1', sql, {}, connection)
+        assertException(PGError, /cursor can only scan forward/) do
+          cursor.fetch('PRIOR')
+        end
+      end
+    end
+  end
+
+  def testMove
+    cursor_setup do |connection|
+      Transaction.new(connection) do
+        sql = Select.new
+        sql.select('i')
+        sql.from(table1)
+        Cursor.new('cursor1', sql, {}, connection) do |cursor|
+          cursor.move("absolute 2")
+          assertEquals(cursor.fetch, [{'i'=>2}])
+        end
+      end
+    end
+  end
+
+  private
+
+  def select_too_complex_for_backwards_fetch_without_scroll_option
+    sql = Select.new
+    sql.select('i')
+    sql.from(table1)
+    sql.join_using('inner', table2, 'i')
+    sql.where('i % 2 = 0')
+    sql
+  end
+
+  def cursor_setup
+    makeTestConnection do |connection|
+      connection.exec("create temporary table #{table1} (i int)")
+      connection.exec("create temporary table #{table2} (i int)")
+      5.times do |i|
+        connection.exec("insert into #{table1} values (#{i})")
+        connection.exec("insert into #{table2} values (#{i})")
+      end
+        yield(connection)
+    end
+  end
+
+end
+
+CursorTest.new.run if $0 == __FILE__
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/test/Delete.test.rb

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+$:.unshift(File.dirname(__FILE__))
+require 'TestSetup'
+
+# Much of Insert is tested in the "roundtrip" test.
+
+class DeleteTest < Test
+
+  include SqlPostgres
+  include TestUtil
+
+  def testDelete_NoWhereClause
+    testit([1, 2, 3], []) do |table, connection|
+      sql = Delete.new(table, connection)
+      sql.exec
+    end
+  end
+
+  def testDelete_OneWhereClause
+    testit([1, 2, 3], [2]) do |table, connection|
+      sql = Delete.new(table, connection)
+      sql.where('i % 2 = 1')
+      sql.exec
+    end
+  end
+
+  def testDelete_TwoWhereClauses
+    testit([1, 2, 3], [1, 2]) do |table, connection|
+      sql = Delete.new(table, connection)
+      sql.where('i % 2 = 1')
+      sql.where('i > 2')
+      sql.exec
+    end
+  end
+
+  def testDelete_PassConnectionToExec
+    testit([1, 2, 3], []) do |table, connection|
+      sql = Delete.new(table)
+      sql.exec(connection)
+    end
+  end
+
+  def testit(initial, final)
+    makeTestConnection do |connection|
+      connection.exec("create temporary table #{table1} (i int)")
+      for i in initial
+        connection.exec("insert into #{table1} (i) values (#{i})")
+      end
+      yield(table1, connection)
+      values = connection.query("select i from #{table1}").collect do |row|
+        row[0].to_i
+      end
+      assertEquals(values, final)
+    end
+  end
+
+end
+
+DeleteTest.new.run if $0 == __FILE__
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/test/Insert.test.rb

@@ -0,0 +1,123 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+$:.unshift(File.dirname(__FILE__))
+require 'TestSetup'
+
+# Much of Insert is tested in the "roundtrip" test.
+
+class InsertTest < Test
+
+  include SqlPostgres
+  include TestUtil
+
+  def testInsert_Subselect
+    makeTestConnection do |connection|
+      connection.exec("create temporary table #{table1} (i int)")
+      select = Select.new
+      select.select_literal(1)
+      insert = Insert.new(table1, connection)
+      insert.insert('i', select)
+      ret = insert.exec
+      assertEquals(connection.query("select i from #{table1}"),
+                   [["1"]])
+    end
+  end
+
+  def testInsert_Expression
+    makeTestConnection do |connection|
+      connection.exec("create temporary table #{table1} (i int)")
+      insert = Insert.new(table1, connection)
+      insert.insert('i', ['1 + 1'])
+      assertEquals(insert.statement, 
+                   "insert into #{table1} (i) values (1 + 1)")
+      insert.exec
+      assertEquals(connection.query("select i from #{table1}"),
+                   [["2"]])
+    end
+  end
+
+  def testSelect
+    makeTestConnection do |connection|
+      connection.exec("create temporary table #{table1} (i int)")
+      select = Select.new
+      select.select_literal(1)
+      insert = Insert.new(table1, connection)
+      insert.insert('i')
+      insert.select(select)
+      insert.exec
+      assertEquals(connection.query("select i from #{table1}"), [["1"]])
+    end
+  end
+
+  def testDefaultConnection
+    makeTestConnection do |connection|
+      connection.exec("create temporary table #{table1} (i int)")
+      setDefaultConnection(connection) do
+        insert = Insert.new(table1)
+        insert.insert('i', 1)
+        insert.exec
+        assertEquals(connection.query("select i from #{table1}"), 
+                     [["1"]])
+      end
+    end
+  end
+
+  def testGiveConnectionToExec
+    makeTestConnection do |connection|
+      connection.exec("create temporary table #{table1} (i int)")
+      insert = Insert.new(table1)
+      insert.insert('i', 1)
+      insert.exec(connection)
+      assertEquals(connection.query("select i from #{table1}"), 
+                   [["1"]])
+    end
+  end
+
+  def testInsertDefaultValues
+    makeTestConnection do |connection|
+      connection.exec("create temporary table #{table1} (i int default 0)")
+      insert = Insert.new(table1, connection)
+      insert.default_values
+      insert.exec
+      assertEquals(connection.query("select i from #{table1}"),
+                   [["0"]])
+    end
+  end
+
+  def testInsertDefault
+    makeTestConnection do |connection|
+      connection.exec("create temporary table #{table1} (i int default 0)")
+      insert = Insert.new(table1, connection)
+      insert.insert('i', :default)
+      insert.exec
+      assertEquals(connection.query("select i from #{table1}"),
+                   [["0"]])
+    end
+  end
+
+  def testInsertReturning
+    makeTestConnection do |connection|
+      connection.exec("create temporary table #{table1} (i int)")
+      insert = Insert.new(table1, connection)
+      insert.insert('i', 2)
+      insert.returning('i * 3', 'calc')
+      assertEquals(insert.statement, 
+                   "insert into #{table1} (i) values (2) returning i * 3 as calc")
+      ret = insert.exec
+      assertEquals(connection.query("select i from #{table1}"),
+                   [["2"]])
+      assertEquals(ret.values, [["6"]])
+    end
+  end
+
+end
+
+InsertTest.new.run if $0 == __FILE__
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/test/MockPGconn.rb

@@ -0,0 +1,62 @@
+class MockPGconn
+
+  @@state = {}
+
+  def MockPGconn.state
+    @@state
+  end
+
+  def state
+    @@state
+  end
+
+  def MockPGconn.connect(*args)
+    @@state[:open] = true
+    @@state[:openArgs] = args
+    @@state[:connection] = MockPGconn.new
+  end
+
+  def set_client_encoding(encoding)
+    @@state[:encoding] = encoding
+  end
+  
+  def exec(statement)
+    @@state[:statements] ||= []
+    @@state[:statements] << statement
+    result = (state[:results] || []).shift
+    raise result if result.kind_of?(Exception)
+    result
+  end
+
+  def close
+    raise "Already closed" unless @@state[:open]
+    @@state[:open] = false
+    raise @@state[:close_exception] if @@state[:close_exception]
+  end
+
+end
+
+module SqlPostgres
+
+  class Connection
+
+    def Connection.mockPgClass
+      oldPgClass = @@pgClass
+      begin
+        MockPGconn.state.clear
+        @@pgClass = MockPGconn
+        yield
+      ensure
+        @@pgClass = oldPgClass
+      end
+    end
+
+  end
+
+end
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/test/NullConnection.test.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+$:.unshift(File.dirname(__FILE__))
+require 'TestSetup'
+
+class NullConnectionTest < Test
+
+  include SqlPostgres
+
+  def testExec
+    assertException(NoConnection) do
+      NullConnection.new.exec("foo")
+    end
+  end
+
+  def testClose
+    assertException(NoConnection) do
+      NullConnection.new.close
+    end
+  end
+
+end
+
+NullConnectionTest.new.run if $0 == __FILE__
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/test/PgBit.test.rb

@@ -0,0 +1,98 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+$:.unshift(File.dirname(__FILE__))
+require 'TestSetup'
+require 'RandomThings'
+
+class PgBitTest < Test
+
+  include SqlPostgres
+  include RandomThings
+
+  def test_ctor_defaults
+    assertEquals(PgBit.new.bits, [])
+  end
+
+  def test_ctor_and_accessors
+    bits = (0..4).collect do rand(2) end
+    assertEquals(PgBit.new(bits).bits, bits)
+    assertEquals(PgBit.new(bits.join.to_s).bits, bits)
+  end
+
+  def test_from_sql
+    testCases = [
+      ["", []],
+      ["0", [0]],
+      ["101", [1, 0, 1]],
+    ]
+    for testCase in testCases
+      sql, bits = *testCase
+      assertInfo("For sql #{sql.inspect}") do
+        assertEquals(PgBit.from_sql(sql), PgBit.new(bits))
+      end
+    end
+    assertException(ArgumentError, 'Invalid bit: "foo"') do
+      PgBit.from_sql("foo")
+    end
+  end
+
+  def test_equality
+    fields = ["bits"]
+    for field in fields
+      assertInfo("For field #{field}") do
+        bit1 = PgBit.new
+        bit2 = PgBit.new
+        assertEquals(bit1.eql?(bit2), true)
+        assertEquals(bit1 == bit2, true)
+        assertEquals(bit1 != bit2, false)
+        args = fields.collect do |f|
+          if f == field then 1 else 0 end
+        end
+        bit2 = PgBit.new(*args)
+        assertEquals(bit1 == bit2, false)
+        assertEquals(bit1 != bit2, true)
+        assertEquals(bit1.eql?(Object.new), false)
+        assertEquals(bit1 == Object.new, false)
+      end
+    end
+  end
+
+  def test_hash
+    count = 0
+    hashes = Hash.new(0)
+    testHash = proc { |*args|
+      assertEquals(PgBit.new(*args).hash, PgBit.new(*args).hash)
+      hashes[PgBit.new(*args).hash] += 1
+      count += 1
+    }
+    for i in (0...10)
+      testHash.call(i)
+    end
+    assertGreaterOrEqual(hashes.size.to_f / count, 0.5)
+  end
+
+  def test_to_s
+    testCases = [
+      [[], ""],
+      [[1], "1"],
+      [[1, 0, 1], "101"],
+    ]
+    for testCase in testCases
+      bits, expected = *testCase
+      bit = PgBit.new(bits)
+      assertEquals(bit.to_s, expected)
+      assertEquals(bit.to_sql, "bit '#{expected}'")
+    end
+  end
+
+end
+
+PgBitTest.new.run if $0 == __FILE__
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End:

data/test/PgBox.test.rb

@@ -0,0 +1,108 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+$:.unshift(File.dirname(__FILE__))
+require 'TestSetup'
+require 'RandomThings'
+
+class PgBoxTest < Test
+
+  include SqlPostgres
+  include RandomThings
+
+   def test_ctor_defaults
+     assertEquals(PgBox.new, PgBox.new(PgPoint.new, PgPoint.new))
+   end
+
+  def test_ctor_and_accessors
+    p1 = randomWhatever
+    p2 = randomWhatever
+    line = PgBox.new(p1, p2)
+    assertEquals(line.p1, p1)
+    assertEquals(line.p2, p2)
+
+    x1 = randomFloat
+    x2 = randomFloat
+    y1 = randomFloat
+    y2 = randomFloat
+    line = PgBox.new(x1, y1, x2, y2)
+    assertEquals(line.p1, PgPoint.new(x1, y1))
+    assertEquals(line.p2, PgPoint.new(x2, y2))
+  end
+
+  def test_from_sql
+    testCases = [
+      ["(0,0),(0,0)", [0, 0, 0, 0]],
+      ["(1.2,-3),(1e+20,-1e20)", [1.2, -3, 1e+20, -1e20]],
+    ]
+    for testCase in testCases
+      sql, args = *testCase
+      assertInfo("For sql #{sql.inspect}") do
+        assertEquals(PgBox.from_sql(sql), PgBox.new(*args))
+      end
+    end
+    assertException(ArgumentError, 'Invalid box: "foo"') do
+      PgBox.from_sql("foo")
+    end
+  end
+
+  def test_equality
+    fields = ["p1", "p2"]
+    for field in fields
+      assertInfo("For field #{field}") do
+        line1 = PgBox.new
+        line2 = PgBox.new
+        assertEquals(line1.eql?(line2), true)
+        assertEquals(line1 == line2, true)
+        assertEquals(line1 != line2, false)
+        args = fields.collect do |f|
+          if f == field then 1 else 0 end
+        end
+        line2 = PgBox.new(*args)
+        assertEquals(line1 == line2, false)
+        assertEquals(line1 != line2, true)
+        assertEquals(line1.eql?(Object.new), false)
+        assertEquals(line1 == Object.new, false)
+      end
+    end
+  end
+
+  def test_hash
+    count = 0
+    hashes = Hash.new(0)
+    testHash = proc { |*args|
+      assertEquals(PgBox.new(*args).hash, PgBox.new(*args).hash)
+      hashes[PgBox.new(*args).hash] += 1
+      count += 1
+    }
+    for i in (0...10)
+      testHash.call(i, 0, 0, 0)
+      testHash.call(0, i, 0, 0)
+      testHash.call(0, 0, i, 0)
+      testHash.call(0, 0, 0, i)
+    end
+    assertGreaterOrEqual(hashes.size.to_f / count, 0.5)
+  end
+
+  def test_to_s
+    testCases = [
+      [[0, 0, 0, 0], "((0, 0), (0, 0))"],
+      [[1.2, -2, 1e10, -1e10], "((1.2, -2), (1e+10, -1e+10))"],
+    ]
+    for testCase in testCases
+      args, expected = *testCase
+      assertEquals(PgBox.new(*args).to_s, expected)
+      assertEquals(PgBox.new(*args).to_sql, "box '#{expected}'")
+    end
+  end
+
+end
+
+PgBoxTest.new.run if $0 == __FILE__
+
+# Local Variables:
+# tab-width: 2
+# ruby-indent-level: 2
+# indent-tabs-mode: nil
+# End: