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

data/test/db/mssql/binary_test.rb

@@ -1,6 +0,0 @@
-require 'db/mssql'
-require 'binary'
-
-class MSSQLBinaryTest < Test::Unit::TestCase
-  include BinaryTestMethods
-end

data/test/db/mssql/exec_proc_test.rb

@@ -1,46 +0,0 @@
-require 'test_helper'
-require 'db/mssql'
-
-class MSSQLExecProcTest < Test::Unit::TestCase
-  
-  def self.startup
-    ActiveRecord::Base.connection.
-      create_table :sample_table, :force => true do |t|
-        t.column :sample_column, :datetime
-      end
-    # ActiveRecord::Base.logger.level = Logger::DEBUG
-  end
-
-  def self.shutdown
-    # ActiveRecord::Base.logger.level = Logger::WARN
-    ActiveRecord::Base.connection.drop_table :sample_table
-  end
-
-  test 'execute a simple procedure' do
-    tables = connection.execute_procedure :sp_tables
-    assert_instance_of Array, tables
-    assert tables.first.respond_to?(:keys)
-  end
-  
-  test 'takes parameter arguments' do
-    tables = connection.execute_procedure :sp_tables, 'sample_table'
-    table_info = tables.first
-    assert_equal 1, tables.size
-    assert_equal 'TABLE', table_info['TABLE_TYPE']
-    assert_equal 'sample_table', table_info['TABLE_NAME']
-  end
-  
-  test 'takes named parameter arguments' do
-    tables = connection.exec_proc :sp_tables, :table_name => 'tables', :table_owner => 'sys'
-    table_info = tables.first
-    assert_equal 1, tables.size
-    assert_equal 'VIEW', table_info['TABLE_TYPE'], "Table Info: #{table_info.inspect}"
-  end
-  
-  private
-  
-  def connection
-    ActiveRecord::Base.connection
-  end
-  
-end

data/test/db/mssql/identity_insert_test.rb

@@ -1,18 +0,0 @@
-require 'jdbc_common'
-require 'db/mssql'
-
-class MSSQLIdentityInsertTest < Test::Unit::TestCase
-  include MigrationSetup
-  
-  def test_enable_identity_insert_when_necessary
-    Entry.connection.execute("INSERT INTO entries([id], [title]) VALUES (333, 'Title')")
-    Entry.connection.execute("INSERT INTO entries([title], [id]) VALUES ('Title', 344)")
-    Entry.connection.execute("INSERT INTO entries(id, title) VALUES (666, 'Title')")
-    Entry.connection.execute("INSERT INTO entries(id, title) (SELECT id+123, title FROM entries)")
-  end
-
-  def test_dont_enable_identity_insert_when_unnecessary
-    Entry.connection.execute("INSERT INTO entries([title]) VALUES ('[id]')")
-  end
-
-end

data/test/db/mssql/ignore_system_views_test.rb

@@ -1,40 +0,0 @@
-require 'jdbc_common'
-require 'db/mssql'
-
-class MSSQLIgnoreSystemViewsTest < Test::Unit::TestCase
-  include MigrationSetup
-
-  def test_system_views_ignored
-    assert_not_include tables, 'views'
-    if ActiveRecord::Base.connection.sqlserver_version == "2000"
-      assert_false table_exists?("sys.views"), %{table_exists?("sys.views")}
-      assert_false table_exists?("information_schema.views"), %{table_exists?("information_schema.views")}
-    else
-      assert_true table_exists?("sys.views"), %{table_exists?("sys.views")}
-      assert_true table_exists?("information_schema.views"), %{table_exists?("information_schema.views")}
-      
-      assert_true table_exists?(:views), %{table_exists?(:views)}
-    end
-    assert_false table_exists?("dbo.views"), %{table_exists?("dbo.views")}
-    #assert_false table_exists?(:views), %{table_exists?(:views)}
-    ActiveRecord::Schema.define { suppress_messages { create_table :views } }
-    assert_include tables, 'views'
-    assert_true table_exists?(:views), %{table_exists?(:views)}
-    ActiveRecord::Schema.define { suppress_messages { drop_table :views } }
-    #assert_false table_exists?(:views), %{table_exists?(:views)}
-  ensure
-    ActiveRecord::Base.connection.drop_table(:views) rescue nil
-  end
-
-  private
-
-  def tables
-    ActiveRecord::Base.connection.tables
-  end
-  
-  def table_exists?(*args)
-    ActiveRecord::Base.connection.table_exists?(*args)
-  end
-    
-end
-

data/test/db/mssql/limit_offset_test.rb

@@ -1,190 +0,0 @@
-require 'jdbc_common'
-require 'db/mssql'
-
-class MSSQLLimitOffsetTest < Test::Unit::TestCase
-
-  class CreateLegacyShips < ActiveRecord::Migration
-
-    def self.up
-      create_table "legacy_ships",{:primary_key => :ShipKey} do |t|
-        t.string "name", :limit => 50, :null => false
-        t.integer "width", :default => 123
-        t.integer "length", :default => 456
-      end
-    end
-
-    def self.down
-      drop_table "legacy_ships"
-    end
-
-  end
-
-  class LegacyShip < ActiveRecord::Base
-    self.primary_key = "ShipKey"
-  end
-
-  class CreateLongShips < ActiveRecord::Migration
-
-    def self.up
-      create_table "long_ships", :force => true do |t|
-        t.string "name", :limit => 50, :null => false
-        t.integer "width", :default => 123
-        t.integer "length", :default => 456
-      end
-    end
-
-    def self.down
-      drop_table "long_ships"
-    end
-
-  end
-
-  class LongShip < ActiveRecord::Base
-    has_many :vikings
-  end
-
-  class CreateVikings < ActiveRecord::Migration
-
-    def self.up
-      create_table "vikings", :force => true do |t|
-        t.integer "long_ship_id", :null => false
-        t.string "name", :limit => 50, :default => "Sven"
-      end
-    end
-
-    def self.down
-      drop_table "vikings"
-    end
-
-  end
-
-  class Viking < ActiveRecord::Base
-    belongs_to :long_ship
-  end
-
-
-  class CreateNoIdVikings < ActiveRecord::Migration
-    def self.up
-      create_table "no_id_vikings", :force => true do |t|
-        t.string "name", :limit => 50, :default => "Sven"
-      end
-      remove_column "no_id_vikings", "id"
-    end
-
-    def self.down
-      drop_table "no_id_vikings"
-    end
-  end
-
-  class NoIdViking < ActiveRecord::Base
-  end
-  
-  def setup
-    CreateLegacyShips.up
-    CreateLongShips.up
-    CreateVikings.up
-    CreateNoIdVikings.up
-    ActiveRecord::Base.connection
-  end
-
-  def teardown
-    CreateLegacyShips.down
-    CreateVikings.down
-    CreateLongShips.down
-    CreateNoIdVikings.down
-    ActiveRecord::Base.clear_active_connections!
-  end
-
-  def test_limit_with_no_id_column_available
-    NoIdViking.create!(:name => 'Erik')
-    #assert_nothing_raised(ActiveRecord::StatementInvalid) do 
-      NoIdViking.first
-    #end
-  end
-
-  def test_limit_with_alternate_named_primary_key
-    %w(one two three four five six seven eight).each do |name|
-      LegacyShip.create!(:name => name)
-    end
-    ships = LegacyShip.limit(3)
-    assert_equal(3, ships.size)
-  end if ar_version('3.0')
-
-  def test_limit_and_offset
-    %w(one two three four five six seven eight).each do |name|
-      LongShip.create!(:name => name)
-    end
-    ship_names = LongShip.find(:all, :offset => 2, :limit => 3).map(&:name)
-    assert_equal(%w(three four five), ship_names)
-  end
-
-  def test_limit_and_offset_with_order
-    %w(one two three four five six seven eight).each do |name|
-      LongShip.create!(:name => name)
-    end
-    ship_names = LongShip.find(:all, :order => "name", :offset => 4, :limit => 2).map(&:name)
-    assert_equal(%w(seven six), ship_names)
-  end
-
-  # TODO: work out how to fix DISTINCT support without breaking :include
-  # def test_limit_and_offset_with_distinct
-  #   %w(c a b a b a c d c d).each do |name|
-  #     LongShip.create!(:name => name)
-  #   end
-  #   ship_names = LongShip.find(:all, :select => "DISTINCT name", :order => "name", :offset => 1, :limit => 2).map(&:name)
-  #   assert_equal(%w(b c), ship_names)
-  # end
-
-  def test_limit_and_offset_with_include
-    skei = LongShip.create!(:name => "Skei")
-    skei.vikings.create!(:name => "Bob")
-    skei.vikings.create!(:name => "Ben")
-    skei.vikings.create!(:name => "Basil")
-    if ar_version('4.0')
-      ships = Viking.includes(:long_ship).offset(1).limit(2) #.all
-    else
-      ships = Viking.find(:all, :include => :long_ship, :offset => 1, :limit => 2)
-    end
-    assert_equal(2, ships.size)
-  end
-
-  def test_limit_and_offset_with_include_and_order
-    boat1 = LongShip.create!(:name => "1-Skei")
-    boat2 = LongShip.create!(:name => "2-Skei")
-
-    boat1.vikings.create!(:name => "Adam")
-    boat2.vikings.create!(:name => "Ben")
-    boat1.vikings.create!(:name => "Carl")
-    boat2.vikings.create!(:name => "Donald")
-
-    if ar_version('4.0')
-      vikings = Viking.includes(:long_ship).order('long_ships.name, vikings.name').references(:long_ship).offset(0).limit(3)
-    else
-      vikings = Viking.find(:all, :include => :long_ship, :order => "long_ships.name, vikings.name", :offset => 0, :limit => 3)
-    end
-    assert_equal ["Adam", "Carl", "Ben"], vikings.map(&:name)
-  end
- 
-  def test_offset_without_limit
-    %w( egy keto harom negy ot hat het nyolc ).each do |name|
-      LongShip.create!(:name => name)
-    end
-    error = assert_raise ActiveRecord::ActiveRecordError do
-      if ar_version('3.0')
-        LongShip.select(:name).offset(2).all
-      else
-        LongShip.find(:all, :select => 'name', :offset => 2)
-      end
-    end
-    assert_equal "You must specify :limit with :offset.", error.message
-  end
-
-  def test_limit_with_group_by
-    %w( one two three four five six seven eight ).each do |name|
-      LongShip.create!(:name => name)
-    end
-    ships = LongShip.select(:name).group(:name).limit(2).all
-    assert_equal ['one', 'two'], ships.map(&:name)
-  end if ar_version('3.0')
-  
-end

data/test/db/mssql/multibyte_test.rb

@@ -1,16 +0,0 @@
-# encoding: utf-8
-require 'jdbc_common'
-require 'db/mssql'
-
-class MSSQLMultibyteTest < Test::Unit::TestCase
-  include MultibyteTestMethods
-
-  def test_select_multibyte_string
-    Entry.create!(:title => 'テスト', :content => '本文')
-    entry = Entry.find(:last)
-    assert_equal "テスト", entry.title
-    assert_equal "本文", entry.content
-    assert_equal entry, Entry.find_by_title("テスト")
-  end
-    
-end

data/test/db/mssql/multiple_connections_test.rb

@@ -1,71 +0,0 @@
-require 'test_helper'
-require 'db/mssql'
-
-class MSSQLMultipleConnectionsTest < Test::Unit::TestCase
-  
-  MSSQL_CONFIG2 = { :adapter  => 'mssql' }
-  MSSQL_CONFIG2[:database] = ENV['SQL2DATABASE']
-  MSSQL_CONFIG2[:username] = ENV['SQL2USER'] || MSSQL_CONFIG[:username]
-  MSSQL_CONFIG2[:password] = ENV['SQL2PASS'] || MSSQL_CONFIG[:password]
-  MSSQL_CONFIG2[:host] = MSSQL_CONFIG[:host]
-  MSSQL_CONFIG2[:port] = MSSQL_CONFIG[:port]
-  
-  OLD_CONFIG = ActiveRecord::Base.configurations.dup
-  
-  if MSSQL_CONFIG2[:database]
-    
-    class Database1 < ActiveRecord::Base
-      self.abstract_class = true
-      #establish_connection 'db1'
-    end
-    
-    class Model1 < Database1
-    end
-    
-    class Database2 < ActiveRecord::Base
-      self.abstract_class = true
-      #establish_connection 'db2'
-    end
-    
-    class Model2 < Database2
-    end
-    
-    def self.startup
-      ActiveRecord::Base.clear_active_connections!
-      ActiveRecord::Base.configurations.replace('db1' => MSSQL_CONFIG, 'db2' => MSSQL_CONFIG2)
-      
-      Database1.establish_connection 'db1'
-      Database2.establish_connection 'db2'
-      
-      Database1.connection.execute "CREATE TABLE [model1s] " + 
-        "([id] int NOT NULL IDENTITY(1, 1) PRIMARY KEY, [name] NVARCHAR(10))"
-      Database2.connection.execute "CREATE TABLE [model2s] " + 
-        "([id] int NOT NULL IDENTITY(1, 1) PRIMARY KEY, [name] NVARCHAR(10))"
-    end
-    
-    def self.shutdown
-      Database1.connection.execute "DROP TABLE [model1s]"
-      Database2.connection.execute "DROP TABLE [model2s]"
-      
-      ActiveRecord::Base.clear_active_connections!
-      
-      ActiveRecord::Base.configurations.replace OLD_CONFIG
-      ActiveRecord::Base.establish_connection MSSQL_CONFIG
-    end
-    
-    test "create and retrieve models" do
-      assert_nil Model1.first
-      assert_nil Model2.first
-      
-      Model1.create :name => 'm1'
-      Model2.create :name => 'm2'
-      
-      assert_not_nil Model1.first
-      assert_not_nil Model2.first
-    end
-    
-  else
-    puts "#{self.name} skipped since no second MS-SQL database configured"
-  end
-  
-end

data/test/db/mssql/rake_test.rb

@@ -1,143 +0,0 @@
-require 'rake_test_support'
-require 'db/mssql'
-
-class MSSQLRakeDbCreateTest < Test::Unit::TestCase
-  include RakeTestSupport
-
-  def db_config
-    MSSQL_CONFIG
-  end
-
-  def do_teardown
-    drop_rake_test_database(:silence)
-  end
-  
-  test 'rake db:create (and db:drop)' do
-    begin
-      Rake::Task["db:create"].invoke
-    rescue => e
-      if e.message =~ /CREATE DATABASE permission denied/
-        puts "\nwarning: db:create test skipped; add 'dbcreator' role to user '#{db_config[:username]}' to run"
-        return
-      end
-    end
-
-    ActiveRecord::Base.establish_connection(db_config.merge(:database => "master"))
-    assert_include databases, db_name
-
-    Rake::Task["db:drop"].invoke
-
-    ActiveRecord::Base.establish_connection(db_config.merge(:database => "master"))
-    assert_not_include databases, db_name
-  end
-
-  test 'rake db:drop (non-existing database)' do
-    drop_rake_test_database(:silence)
-    Rake::Task["db:drop"].invoke
-  end
-  
-  test 'rake db:test:purge' do
-    # Rake::Task["db:create"].invoke
-    create_rake_test_database do |connection|
-      connection.create_table('users') { |t| t.string :name }
-    end
-    
-    Rake::Task["db:test:purge"].invoke
-
-    ActiveRecord::Base.establish_connection db_config.merge :database => db_name
-    assert_false ActiveRecord::Base.connection.table_exists?('users')
-    ActiveRecord::Base.connection.disconnect!
-  end
-
-  test 'rake db:structure:dump (and db:structure:load)' do
-    omit('smoscript not available') unless self.class.find_executable?('smoscript')
-    # Rake::Task["db:create"].invoke
-    create_rake_test_database do |connection|
-      create_schema_migrations_table(connection)
-      connection.create_table('users') { |t| t.string :name; t.timestamps }
-    end
-    
-    structure_sql = File.join('db', structure_sql_filename)
-    begin
-      Dir.mkdir 'db' # db/structure.sql
-      Rake::Task["db:structure:dump"].invoke
-      
-      assert File.exists?(structure_sql)
-      # CREATE TABLE [dbo].[users]( ... )
-      assert_match /CREATE TABLE .*?\[users\]/i, File.read(structure_sql)
-      
-      # db:structure:load
-      drop_rake_test_database(:silence)
-      create_rake_test_database
-      Rake::Task["db:structure:load"].invoke
-      
-      ActiveRecord::Base.establish_connection db_config.merge :database => db_name
-      assert ActiveRecord::Base.connection.table_exists?('users')
-      ActiveRecord::Base.connection.disconnect!
-    ensure
-      File.delete(structure_sql) if File.exists?(structure_sql)
-      Dir.rmdir 'db'
-    end
-  end
-  
-  setup { rm_r 'db' if File.exist?('db') }
-  
-  test 'rake db:charset' do
-    create_rake_test_database
-    # using the default character set, the character_set_name should be 
-    # iso_1 (ISO 8859-1) for the char and varchar data types
-    expect_rake_output /iso_1|UCS/i
-    Rake::Task["db:charset"].invoke
-  end
-
-  test 'rake db:collation' do
-    create_rake_test_database
-    # default (for iso_1) : 'SQL_Latin1_General_CP1_CI_AS'
-    expect_rake_output /SQL_.*/
-    Rake::Task["db:collation"].invoke
-  end
-  
-  # @override
-  def create_rake_test_database(db_name = self.db_name)
-    ActiveRecord::Base.establish_connection db_config
-    connection = ActiveRecord::Base.connection
-    unless connection.database_exists?(db_name)
-      # connection.use_database('master')
-      connection.create_database(db_name, db_config)
-    end
-    
-    if block_given?
-      ActiveRecord::Base.establish_connection db_config.merge :database => db_name
-      yield ActiveRecord::Base.connection
-    end
-    ActiveRecord::Base.connection.disconnect!
-  end
-  
-  # @override
-  def drop_rake_test_database(silence = false)
-    ActiveRecord::Base.establish_connection db_config
-    connection = ActiveRecord::Base.connection
-    begin
-      #current_db_name = connection.current_database
-      #if current_db_name.upcase == db_name.upcase
-        connection.use_database('master')
-      #end
-      connection.drop_database(db_name)
-    rescue => e
-      raise e unless silence
-    end
-    ActiveRecord::Base.connection.disconnect!
-  end
-  
-  private
-  
-  def databases
-    if ActiveRecord::Base.connection.send(:sqlserver_2000?)
-      select = "SELECT name FROM master..sysdatabases ORDER BY name"
-    else
-      select = "SELECT name FROM sys.sysdatabases"
-    end
-    ActiveRecord::Base.connection.select_rows(select).flatten
-  end
-  
-end