activerecord-nuodb-adapter 1.0.3 → 1.0.4

data/test/cases/adapters/postgresql/sql_types_test.rb

@@ -0,0 +1,18 @@
+require "cases/helper"
+
+class SqlTypesTest < ActiveRecord::TestCase
+  def test_binary_types
+    assert_equal 'bytea', type_to_sql(:binary, 100_000)
+    assert_raise ActiveRecord::ActiveRecordError do
+      type_to_sql :binary, 4294967295
+    end
+    assert_equal 'text', type_to_sql(:text, 100_000)
+    assert_raise ActiveRecord::ActiveRecordError do
+      type_to_sql :text, 4294967295
+    end
+  end
+
+  def type_to_sql(*args)
+    ActiveRecord::Base.connection.type_to_sql(*args)
+  end
+end

data/test/cases/adapters/postgresql/statement_pool_test.rb

@@ -0,0 +1,39 @@
+require 'cases/helper'
+
+module ActiveRecord::ConnectionAdapters
+  class PostgreSQLAdapter < AbstractAdapter
+    class InactivePGconn
+      def query(*args)
+        raise PGError
+      end
+
+      def status
+        PGconn::CONNECTION_BAD
+      end
+    end
+
+    class StatementPoolTest < ActiveRecord::TestCase
+      def test_cache_is_per_pid
+        return skip('must support fork') unless Process.respond_to?(:fork)
+
+        cache = StatementPool.new nil, 10
+        cache['foo'] = 'bar'
+        assert_equal 'bar', cache['foo']
+
+        pid = fork {
+          lookup = cache['foo'];
+          exit!(!lookup)
+        }
+
+        Process.waitpid pid
+        assert $?.success?, 'process should exit successfully'
+      end
+
+      def test_dealloc_does_not_raise_on_inactive_connection
+        cache = StatementPool.new InactivePGconn.new, 10
+        cache['foo'] = 'bar'
+        assert_nothing_raised { cache.clear }
+      end
+    end
+  end
+end

data/test/cases/adapters/postgresql/timestamp_test.rb

@@ -0,0 +1,113 @@
+require 'cases/helper'
+require 'models/developer'
+require 'models/topic'
+
+class TimestampTest < ActiveRecord::TestCase
+  fixtures :topics
+
+  def test_group_by_date
+    keys = Topic.group("date_trunc('month', created_at)").count.keys
+    assert_operator keys.length, :>, 0
+    keys.each { |k| assert_kind_of Time, k }
+  end
+
+  def test_load_infinity_and_beyond
+    unless current_adapter?(:PostgreSQLAdapter)
+      return skip("only tested on postgresql")
+    end
+
+    d = Developer.find_by_sql("select 'infinity'::timestamp as updated_at")
+    assert d.first.updated_at.infinite?, 'timestamp should be infinite'
+
+    d = Developer.find_by_sql("select '-infinity'::timestamp as updated_at")
+    time = d.first.updated_at
+    assert time.infinite?, 'timestamp should be infinite'
+    assert_operator time, :<, 0
+  end
+
+  def test_save_infinity_and_beyond
+    unless current_adapter?(:PostgreSQLAdapter)
+      return skip("only tested on postgresql")
+    end
+
+    d = Developer.create!(:name => 'aaron', :updated_at => 1.0 / 0.0)
+    assert_equal(1.0 / 0.0, d.updated_at)
+
+    d = Developer.create!(:name => 'aaron', :updated_at => -1.0 / 0.0)
+    assert_equal(-1.0 / 0.0, d.updated_at)
+  end
+
+  def test_default_datetime_precision
+    ActiveRecord::Base.connection.create_table(:foos)
+    ActiveRecord::Base.connection.add_column :foos, :created_at, :datetime
+    ActiveRecord::Base.connection.add_column :foos, :updated_at, :datetime
+    assert_nil activerecord_column_option('foos', 'created_at', 'precision')
+  end
+
+  def test_timestamp_data_type_with_precision
+    ActiveRecord::Base.connection.create_table(:foos)
+    ActiveRecord::Base.connection.add_column :foos, :created_at, :datetime, :precision => 0
+    ActiveRecord::Base.connection.add_column :foos, :updated_at, :datetime, :precision => 5
+    assert_equal 0, activerecord_column_option('foos', 'created_at', 'precision')
+    assert_equal 5, activerecord_column_option('foos', 'updated_at', 'precision')
+  end
+
+  def test_timestamps_helper_with_custom_precision
+    ActiveRecord::Base.connection.create_table(:foos) do |t|
+      t.timestamps :precision => 4
+    end
+    assert_equal 4, activerecord_column_option('foos', 'created_at', 'precision')
+    assert_equal 4, activerecord_column_option('foos', 'updated_at', 'precision')
+  end
+
+  def test_passing_precision_to_timestamp_does_not_set_limit
+    ActiveRecord::Base.connection.create_table(:foos) do |t|
+      t.timestamps :precision => 4
+    end
+    assert_nil activerecord_column_option("foos", "created_at", "limit")
+    assert_nil activerecord_column_option("foos", "updated_at", "limit")
+  end
+
+  def test_invalid_timestamp_precision_raises_error
+    assert_raises ActiveRecord::ActiveRecordError do
+      ActiveRecord::Base.connection.create_table(:foos) do |t|
+        t.timestamps :precision => 7
+      end
+    end
+  end
+
+  def test_postgres_agrees_with_activerecord_about_precision
+    ActiveRecord::Base.connection.create_table(:foos) do |t|
+      t.timestamps :precision => 4
+    end
+    assert_equal '4', pg_datetime_precision('foos', 'created_at')
+    assert_equal '4', pg_datetime_precision('foos', 'updated_at')
+  end
+
+  def test_bc_timestamp
+    unless current_adapter?(:PostgreSQLAdapter)
+      return skip("only tested on postgresql")
+    end
+    date = Date.new(0) - 1.second
+    Developer.create!(:name => "aaron", :updated_at => date)
+    assert_equal date, Developer.find_by_name("aaron").updated_at
+  end
+
+  private
+
+    def pg_datetime_precision(table_name, column_name)
+      results = ActiveRecord::Base.connection.execute("SELECT column_name, datetime_precision FROM information_schema.columns WHERE table_name ='#{table_name}'")
+      result = results.find do |result_hash|
+        result_hash["column_name"] == column_name
+      end
+      result && result["datetime_precision"]
+    end
+
+    def activerecord_column_option(tablename, column_name, option)
+      result = ActiveRecord::Base.connection.columns(tablename).find do |column|
+        column.name == column_name
+      end
+      result && result.send(option)
+    end
+
+end

data/test/cases/adapters/postgresql/utils_test.rb

@@ -0,0 +1,20 @@
+require 'cases/helper'
+
+class PostgreSQLUtilsTest < ActiveSupport::TestCase
+  include ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::Utils
+
+  def test_extract_schema_and_table
+    {
+      %(table_name)            => [nil,'table_name'],
+      %("table.name")          => [nil,'table.name'],
+      %(schema.table_name)     => %w{schema table_name},
+      %("schema".table_name)   => %w{schema table_name},
+      %(schema."table_name")   => %w{schema table_name},
+      %("schema"."table_name") => %w{schema table_name},
+      %("even spaces".table)   => ['even spaces','table'],
+      %(schema."table.name")   => ['schema', 'table.name']
+    }.each do |given, expect|
+      assert_equal expect, extract_schema_and_table(given)
+    end
+  end
+end

data/test/cases/adapters/postgresql/uuid_test.rb

@@ -0,0 +1,95 @@
+# encoding: utf-8
+
+require "cases/helper"
+require 'active_record/base'
+require 'active_record/connection_adapters/postgresql_adapter'
+
+class PostgresqlUUIDTest < ActiveRecord::TestCase
+  class UUID < ActiveRecord::Base
+    self.table_name = 'pg_uuids'
+  end
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+
+    unless @connection.supports_extensions?
+      return skip "do not test on PG without uuid-ossp"
+    end
+
+    unless @connection.extension_enabled?('uuid-ossp')
+      @connection.enable_extension 'uuid-ossp'
+      @connection.commit_db_transaction
+    end
+
+    @connection.reconnect!
+
+    @connection.transaction do
+      @connection.create_table('pg_uuids', id: :uuid) do |t|
+        t.string 'name'
+        t.uuid 'other_uuid', default: 'uuid_generate_v4()'
+      end
+    end
+  end
+
+  def teardown
+    @connection.execute 'drop table if exists pg_uuids'
+  end
+
+  def test_id_is_uuid
+    assert_equal :uuid, UUID.columns_hash['id'].type
+    assert UUID.primary_key
+  end
+
+  def test_id_has_a_default
+    u = UUID.create
+    assert_not_nil u.id
+  end
+
+  def test_auto_create_uuid
+    u = UUID.create
+    u.reload
+    assert_not_nil u.other_uuid
+  end
+
+  def test_pk_and_sequence_for_uuid_primary_key
+    pk, seq = @connection.pk_and_sequence_for('pg_uuids')
+    assert_equal 'id', pk
+    assert_equal nil, seq
+  end
+
+  def test_schema_dumper_for_uuid_primary_key
+    schema = StringIO.new
+    ActiveRecord::SchemaDumper.dump(@connection, schema)
+    assert_match(/\bcreate_table "pg_uuids", id: :uuid\b/, schema.string)
+  end
+end
+
+class PostgresqlUUIDTestNilDefault < ActiveRecord::TestCase
+  class UUID < ActiveRecord::Base
+    self.table_name = 'pg_uuids'
+  end
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+    @connection.reconnect!
+
+    @connection.transaction do
+      @connection.create_table('pg_uuids', id: false) do |t|
+        t.primary_key :id, :uuid, default: nil
+        t.string 'name'
+      end
+    end
+  end
+
+  def teardown
+    @connection.execute 'drop table if exists pg_uuids'
+  end
+
+  def test_id_allows_default_override_via_nil
+    col_desc = @connection.execute("SELECT pg_get_expr(d.adbin, d.adrelid) as default
+                                    FROM pg_attribute a
+                                    LEFT JOIN pg_attrdef d ON a.attrelid = d.adrelid AND a.attnum = d.adnum
+                                    WHERE a.attname='id' AND a.attrelid = 'pg_uuids'::regclass").first
+    assert_nil col_desc["default"]
+  end
+end

data/test/cases/adapters/postgresql/view_test.rb

@@ -0,0 +1,49 @@
+require "cases/helper"
+
+class ViewTest < ActiveRecord::TestCase
+  self.use_transactional_fixtures = false
+
+  SCHEMA_NAME = 'test_schema'
+  TABLE_NAME = 'things'
+  VIEW_NAME = 'view_things'
+  COLUMNS = [
+    'id integer',
+    'name character varying(50)',
+    'email character varying(50)',
+    'moment timestamp without time zone'
+  ]
+
+  class ThingView < ActiveRecord::Base
+    self.table_name = 'test_schema.view_things'
+  end
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+    @connection.execute "CREATE SCHEMA #{SCHEMA_NAME} CREATE TABLE #{TABLE_NAME} (#{COLUMNS.join(',')})"
+    @connection.execute "CREATE TABLE #{SCHEMA_NAME}.\"#{TABLE_NAME}.table\" (#{COLUMNS.join(',')})"
+    @connection.execute "CREATE VIEW #{SCHEMA_NAME}.#{VIEW_NAME} AS SELECT id,name,email,moment FROM #{SCHEMA_NAME}.#{TABLE_NAME}"
+  end
+
+  def teardown
+    @connection.execute "DROP SCHEMA #{SCHEMA_NAME} CASCADE"
+  end
+
+  def test_table_exists
+    name = ThingView.table_name
+    assert @connection.table_exists?(name), "'#{name}' table should exist"
+  end
+
+  def test_column_definitions
+    assert_nothing_raised do
+      assert_equal COLUMNS, columns("#{SCHEMA_NAME}.#{VIEW_NAME}")
+    end
+  end
+
+  private
+    def columns(table_name)
+      @connection.send(:column_definitions, table_name).map do |name, type, default|
+        "#{name} #{type}" + (default ? " default #{default}" : '')
+      end
+    end
+
+end

data/test/cases/adapters/sqlite3/copy_table_test.rb

@@ -0,0 +1,99 @@
+require "cases/helper"
+
+class CopyTableTest < ActiveRecord::TestCase
+  fixtures :customers, :companies, :comments, :binaries
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+    class << @connection
+      public :copy_table, :table_structure, :indexes
+    end
+  end
+
+  def test_copy_table(from = 'customers', to = 'customers2', options = {})
+    assert_nothing_raised {copy_table(from, to, options)}
+    assert_equal row_count(from), row_count(to)
+
+    if block_given?
+      yield from, to, options
+    else
+      assert_equal column_names(from), column_names(to)
+    end
+
+    @connection.drop_table(to) rescue nil
+  end
+
+  def test_copy_table_renaming_column
+    test_copy_table('customers', 'customers2',
+        :rename => {'name' => 'person_name'}) do |from, to, options|
+      expected = column_values(from, 'name')
+      assert_equal expected, column_values(to, 'person_name')
+      assert expected.any?, "No values in table: #{expected.inspect}"
+    end
+  end
+
+  def test_copy_table_allows_to_pass_options_to_create_table
+    @connection.create_table('blocker_table')
+    test_copy_table('customers', 'blocker_table', force: true)
+  end
+
+  def test_copy_table_with_index
+    test_copy_table('comments', 'comments_with_index') do
+      @connection.add_index('comments_with_index', ['post_id', 'type'])
+      test_copy_table('comments_with_index', 'comments_with_index2') do
+        assert_equal table_indexes_without_name('comments_with_index'),
+                     table_indexes_without_name('comments_with_index2')
+      end
+    end
+  end
+
+  def test_copy_table_without_primary_key
+    test_copy_table('developers_projects', 'programmers_projects') do
+      assert_nil @connection.primary_key('programmers_projects')
+    end
+  end
+
+  def test_copy_table_with_id_col_that_is_not_primary_key
+    test_copy_table('goofy_string_id', 'goofy_string_id2') do
+      original_id = @connection.columns('goofy_string_id').detect{|col| col.name == 'id' }
+      copied_id = @connection.columns('goofy_string_id2').detect{|col| col.name == 'id' }
+      assert_equal original_id.type, copied_id.type
+      assert_equal original_id.sql_type, copied_id.sql_type
+      assert_equal original_id.limit, copied_id.limit
+      assert_equal original_id.primary, copied_id.primary
+    end
+  end
+
+  def test_copy_table_with_unconventional_primary_key
+    test_copy_table('owners', 'owners_unconventional') do
+      original_pk = @connection.primary_key('owners')
+      copied_pk = @connection.primary_key('owners_unconventional')
+      assert_equal original_pk, copied_pk
+    end
+  end
+
+  def test_copy_table_with_binary_column
+    test_copy_table 'binaries', 'binaries2'
+  end
+
+protected
+  def copy_table(from, to, options = {})
+    @connection.copy_table(from, to, {:temporary => true}.merge(options))
+  end
+
+  def column_names(table)
+    @connection.table_structure(table).map {|column| column['name']}
+  end
+
+  def column_values(table, column)
+    @connection.select_all("SELECT #{column} FROM #{table} ORDER BY id").map {|row| row[column]}
+  end
+
+  def table_indexes_without_name(table)
+    @connection.indexes(table).delete(:name)
+  end
+
+  def row_count(table)
+    @connection.select_one("SELECT COUNT(*) AS count FROM #{table}")['count']
+  end
+end

data/test/cases/adapters/sqlite3/explain_test.rb

@@ -0,0 +1,26 @@
+require "cases/helper"
+require 'models/developer'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class SQLite3Adapter
+      class ExplainTest < ActiveRecord::TestCase
+        fixtures :developers
+
+        def test_explain_for_one_query
+          explain = Developer.where(:id => 1).explain
+          assert_match %(EXPLAIN for: SELECT "developers".* FROM "developers"  WHERE "developers"."id" = 1), explain
+          assert_match(/(SEARCH )?TABLE developers USING (INTEGER )?PRIMARY KEY/, explain)
+        end
+
+        def test_explain_with_eager_loading
+          explain = Developer.where(:id => 1).includes(:audit_logs).explain
+          assert_match %(EXPLAIN for: SELECT "developers".* FROM "developers"  WHERE "developers"."id" = 1), explain
+          assert_match(/(SEARCH )?TABLE developers USING (INTEGER )?PRIMARY KEY/, explain)
+          assert_match %(EXPLAIN for: SELECT "audit_logs".* FROM "audit_logs"  WHERE "audit_logs"."developer_id" IN (1)), explain
+          assert_match(/(SCAN )?TABLE audit_logs/, explain)
+        end
+      end
+    end
+  end
+end