kb-activerecord-jdbc-adapter 0.9.7.1-java

data/test/models/entry.rb

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'active_record'
+
+class CreateEntries < ActiveRecord::Migration
+  def self.up
+    create_table "entries", :force => true do |t|
+      t.column :title, :string, :limit => 100
+      t.column :updated_on, :datetime
+      t.column :content, :text
+      t.column :rating, :decimal, :precision => 10, :scale => 2
+    end
+  end
+
+  def self.down
+    drop_table "entries"
+  end
+end
+
+class Entry < ActiveRecord::Base
+  def to_param
+    "#{id}-#{title.gsub(/[^a-zA-Z0-9]/, '-')}"
+  end
+end

data/test/models/mixed_case.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'active_record'
+
+module Migration
+  class MixedCase < ActiveRecord::Migration
+    
+    def self.up
+      create_table "mixed_cases" do |t|
+        t.column :SOME_value, :string
+      end
+    end
+    
+    def self.down
+      drop_table "mixed_cases"
+    end
+  end
+end
+
+class MixedCase < ActiveRecord::Base
+end

data/test/models/reserved_word.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'active_record'
+
+class CreateReservedWords < ActiveRecord::Migration
+  def self.up
+    create_table "reserved_words", :force => true do |t|
+      t.column :position, :integer
+      t.column :select, :integer
+    end
+  end
+
+  def self.down
+    drop_table "reserved_words"
+  end
+end
+
+class ReservedWord < ActiveRecord::Base
+end

data/test/models/string_id.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'active_record'
+
+class CreateStringIds < ActiveRecord::Migration
+  def self.up
+    create_table "string_ids", :force => true, :id => false do |t|
+      t.string :id
+    end
+  end
+
+  def self.down
+    drop_table "string_ids"
+  end
+end
+
+class StringId < ActiveRecord::Base
+  def self.table_name () "string_ids" end
+end

data/test/models/validates_uniqueness_of_string.rb

@@ -0,0 +1,19 @@
+class CreateValidatesUniquenessOf < ActiveRecord::Migration
+  def self.up
+    create_table "validates_uniqueness_of", :force => true do |t|
+      t.column :cs_string, :string
+      t.column :ci_string, :string
+      t.column :content, :text
+    end
+  end
+
+  def self.down
+    drop_table "validates_uniqueness_of"
+  end
+end
+
+class ValidatesUniquenessOfString < ActiveRecord::Base
+  self.set_table_name "validates_uniqueness_of"
+  validates_uniqueness_of :cs_string, :case_sensitive => true
+  validates_uniqueness_of :ci_string, :case_sensitive => false
+end

data/test/mssql_db_create_test.rb

@@ -0,0 +1,26 @@
+require 'abstract_db_create'
+require 'db/mssql'
+
+class MysqlDbCreateTest < Test::Unit::TestCase
+  include AbstractDbCreate
+
+  def db_config
+    MSSQL_CONFIG
+  end
+  
+  def test_rake_db_create
+    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"))
+    select = "SELECT NAME FROM sys.sysdatabases"
+    select = "SELECT name FROM master..sysdatabases ORDER BY name" if ActiveRecord::Base.connection.sqlserver_version == "2000"
+    databases = ActiveRecord::Base.connection.select_rows(select).flatten
+    assert databases.include?(@db_name)
+  end
+end

data/test/mssql_identity_insert_test.rb

@@ -0,0 +1,19 @@
+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/mssql_legacy_types_test.rb

@@ -0,0 +1,58 @@
+require 'jdbc_common'
+require 'db/mssql'
+
+ActiveRecord::Schema.verbose = false
+
+class CreateArticles < ActiveRecord::Migration
+
+  def self.up
+    execute <<-SQL
+      CREATE TABLE articles (
+        [id] int NOT NULL IDENTITY(1, 1) PRIMARY KEY, 
+        [title] VARCHAR(100), 
+        [author] VARCHAR(60) DEFAULT 'anonymous', 
+        [body] TEXT
+      )
+    SQL
+  end
+
+  def self.down
+    drop_table "articles"
+  end
+
+end
+
+class Article < ActiveRecord::Base
+end
+
+class MsSQLLegacyTypesTest < Test::Unit::TestCase
+
+  def setup
+    CreateArticles.up
+    @connection = ActiveRecord::Base.connection
+  end
+
+  def teardown
+    CreateArticles.down
+    ActiveRecord::Base.clear_active_connections!
+  end
+
+  def test_varchar_column
+    Article.create!(:title => "Blah blah")
+    article = Article.first
+    assert_equal("Blah blah", article.title)
+  end
+  
+  SAMPLE_TEXT = "Lorem ipsum dolor sit amet ..."
+  
+  def test_text_column
+    Article.create!(:body => SAMPLE_TEXT)
+    article = Article.first
+    assert_equal(SAMPLE_TEXT, article.body)
+  end
+  
+  def test_varchar_default_value
+    assert_equal("anonymous", Article.new.author)
+  end
+  
+end

data/test/mssql_limit_offset_test.rb

@@ -0,0 +1,108 @@
+require 'jdbc_common'
+require 'db/mssql'
+
+ActiveRecord::Schema.verbose = false
+
+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 MsSQLLimitOffsetTest < Test::Unit::TestCase
+
+  def setup
+    CreateLongShips.up
+    CreateVikings.up
+    @connection = ActiveRecord::Base.connection
+  end
+
+  def teardown
+    CreateVikings.down
+    CreateLongShips.down
+    ActiveRecord::Base.clear_active_connections!
+  end
+
+  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")
+    ships = Viking.find(:all, :include => :long_ship, :offset => 1, :limit => 2)
+    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")
+  
+    vikings = Viking.find(:all, :include => :long_ship, :order => "long_ships.name, vikings.name", :offset => 0, :limit => 3)
+    assert_equal(["Adam", "Carl", "Ben"], vikings.map(&:name))
+
+  end
+  
+end

data/test/mssql_multibyte_test.rb

@@ -0,0 +1,18 @@
+#! /usr/bin/env jruby
+
+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/mssql_simple_test.rb

@@ -0,0 +1,49 @@
+require 'jdbc_common'
+require 'db/mssql'
+
+class MsSQLSimpleTest < Test::Unit::TestCase
+
+  include SimpleTestMethods
+
+  # MS SQL 2005 doesn't have a DATE class, only TIMESTAMP.
+  undef_method :test_save_date
+
+  # String comparisons are insensitive by default
+  undef_method :test_validates_uniqueness_of_strings_case_sensitive
+
+  def test_does_not_munge_quoted_strings
+    example_quoted_values = [%{'quoted'}, %{D'oh!}]
+    example_quoted_values.each do |value|
+      entry = Entry.create!(:title => value)
+      entry.reload
+      assert_equal(value, entry.title)
+    end
+  end
+
+  def test_change_column_default
+
+    Entry.connection.change_column "entries", "title", :string, :default => "new default"
+    Entry.reset_column_information
+    assert_equal("new default", Entry.new.title)
+
+    Entry.connection.change_column "entries", "title", :string, :default => nil
+    Entry.reset_column_information
+    assert_equal(nil, Entry.new.title)
+
+  end
+
+  def test_change_column_nullability
+    
+    Entry.connection.change_column "entries", "title", :string, :null => true
+    Entry.reset_column_information
+    title_column = Entry.columns.find { |c| c.name == "title" }
+    assert(title_column.null)
+
+    Entry.connection.change_column "entries", "title", :string, :null => false
+    Entry.reset_column_information
+    title_column = Entry.columns.find { |c| c.name == "title" }
+    assert(!title_column.null)
+
+  end
+
+end

data/test/mysql_db_create_test.rb

@@ -0,0 +1,25 @@
+require 'abstract_db_create'
+require 'db/mysql'
+
+class MysqlDbCreateTest < Test::Unit::TestCase
+  include AbstractDbCreate
+
+  def db_config
+    MYSQL_CONFIG
+  end
+
+  if find_executable?("mysql")
+    def test_rake_db_create
+      Rake::Task["db:create"].invoke
+      output = nil
+      IO.popen("mysql -u #{MYSQL_CONFIG[:username]} --password=#{MYSQL_CONFIG[:password]}", "r+") do |mysql|
+        mysql << "show databases where `Database` = '#{@db_name}';"
+        mysql.close_write
+        assert mysql.read =~ /#{@db_name}/m
+      end
+    end
+  else
+    def test_skipped
+    end
+  end
+end

data/test/mysql_info_test.rb

@@ -0,0 +1,62 @@
+require 'jdbc_common'
+require 'db/mysql'
+
+class DBSetup < ActiveRecord::Migration
+  
+  def self.up
+    create_table :books do |t|
+      t.string :title
+    end
+    
+    create_table :cars, :primary_key => 'legacy_id' do |t|
+      t.string :name
+    end
+    
+    create_table :cats, :id => false do |t|
+      t.string :name
+    end
+    
+  end
+
+  def self.down
+    drop_table :books
+    drop_table :cars
+    drop_table :cats
+  end
+
+end
+
+class MysqlInfoTest < Test::Unit::TestCase
+
+  def setup
+    DBSetup.up
+    @connection = ActiveRecord::Base.connection
+  end
+
+  def teardown
+    DBSetup.down
+  end
+
+  ## primary_key
+  def test_should_return_the_primary_key_of_a_table
+    assert_equal 'id', @connection.primary_key('books')
+  end
+  
+  def test_should_be_able_to_return_a_custom_primary_key
+    assert_equal 'legacy_id', @connection.primary_key('cars')
+  end
+
+  def test_should_return_nil_for_a_table_without_a_primary_key
+    assert_nil @connection.primary_key('cats')
+  end
+  
+  ## structure_dump
+  def test_should_include_the_tables_in_a_structure_dump
+    # TODO: Improve these tests, I added this one because no other tests exists for this method.
+    dump = @connection.structure_dump
+    assert dump.include?('CREATE TABLE `books`')
+    assert dump.include?('CREATE TABLE `cars`')
+    assert dump.include?('CREATE TABLE `cats`')
+  end
+
+end