activerecord-jdbc-adapter 1.3.0.beta2 → 1.3.0.rc1

data/test/db/postgres/hstore_test.rb

@@ -1,200 +0,0 @@
-# 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

@@ -1,30 +0,0 @@
-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

@@ -1,86 +0,0 @@
-# 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

@@ -1,51 +0,0 @@
-# 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.transaction do
-      disable_logger(connection) do
-        connection.create_table('ltrees') do |t|
-          t.ltree 'path'
-        end
-      end
-    end
-    @@ltree_support = true
-  rescue ActiveRecord::ActiveRecordError => e
-    puts "skiping ltree tests due: #{e.message}" unless e.message.index('type "ltree" does not exist')
-    @@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/mixed_case_test.rb

@@ -1,29 +0,0 @@
-require 'jdbc_common'
-require 'models/entry'
-require 'models/mixed_case'
-
-class MixedCaseTest < Test::Unit::TestCase
-  def setup
-    Migration::MixedCase.up
-    @table_name = User.table_name
-    User.table_name = 'tblUsers'
-    User.reset_column_information
-  end
-
-  def teardown
-    User.table_name = @table_name
-    User.reset_column_information
-    Migration::MixedCase.down
-  end
-
-  def test_create
-    mixed_case = MixedCase.create :SOME_value => 'some value'
-    assert_equal 'some value', mixed_case.SOME_value
-  end
-
-  def test_find_mixed_table_name
-    User.create :firstName => "Nick", :lastName => "Sieger"
-    u = User.find :first
-    assert_equal "Nick Sieger", "#{u.firstName} #{u.lastName}"
-  end
-end

data/test/db/postgres/native_types_test.rb

@@ -1,124 +0,0 @@
-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
-    assert_equal :string, column_type("interval_should_be_string")
-  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