ibm_db 3.0.3-x86-mingw32 → 5.0.3-x86-mingw32

data/test/cases/statement_cache_test.rb

@@ -1,98 +1,136 @@
-require 'cases/helper'
-require 'models/book'
-require 'models/liquid'
-require 'models/molecule'
-require 'models/electron'
-
-module ActiveRecord
-  class StatementCacheTest < ActiveRecord::TestCase
-    def setup
-      @connection = ActiveRecord::Base.connection
-    end
-
-    #Cache v 1.1 tests
-    def test_statement_cache
-      Book.create(name: "my book")
-      Book.create(name: "my other book")
-
-      cache = StatementCache.create(Book.connection) do |params|
-        Book.where(:name => params.bind)
-      end
-
-      b = cache.execute([ "my book" ], Book, Book.connection)
-      assert_equal "my book", b[0].name
-      b = cache.execute([ "my other book" ], Book, Book.connection)
-      assert_equal "my other book", b[0].name
-    end
-
-
-    def test_statement_cache_id
-      b1 = Book.create(name: "my book")
-      b2 = Book.create(name: "my other book")
-
-      cache = StatementCache.create(Book.connection) do |params|
-        Book.where(id: params.bind)
-      end
-
-      b = cache.execute([ b1.id ], Book, Book.connection)
-      assert_equal b1.name, b[0].name
-      b = cache.execute([ b2.id ], Book, Book.connection)
-      assert_equal b2.name, b[0].name
-    end
-
-    def test_find_or_create_by
-      Book.create(name: "my book")
-
-      a = Book.find_or_create_by(name: "my book")
-      b = Book.find_or_create_by(name: "my other book")
-
-      assert_equal("my book", a.name)
-      assert_equal("my other book", b.name)
-    end
-
-    #End
-
-    def test_statement_cache_with_simple_statement
-      cache = ActiveRecord::StatementCache.create(Book.connection) do |params|
-        Book.where(name: "my book").where("author_id > 3")
-      end
-
-      Book.create(name: "my book", author_id: 4)
-
-      books = cache.execute([], Book, Book.connection)
-      assert_equal "my book", books[0].name
-    end
-
-    def test_statement_cache_with_complex_statement
-      cache = ActiveRecord::StatementCache.create(Book.connection) do |params|
-        Liquid.joins(:molecules => :electrons).where('molecules.name' => 'dioxane', 'electrons.name' => 'lepton')
-      end
-
-      salty = Liquid.create(name: 'salty')
-      molecule = salty.molecules.create(name: 'dioxane')
-      molecule.electrons.create(name: 'lepton')
-
-      liquids = cache.execute([], Book, Book.connection)
-      assert_equal "salty", liquids[0].name
-    end
-
-    def test_statement_cache_values_differ
-      cache = ActiveRecord::StatementCache.create(Book.connection) do |params|
-        Book.where(name: "my book")
-      end
-
-      3.times do
-        Book.create(name: "my book")
-      end
-
-      first_books = cache.execute([], Book, Book.connection)
-
-      3.times do
-        Book.create(name: "my book")
-      end
-
-      additional_books = cache.execute([], Book, Book.connection)
-      assert first_books != additional_books
-    end
-  end
-end
+require 'cases/helper'
+require 'models/book'
+require 'models/liquid'
+require 'models/molecule'
+require 'models/electron'
+
+module ActiveRecord
+  class StatementCacheTest < ActiveRecord::TestCase
+    def setup
+      @connection = ActiveRecord::Base.connection
+    end
+
+    #Cache v 1.1 tests
+    def test_statement_cache
+      Book.create(name: "my book")
+      Book.create(name: "my other book")
+
+      cache = StatementCache.create(Book.connection) do |params|
+        Book.where(:name => params.bind)
+      end
+
+      b = cache.execute([ "my book" ], Book, Book.connection)
+      assert_equal "my book", b[0].name
+      b = cache.execute([ "my other book" ], Book, Book.connection)
+      assert_equal "my other book", b[0].name
+    end
+
+
+    def test_statement_cache_id
+      b1 = Book.create(name: "my book")
+      b2 = Book.create(name: "my other book")
+
+      cache = StatementCache.create(Book.connection) do |params|
+        Book.where(id: params.bind)
+      end
+
+      b = cache.execute([ b1.id ], Book, Book.connection)
+      assert_equal b1.name, b[0].name
+      b = cache.execute([ b2.id ], Book, Book.connection)
+      assert_equal b2.name, b[0].name
+    end
+
+    def test_find_or_create_by
+      Book.create(name: "my book")
+
+      a = Book.find_or_create_by(name: "my book")
+      b = Book.find_or_create_by(name: "my other book")
+
+      assert_equal("my book", a.name)
+      assert_equal("my other book", b.name)
+    end
+
+    #End
+
+    def test_statement_cache_with_simple_statement
+      cache = ActiveRecord::StatementCache.create(Book.connection) do |params|
+        Book.where(name: "my book").where("author_id > 3")
+      end
+
+      Book.create(name: "my book", author_id: 4)
+
+      books = cache.execute([], Book, Book.connection)
+      assert_equal "my book", books[0].name
+    end
+
+    def test_statement_cache_with_complex_statement
+      cache = ActiveRecord::StatementCache.create(Book.connection) do |params|
+        Liquid.joins(:molecules => :electrons).where('molecules.name' => 'dioxane', 'electrons.name' => 'lepton')
+      end
+
+      salty = Liquid.create(name: 'salty')
+      molecule = salty.molecules.create(name: 'dioxane')
+      molecule.electrons.create(name: 'lepton')
+
+      liquids = cache.execute([], Book, Book.connection)
+      assert_equal "salty", liquids[0].name
+    end
+
+    def test_statement_cache_values_differ
+      cache = ActiveRecord::StatementCache.create(Book.connection) do |params|
+        Book.where(name: "my book")
+      end
+
+      3.times do
+        Book.create(name: "my book")
+      end
+
+      first_books = cache.execute([], Book, Book.connection)
+
+      3.times do
+        Book.create(name: "my book")
+      end
+
+      additional_books = cache.execute([], Book, Book.connection)
+      assert first_books != additional_books
+    end
+
+    def test_unprepared_statements_dont_share_a_cache_with_prepared_statements
+      Book.create(name: "my book")
+      Book.create(name: "my other book")
+
+      book = Book.find_by(name: "my book")
+      other_book = Book.connection.unprepared_statement do
+        Book.find_by(name: "my other book")
+      end
+
+      refute_equal book, other_book
+    end
+
+    def test_find_by_does_not_use_statement_cache_if_table_name_is_changed
+      book = Book.create(name: "my book")
+
+      Book.find_by(name: book.name) # warming the statement cache.
+
+      # changing the table name should change the query that is not cached.
+      Book.table_name = :birds
+      assert_nil Book.find_by(name: "my book")
+    ensure
+      Book.table_name = :books
+    end
+
+    def test_find_does_not_use_statement_cache_if_table_name_is_changed
+      book = Book.create(name: "my book")
+
+      Book.find(book.id) # warming the statement cache.
+
+      # changing the table name should change the query that is not cached.
+      Book.table_name = :birds
+      assert_raise ActiveRecord::RecordNotFound do
+        Book.find(book.id)
+      end
+    ensure
+      Book.table_name = :books
+    end
+  end
+end

data/test/cases/store_test.rb

@@ -1,194 +1,195 @@
-require 'cases/helper'
-require 'models/admin'
-require 'models/admin/user'
-
-class StoreTest < ActiveRecord::TestCase
-  fixtures :'admin/users'
-
-  setup do
-    @john = Admin::User.create!(:name => 'John Doe', :color => 'black', :remember_login => true, :height => 'tall', :is_a_good_guy => true)
-  end
-
-  test "reading store attributes through accessors" do
-    assert_equal 'black', @john.color
-    assert_nil @john.homepage
-  end
-
-  test "writing store attributes through accessors" do
-    @john.color = 'red'
-    @john.homepage = '37signals.com'
-
-    assert_equal 'red', @john.color
-    assert_equal '37signals.com', @john.homepage
-  end
-
-  test "accessing attributes not exposed by accessors" do
-    @john.settings[:icecream] = 'graeters'
-    @john.save
-
-    assert_equal 'graeters', @john.reload.settings[:icecream]
-  end
-
-  test "overriding a read accessor" do
-    @john.settings[:phone_number] = '1234567890'
-
-    assert_equal '(123) 456-7890', @john.phone_number
-  end
-
-  test "overriding a read accessor using super" do
-    @john.settings[:color] = nil
-
-    assert_equal 'red', @john.color
-  end
-
-  test "updating the store will mark it as changed" do
-    @john.color = 'red'
-    assert @john.settings_changed?
-  end
-
-  test "updating the store populates the changed array correctly" do
-    @john.color = 'red'
-    assert_equal 'black', @john.settings_change[0]['color']
-    assert_equal 'red', @john.settings_change[1]['color']
-  end
-
-  test "updating the store won't mark it as changed if an attribute isn't changed" do
-    @john.color = @john.color
-    assert !@john.settings_changed?
-  end
-
-  test "object initialization with not nullable column" do
-    assert_equal true, @john.remember_login
-  end
-
-  test "writing with not nullable column" do
-    @john.remember_login = false
-    assert_equal false, @john.remember_login
-  end
-
-  test "overriding a write accessor" do
-    @john.phone_number = '(123) 456-7890'
-
-    assert_equal '1234567890', @john.settings[:phone_number]
-  end
-
-  test "overriding a write accessor using super" do
-    @john.color = 'yellow'
-
-    assert_equal 'blue', @john.color
-  end
-
-  test "preserve store attributes data in HashWithIndifferentAccess format without any conversion" do
-    @john.json_data = ActiveSupport::HashWithIndifferentAccess.new(:height => 'tall', 'weight' => 'heavy')
-    @john.height = 'low'
-    assert_equal true, @john.json_data.instance_of?(ActiveSupport::HashWithIndifferentAccess)
-    assert_equal 'low', @john.json_data[:height]
-    assert_equal 'low', @john.json_data['height']
-    assert_equal 'heavy', @john.json_data[:weight]
-    assert_equal 'heavy', @john.json_data['weight']
-  end
-
-  test "convert store attributes from Hash to HashWithIndifferentAccess saving the data and access attributes indifferently" do
-    user = Admin::User.find_by_name('Jamis')
-    assert_equal 'symbol',  user.settings[:symbol]
-    assert_equal 'symbol',  user.settings['symbol']
-    assert_equal 'string',  user.settings[:string]
-    assert_equal 'string',  user.settings['string']
-    assert_equal true,      user.settings.instance_of?(ActiveSupport::HashWithIndifferentAccess)
-
-    user.height = 'low'
-    assert_equal 'symbol',  user.settings[:symbol]
-    assert_equal 'symbol',  user.settings['symbol']
-    assert_equal 'string',  user.settings[:string]
-    assert_equal 'string',  user.settings['string']
-    assert_equal true,      user.settings.instance_of?(ActiveSupport::HashWithIndifferentAccess)
-  end
-
-  test "convert store attributes from any format other than Hash or HashWithIndifferent access losing the data" do
-    @john.json_data = "somedata"
-    @john.height = 'low'
-    assert_equal true, @john.json_data.instance_of?(ActiveSupport::HashWithIndifferentAccess)
-    assert_equal 'low', @john.json_data[:height]
-    assert_equal 'low', @john.json_data['height']
-    assert_equal false, @john.json_data.delete_if { |k, v| k == 'height' }.any?
-  end
-
-  test "reading store attributes through accessors encoded with JSON" do
-    assert_equal 'tall', @john.height
-    assert_nil @john.weight
-  end
-
-  test "writing store attributes through accessors encoded with JSON" do
-    @john.height = 'short'
-    @john.weight = 'heavy'
-
-    assert_equal 'short', @john.height
-    assert_equal 'heavy', @john.weight
-  end
-
-  test "accessing attributes not exposed by accessors encoded with JSON" do
-    @john.json_data['somestuff'] = 'somecoolstuff'
-    @john.save
-
-    assert_equal 'somecoolstuff', @john.reload.json_data['somestuff']
-  end
-
-  test "updating the store will mark it as changed encoded with JSON" do
-    @john.height = 'short'
-    assert @john.json_data_changed?
-  end
-
-  test "object initialization with not nullable column encoded with JSON" do
-    assert_equal true, @john.is_a_good_guy
-  end
-
-  test "writing with not nullable column encoded with JSON" do
-    @john.is_a_good_guy = false
-    assert_equal false, @john.is_a_good_guy
-  end
-
-  test "all stored attributes are returned" do
-    assert_equal [:color, :homepage, :favorite_food], Admin::User.stored_attributes[:settings]
-  end
-
-  test "stored_attributes are tracked per class" do
-    first_model = Class.new(ActiveRecord::Base) do
-      store_accessor :data, :color
-    end
-    second_model = Class.new(ActiveRecord::Base) do
-      store_accessor :data, :width, :height
-    end
-
-    assert_equal [:color], first_model.stored_attributes[:data]
-    assert_equal [:width, :height], second_model.stored_attributes[:data]
-  end
-
-  test "stored_attributes are tracked per subclass" do
-    first_model = Class.new(ActiveRecord::Base) do
-      store_accessor :data, :color
-    end
-    second_model = Class.new(first_model) do
-      store_accessor :data, :width, :height
-    end
-    third_model = Class.new(first_model) do
-      store_accessor :data, :area, :volume
-    end
-
-    assert_equal [:color], first_model.stored_attributes[:data]
-    assert_equal [:color, :width, :height], second_model.stored_attributes[:data]
-    assert_equal [:color, :area, :volume], third_model.stored_attributes[:data]
-  end
-
-  test "YAML coder initializes the store when a Nil value is given" do
-    assert_equal({}, @john.params)
-  end
-
-  test "dump, load and dump again a model" do
-    dumped = YAML.dump(@john)
-    loaded = YAML.load(dumped)
-    assert_equal @john, loaded
-
-    second_dump = YAML.dump(loaded)
-    assert_equal @john, YAML.load(second_dump)
-  end
-end
+require 'cases/helper'
+require 'models/admin'
+require 'models/admin/user'
+
+class StoreTest < ActiveRecord::TestCase
+  fixtures :'admin/users'
+
+  setup do
+    @john = Admin::User.create!(:name => 'John Doe', :color => 'black', :remember_login => true, :height => 'tall', :is_a_good_guy => true)
+  end
+
+  test "reading store attributes through accessors" do
+    assert_equal 'black', @john.color
+    assert_nil @john.homepage
+  end
+
+  test "writing store attributes through accessors" do
+    @john.color = 'red'
+    @john.homepage = '37signals.com'
+
+    assert_equal 'red', @john.color
+    assert_equal '37signals.com', @john.homepage
+  end
+
+  test "accessing attributes not exposed by accessors" do
+    @john.settings[:icecream] = 'graeters'
+    @john.save
+
+    assert_equal 'graeters', @john.reload.settings[:icecream]
+  end
+
+  test "overriding a read accessor" do
+    @john.settings[:phone_number] = '1234567890'
+
+    assert_equal '(123) 456-7890', @john.phone_number
+  end
+
+  test "overriding a read accessor using super" do
+    @john.settings[:color] = nil
+
+    assert_equal 'red', @john.color
+  end
+
+  test "updating the store will mark it as changed" do
+    @john.color = 'red'
+    assert @john.settings_changed?
+  end
+
+  test "updating the store populates the changed array correctly" do
+    @john.color = 'red'
+    assert_equal 'black', @john.settings_change[0]['color']
+    assert_equal 'red', @john.settings_change[1]['color']
+  end
+
+  test "updating the store won't mark it as changed if an attribute isn't changed" do
+    @john.color = @john.color
+    assert !@john.settings_changed?
+  end
+
+  test "object initialization with not nullable column" do
+    assert_equal true, @john.remember_login
+  end
+
+  test "writing with not nullable column" do
+    @john.remember_login = false
+    assert_equal false, @john.remember_login
+  end
+
+  test "overriding a write accessor" do
+    @john.phone_number = '(123) 456-7890'
+
+    assert_equal '1234567890', @john.settings[:phone_number]
+  end
+
+  test "overriding a write accessor using super" do
+    @john.color = 'yellow'
+
+    assert_equal 'blue', @john.color
+  end
+
+  test "preserve store attributes data in HashWithIndifferentAccess format without any conversion" do
+    @john.json_data = ActiveSupport::HashWithIndifferentAccess.new(:height => 'tall', 'weight' => 'heavy')
+    @john.height = 'low'
+    assert_equal true, @john.json_data.instance_of?(ActiveSupport::HashWithIndifferentAccess)
+    assert_equal 'low', @john.json_data[:height]
+    assert_equal 'low', @john.json_data['height']
+    assert_equal 'heavy', @john.json_data[:weight]
+    assert_equal 'heavy', @john.json_data['weight']
+  end
+
+  test "convert store attributes from Hash to HashWithIndifferentAccess saving the data and access attributes indifferently" do
+    user = Admin::User.find_by_name('Jamis')
+    assert_equal 'symbol',  user.settings[:symbol]
+    assert_equal 'symbol',  user.settings['symbol']
+    assert_equal 'string',  user.settings[:string]
+    assert_equal 'string',  user.settings['string']
+    assert_equal true,      user.settings.instance_of?(ActiveSupport::HashWithIndifferentAccess)
+
+    user.height = 'low'
+    assert_equal 'symbol',  user.settings[:symbol]
+    assert_equal 'symbol',  user.settings['symbol']
+    assert_equal 'string',  user.settings[:string]
+    assert_equal 'string',  user.settings['string']
+    assert_equal true,      user.settings.instance_of?(ActiveSupport::HashWithIndifferentAccess)
+  end
+
+  test "convert store attributes from any format other than Hash or HashWithIndifferentAccess losing the data" do
+    @john.json_data = "somedata"
+    @john.height = 'low'
+    assert_equal true, @john.json_data.instance_of?(ActiveSupport::HashWithIndifferentAccess)
+    assert_equal 'low', @john.json_data[:height]
+    assert_equal 'low', @john.json_data['height']
+    assert_equal false, @john.json_data.delete_if { |k, v| k == 'height' }.any?
+  end
+
+  test "reading store attributes through accessors encoded with JSON" do
+    assert_equal 'tall', @john.height
+    assert_nil @john.weight
+  end
+
+  test "writing store attributes through accessors encoded with JSON" do
+    @john.height = 'short'
+    @john.weight = 'heavy'
+
+    assert_equal 'short', @john.height
+    assert_equal 'heavy', @john.weight
+  end
+
+  test "accessing attributes not exposed by accessors encoded with JSON" do
+    @john.json_data['somestuff'] = 'somecoolstuff'
+    @john.save
+
+    assert_equal 'somecoolstuff', @john.reload.json_data['somestuff']
+  end
+
+  test "updating the store will mark it as changed encoded with JSON" do
+    @john.height = 'short'
+    assert @john.json_data_changed?
+  end
+
+  test "object initialization with not nullable column encoded with JSON" do
+    assert_equal true, @john.is_a_good_guy
+  end
+
+  test "writing with not nullable column encoded with JSON" do
+    @john.is_a_good_guy = false
+    assert_equal false, @john.is_a_good_guy
+  end
+
+  test "all stored attributes are returned" do
+    assert_equal [:color, :homepage, :favorite_food], Admin::User.stored_attributes[:settings]
+  end
+
+  test "stored_attributes are tracked per class" do
+    first_model = Class.new(ActiveRecord::Base) do
+      store_accessor :data, :color
+    end
+    second_model = Class.new(ActiveRecord::Base) do
+      store_accessor :data, :width, :height
+    end
+
+    assert_equal [:color], first_model.stored_attributes[:data]
+    assert_equal [:width, :height], second_model.stored_attributes[:data]
+  end
+
+  test "stored_attributes are tracked per subclass" do
+    first_model = Class.new(ActiveRecord::Base) do
+      store_accessor :data, :color
+    end
+    second_model = Class.new(first_model) do
+      store_accessor :data, :width, :height
+    end
+    third_model = Class.new(first_model) do
+      store_accessor :data, :area, :volume
+    end
+
+    assert_equal [:color], first_model.stored_attributes[:data]
+    assert_equal [:color, :width, :height], second_model.stored_attributes[:data]
+    assert_equal [:color, :area, :volume], third_model.stored_attributes[:data]
+    assert_equal [:color], first_model.stored_attributes[:data]
+  end
+
+  test "YAML coder initializes the store when a Nil value is given" do
+    assert_equal({}, @john.params)
+  end
+
+  test "dump, load and dump again a model" do
+    dumped = YAML.dump(@john)
+    loaded = YAML.load(dumped)
+    assert_equal @john, loaded
+
+    second_dump = YAML.dump(loaded)
+    assert_equal @john, YAML.load(second_dump)
+  end
+end