activerecord-jdbc-adapter 1.2.9.1 → 1.3.0.beta1

data/test/{postgres_db_create_test.rb → db/postgres/db_create_test.rb}

@@ -1,5 +1,5 @@
-require 'abstract_db_create'
 require 'db/postgres'
+require 'abstract_db_create'
 
 class PostgresDbCreateTest < Test::Unit::TestCase
   include AbstractDbCreate

data/test/{postgres_drop_db_test.rb → db/postgres/db_drop_test.rb}

@@ -1,3 +1,4 @@
+require 'db/postgres'
 require 'abstract_db_create'
 
 class PostgresDbDropTest < Test::Unit::TestCase
@@ -12,4 +13,5 @@ class PostgresDbDropTest < Test::Unit::TestCase
       Rake::Task["db:drop"].invoke
     end
   end
+  
 end

data/test/db/postgres/hstore_test.rb

@@ -0,0 +1,200 @@
+# encoding: utf-8
+require 'test_helper'
+require 'db/postgres'
+
+class PostgresqlHstoreTest < Test::Unit::TestCase
+  
+  class Hstore < ActiveRecord::Base
+    self.table_name = 'hstores'
+  end
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+
+    unless @connection.supports_extensions?
+      return skip "do not test on PG without hstore"
+    end
+
+    unless @connection.extension_enabled?('hstore')
+      @connection.enable_extension 'hstore'
+      @connection.commit_db_transaction
+    end
+
+    @connection.reconnect!
+
+    @connection.transaction do
+      @connection.create_table('hstores') do |t|
+        t.hstore 'tags', :default => ''
+      end
+    end
+    @column = Hstore.columns.find { |c| c.name == 'tags' }
+  end
+
+  def teardown
+    @connection.execute 'drop table if exists hstores'
+  end
+
+  def test_hstore_included_in_extensions
+    assert @connection.respond_to?(:extensions), "connection should have a list of extensions"
+    assert @connection.extensions.include?('hstore'), "extension list should include hstore"
+  end
+
+  def test_disable_enable_hstore
+    assert_true @connection.extension_enabled?('hstore')
+    @connection.disable_extension 'hstore'
+    assert_false @connection.extension_enabled?('hstore')
+    @connection.enable_extension 'hstore'
+    assert_true @connection.extension_enabled?('hstore')
+  ensure
+    # Restore column(s) dropped by `drop extension hstore cascade;`
+    # load_schema
+  end
+
+  def test_column
+    assert_equal :hstore, @column.type
+  end
+
+  def test_change_table_supports_hstore
+    @connection.transaction do
+      @connection.change_table('hstores') do |t|
+        t.hstore 'users', :default => ''
+      end
+      Hstore.reset_column_information
+      column = Hstore.columns.find { |c| c.name == 'users' }
+      assert_equal :hstore, column.type
+
+      raise ActiveRecord::Rollback # reset the schema change
+    end
+  ensure
+    Hstore.reset_column_information
+  end
+
+  def test_type_cast_hstore
+    assert @column
+
+    data = "\"1\"=>\"2\""
+    hash = @column.class.string_to_hstore data
+    assert_equal({'1' => '2'}, hash)
+    assert_equal({'1' => '2'}, @column.type_cast(data))
+
+    assert_equal({}, @column.type_cast(""))
+    assert_equal({'key'=>nil}, @column.type_cast('key => NULL'))
+    assert_equal({'c'=>'}','"a"'=>'b "a b'}, @column.type_cast(%q(c=>"}", "\"a\""=>"b \"a b")))
+  end
+
+  def test_gen1
+    assert_equal(%q(" "=>""), @column.class.hstore_to_string({' '=>''}))
+  end
+
+  def test_gen2
+    assert_equal(%q(","=>""), @column.class.hstore_to_string({','=>''}))
+  end
+
+  def test_gen3
+    assert_equal(%q("="=>""), @column.class.hstore_to_string({'='=>''}))
+  end
+
+  def test_gen4
+    assert_equal(%q(">"=>""), @column.class.hstore_to_string({'>'=>''}))
+  end
+
+  def test_parse1
+    assert_equal({'a'=>nil,'b'=>nil,'c'=>'NuLl','null'=>'c'}, @column.type_cast('a=>null,b=>NuLl,c=>"NuLl",null=>c'))
+  end
+
+  def test_parse2
+    assert_equal({" " => " "},  @column.type_cast("\\ =>\\ "))
+  end
+
+  def test_parse3
+    assert_equal({"=" => ">"},  @column.type_cast("==>>"))
+  end
+
+  def test_parse4
+    assert_equal({"=a"=>"q=w"},   @column.type_cast('\=a=>q=w'))
+  end
+
+  def test_parse5
+    assert_equal({"=a"=>"q=w"},   @column.type_cast('"=a"=>q\=w'))
+  end
+
+  def test_parse6
+    assert_equal({"\"a"=>"q>w"},  @column.type_cast('"\"a"=>q>w'))
+  end
+
+  def test_parse7
+    assert_equal({"\"a"=>"q\"w"}, @column.type_cast('\"a=>q"w'))
+  end
+
+  def test_rewrite
+    @connection.execute "insert into hstores (tags) VALUES ('1=>2')"
+    x = Hstore.first
+    x.tags = { '"a\'' => 'b' }
+    assert x.save!
+  end
+
+
+  def test_select
+    @connection.execute "insert into hstores (tags) VALUES ('1=>2')"
+    x = Hstore.first
+    assert_equal({'1' => '2'}, x.tags)
+  end
+
+  def test_select_multikey
+    @connection.execute "insert into hstores (tags) VALUES ('1=>2,2=>3')"
+    x = Hstore.first
+    assert_equal({'1' => '2', '2' => '3'}, x.tags)
+  end
+
+  def test_create
+    assert_cycle('a' => 'b', '1' => '2')
+  end
+
+  def test_nil
+    assert_cycle('a' => nil)
+  end
+
+  def test_quotes
+    assert_cycle('a' => 'b"ar', '1"foo' => '2')
+  end
+
+  def test_whitespace
+    assert_cycle('a b' => 'b ar', '1"foo' => '2')
+  end
+
+  def test_backslash
+    assert_cycle('a\\b' => 'b\\ar', '1"foo' => '2')
+  end
+
+  def test_comma
+    assert_cycle('a, b' => 'bar', '1"foo' => '2')
+  end
+
+  def test_arrow
+    assert_cycle('a=>b' => 'bar', '1"foo' => '2')
+  end
+
+  def test_quoting_special_characters
+    assert_cycle('ca' => 'cà', 'ac' => 'àc')
+  end
+
+  def test_multiline
+    assert_cycle("a\nb" => "c\nd")
+  end
+
+  private
+  def assert_cycle hash
+    # test creation
+    x = Hstore.create!(:tags => hash)
+    x.reload
+    assert_equal(hash, x.tags)
+
+    # test updating
+    x = Hstore.create!(:tags => {})
+    x.tags = hash
+    x.save!
+    x.reload
+    assert_equal(hash, x.tags)
+  end
+  
+end if Test::Unit::TestCase.ar_version('4.0')

data/test/db/postgres/information_schema_leak_test.rb

@@ -0,0 +1,30 @@
+require 'db/postgres'
+
+class PostgresInformationSchemaLeakTest < Test::Unit::TestCase
+  
+  class CreateISLSchema < ActiveRecord::Migration
+    def self.up
+      execute "CREATE TABLE domains (id int, name varchar(16))"
+    end
+
+    def self.down
+      execute "DROP TABLE domains"
+    end
+  end
+
+  class Domain < ActiveRecord::Base
+  end
+  
+  def setup
+    CreateISLSchema.up
+  end
+
+  def teardown
+    CreateISLSchema.down
+  end
+
+  def test_domain_columns
+    assert_equal(%w{id name}, Domain.column_names)
+  end
+  
+end

data/test/db/postgres/json_test.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+require 'test_helper'
+require 'db/postgres'
+
+class PostgresqlJSONTest < Test::Unit::TestCase
+  
+  class JsonDataType < ActiveRecord::Base
+    self.table_name = 'json_data_type'
+  end
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+    begin
+      @connection.transaction do
+        @connection.create_table('json_data_type') do |t|
+          t.json 'payload', :default => {}
+        end
+      end
+    rescue ActiveRecord::StatementInvalid
+      return skip "do not test on PG without json"
+    end
+  end
+
+  def teardown
+    @connection.execute 'drop table if exists json_data_type'
+  end
+
+  def test_column
+    column = JsonDataType.columns.find { |c| c.name == 'payload' }
+    assert_equal :json, column.type
+  end
+
+  def test_change_table_supports_json
+    @connection.transaction do
+      @connection.change_table('json_data_type') do |t|
+        t.json 'users', :default => '{}'
+      end
+      JsonDataType.reset_column_information
+      column = JsonDataType.columns.find { |c| c.name == 'users' }
+      assert_equal :json, column.type
+
+      raise ActiveRecord::Rollback # reset the schema change
+    end
+  ensure
+    JsonDataType.reset_column_information
+  end
+
+  def test_type_cast_json
+    assert @column = JsonDataType.columns.find { |c| c.name == 'payload' }
+
+    data = "{\"a_key\":\"a_value\"}"
+    hash = @column.class.string_to_json data
+    assert_equal({'a_key' => 'a_value'}, hash)
+    assert_equal({'a_key' => 'a_value'}, @column.type_cast(data))
+
+    assert_equal({}, @column.type_cast("{}"))
+    assert_equal({'key'=>nil}, @column.type_cast('{"key": null}'))
+    assert_equal({'c'=>'}','"a"'=>'b "a b'}, @column.type_cast(%q({"c":"}", "\"a\"":"b \"a b"})))
+  end
+
+  def test_rewrite
+    @connection.execute "insert into json_data_type (payload) VALUES ('{\"k\":\"v\"}')"
+    x = JsonDataType.first
+    x.payload = { '"a\'' => 'b' }
+    assert x.save!
+  end
+
+  def test_select
+    @connection.execute "insert into json_data_type (payload) VALUES ('{\"k\":\"v\"}')"
+    x = JsonDataType.first
+    assert_equal({'k' => 'v'}, x.payload)
+  end
+
+  def test_select_multikey
+    @connection.execute %q|insert into json_data_type (payload) VALUES ('{"k1":"v1", "k2":"v2", "k3":[1,2,3]}')|
+    x = JsonDataType.first
+    assert_equal({'k1' => 'v1', 'k2' => 'v2', 'k3' => [1,2,3]}, x.payload)
+  end
+
+  def test_null_json
+    @connection.execute %q|insert into json_data_type (payload) VALUES(null)|
+    x = JsonDataType.first
+    assert_equal(nil, x.payload)
+  end
+  
+end if Test::Unit::TestCase.ar_version('4.0')

data/test/db/postgres/ltree_test.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+require 'test_helper'
+require 'db/postgres'
+
+class PostgresqlLtreeTest < Test::Unit::TestCase
+  
+  class Ltree < ActiveRecord::Base
+    self.table_name = 'ltrees'
+  end
+
+  @@ltree_support = nil
+  
+  def self.startup
+    connection = ActiveRecord::Base.connection
+    connection = ActiveRecord::Base.connection
+    connection.transaction do
+      connection.create_table('ltrees') do |t|
+        t.ltree 'path'
+      end
+    end
+    @@ltree_support = true
+  rescue ActiveRecord::StatementInvalid => e
+    puts "skiping ltree tests due: #{e.message}"
+    @@ltree_support = false
+  end
+
+  def self.shutdown
+    ActiveRecord::Base.connection.execute 'drop table if exists ltrees'
+  end
+
+  def test_column
+    skip unless @@ltree_support
+    column = Ltree.columns_hash['path']
+    assert_equal :ltree, column.type
+  end
+
+  def test_write
+    skip unless @@ltree_support
+    ltree = Ltree.new(:path => '1.2.3.4')
+    assert ltree.save!
+  end
+
+  def test_select
+    skip unless @@ltree_support
+    @connection.execute "insert into ltrees (path) VALUES ('1.2.3')"
+    ltree = Ltree.first
+    assert_equal '1.2.3', ltree.path
+  end
+  
+end if Test::Unit::TestCase.ar_version('4.0')

data/test/db/postgres/native_types_test.rb

@@ -0,0 +1,128 @@
+require 'db/postgres'
+
+class PostgresNativeTypesTest < Test::Unit::TestCase
+  
+  class CustomersMigration < ActiveRecord::Migration
+    def self.up
+      execute "DROP SEQUENCE IF EXISTS seq_pk_customers"
+      execute "CREATE SEQUENCE seq_pk_customers"
+      columns = [
+        "bigint_serial_should_be_integer bigint default nextval('seq_pk_customers')",
+        "integer_serial_should_be_integer integer default nextval('seq_pk_customers')",
+        "varchar_should_be_string varchar(2)",
+        "timestamp_should_be_datetime timestamp",
+        "bytea_should_be_binary bytea",
+        "double_precision_should_be_float double precision",
+        "real_should_be_float real",
+        "bool_should_be_boolean bool",
+        "interval_should_be_string interval",
+        "bigint_should_be_integer bigint"
+      ]
+      columns << "uuid_should_be_string uuid" if PG_VERSION >= 80300
+      execute %Q{CREATE TABLE customers (\n #{columns.join(",\n")} \n)}
+    end
+
+    def self.down
+      execute "DROP TABLE customers"
+      execute "DROP SEQUENCE IF EXISTS seq_pk_customers"
+    end
+  end
+
+  class Customer < ActiveRecord::Base; end
+  
+  def self.startup
+    CustomersMigration.up
+  end
+
+  def self.shutdown
+    CustomersMigration.down
+  end
+
+  def column_type(column_name)
+    Customer.columns.detect { |c| c.name == column_name }.type
+  end
+
+  def test_uuid_column_should_map_to_string
+    return unless PG_VERSION >= 80300
+    if ar_version('4.0')
+      assert_equal :uuid, column_type("uuid_should_be_string")
+    else
+      assert_equal :string, column_type("uuid_should_be_string")
+    end
+  end
+  
+  def test_interval_should_be_mapped_to_string
+    if ar_version('4.0')
+      assert_equal :interval, column_type("interval_should_be_string")
+    else
+      assert_equal :string, column_type("interval_should_be_string")
+    end
+  end
+  
+  def test_bigint_serial_should_be_mapped_to_integer
+    assert_equal :integer, column_type("bigint_serial_should_be_integer")
+  end
+
+  def test_integer_serial_should_be_mapped_to_integer
+    assert_equal :integer, column_type("integer_serial_should_be_integer")
+  end
+
+  def test_varchar_should_be_mapped_to_string
+    assert_equal :string, column_type("varchar_should_be_string")
+  end
+
+  def test_timestamp_should_be_mapped_to_datetime
+    assert_equal :datetime, column_type("timestamp_should_be_datetime")
+  end
+
+  def test_bytea_should_be_mapped_to_binary
+    assert_equal :binary, column_type("bytea_should_be_binary")
+  end
+
+  def test_double_precision_should_be_mapped_to_float
+    assert_equal :float, column_type("double_precision_should_be_float")
+  end
+
+  def test_real_should_be_mapped_to_float
+    assert_equal :float, column_type("real_should_be_float")
+  end
+
+  def test_bool_should_be_mapped_to_boolean
+    assert_equal :boolean, column_type("bool_should_be_boolean")
+  end
+
+  def test_bigint_should_be_mapped_to_integer
+    assert_equal :integer, column_type("bigint_should_be_integer")
+  end
+  
+end
+
+class PostgresTypeConversionTest < Test::Unit::TestCase
+  
+  class BooleansMigration < ActiveRecord::Migration
+    def self.up
+      create_table :booleans do |t|
+        t.boolean :value, :default => false, :null => false
+      end
+    end
+
+    def self.down
+      drop_table :booleans
+    end
+  end
+
+  class Boolean < ActiveRecord::Base; end
+  
+  def self.startup
+    BooleansMigration.up
+  end
+
+  def self.shutdown
+    BooleansMigration.down
+  end
+
+  def test_conversion_with_boolean_relation
+    ActiveRecord::Base.connection.raw_connection.set_native_database_types
+  end
+  
+end