activerecord-nuodb-adapter 1.0.3 → 1.0.4

data/test/cases/integration_test.rb

@@ -0,0 +1,87 @@
+require 'cases/helper'
+require 'models/company'
+require 'models/developer'
+require 'models/car'
+require 'models/bulb'
+
+class IntegrationTest < ActiveRecord::TestCase
+  fixtures :companies, :developers
+
+  def test_to_param_should_return_string
+    assert_kind_of String, Client.first.to_param
+  end
+
+  def test_to_param_returns_nil_if_not_persisted
+    client = Client.new
+    assert_equal nil, client.to_param
+  end
+
+  def test_to_param_returns_id_if_not_persisted_but_id_is_set
+    client = Client.new
+    client.id = 1
+    assert_equal '1', client.to_param
+  end
+
+  def test_cache_key_for_existing_record_is_not_timezone_dependent
+    ActiveRecord::Base.time_zone_aware_attributes = true
+
+    Time.zone = 'UTC'
+    utc_key = Developer.first.cache_key
+
+    Time.zone = 'EST'
+    est_key = Developer.first.cache_key
+
+    assert_equal utc_key, est_key
+  end
+
+  def test_cache_key_format_for_existing_record_with_updated_at
+    dev = Developer.first
+    assert_equal "developers/#{dev.id}-#{dev.updated_at.utc.to_s(:nsec)}", dev.cache_key
+  end
+
+  def test_cache_key_format_for_existing_record_with_updated_at_and_custom_cache_timestamp_format
+    dev = CachedDeveloper.first
+    assert_equal "cached_developers/#{dev.id}-#{dev.updated_at.utc.to_s(:number)}", dev.cache_key
+  end
+
+  def test_cache_key_changes_when_child_touched
+    car = Car.create
+    Bulb.create(car: car)
+
+    key = car.cache_key
+    car.bulb.touch
+    car.reload
+    assert_not_equal key, car.cache_key
+  end
+
+  def test_cache_key_format_for_existing_record_with_nil_updated_timestamps
+    dev = Developer.first
+    dev.update_columns(updated_at: nil, updated_on: nil)
+    assert_match(/\/#{dev.id}$/, dev.cache_key)
+  end
+
+  def test_cache_key_for_updated_on
+    dev = Developer.first
+    dev.updated_at = nil
+    assert_equal "developers/#{dev.id}-#{dev.updated_on.utc.to_s(:nsec)}", dev.cache_key
+  end
+
+  def test_cache_key_for_newer_updated_at
+    dev = Developer.first
+    dev.updated_at += 3600
+    assert_equal "developers/#{dev.id}-#{dev.updated_at.utc.to_s(:nsec)}", dev.cache_key
+  end
+
+  def test_cache_key_for_newer_updated_on
+    dev = Developer.first
+    dev.updated_on += 3600
+    assert_equal "developers/#{dev.id}-#{dev.updated_on.utc.to_s(:nsec)}", dev.cache_key
+  end
+
+  def test_cache_key_format_is_precise_enough
+    dev = Developer.first
+    key = dev.cache_key
+    dev.touch
+    assert_not_equal key, dev.cache_key
+  end
+end

data/test/cases/invalid_connection_test.rb

@@ -0,0 +1,22 @@
+require "cases/helper"
+
+class TestAdapterWithInvalidConnection < ActiveRecord::TestCase
+  self.use_transactional_fixtures = false
+
+  class Bird < ActiveRecord::Base
+  end
+
+  def setup
+    # Can't just use current adapter; sqlite3 will create a database
+    # file on the fly.
+    Bird.establish_connection adapter: 'mysql', database: 'i_do_not_exist'
+  end
+
+  def teardown
+    Bird.remove_connection
+  end
+
+  test "inspect on Model class does not raise" do
+    assert_equal "#{Bird.name}(no database connection)", Bird.inspect
+  end
+end

data/test/cases/invalid_date_test.rb

@@ -0,0 +1,32 @@
+require 'cases/helper'
+require 'models/topic'
+
+class InvalidDateTest < ActiveRecord::TestCase
+  def test_assign_valid_dates
+    valid_dates = [[2007, 11, 30], [1993, 2, 28], [2008, 2, 29]]
+
+    invalid_dates = [[2007, 11, 31], [1993, 2, 29], [2007, 2, 29]]
+
+    valid_dates.each do |date_src|
+      topic = Topic.new("last_read(1i)" => date_src[0].to_s, "last_read(2i)" => date_src[1].to_s, "last_read(3i)" => date_src[2].to_s)
+      # Oracle DATE columns are datetime columns and Oracle adapter returns Time value
+      if current_adapter?(:OracleAdapter)
+        assert_equal(topic.last_read.to_date, Date.new(*date_src))
+      else
+        assert_equal(topic.last_read, Date.new(*date_src))
+      end
+    end
+
+    invalid_dates.each do |date_src|
+      assert_nothing_raised do
+        topic = Topic.new({"last_read(1i)" => date_src[0].to_s, "last_read(2i)" => date_src[1].to_s, "last_read(3i)" => date_src[2].to_s})
+        # Oracle DATE columns are datetime columns and Oracle adapter returns Time value
+        if current_adapter?(:OracleAdapter)
+          assert_equal(topic.last_read.to_date, Time.local(*date_src).to_date, "The date should be modified according to the behavior of the Time object")
+        else
+          assert_equal(topic.last_read, Time.local(*date_src).to_date, "The date should be modified according to the behavior of the Time object")
+        end
+      end
+    end
+  end
+end

data/test/cases/invertible_migration_test.rb

@@ -0,0 +1,259 @@
+require "cases/helper"
+
+module ActiveRecord
+  class InvertibleMigrationTest < ActiveRecord::TestCase
+    class SilentMigration < ActiveRecord::Migration
+      def write(text = '')
+        # sssshhhhh!!
+      end
+    end
+
+    class InvertibleMigration < SilentMigration
+      def change
+        create_table("horses") do |t|
+          t.column :content, :text
+          t.column :remind_at, :datetime
+        end
+      end
+    end
+
+    class InvertibleRevertMigration < SilentMigration
+      def change
+        revert do
+          create_table("horses") do |t|
+            t.column :content, :text
+            t.column :remind_at, :datetime
+          end
+        end
+      end
+    end
+
+    class InvertibleByPartsMigration < SilentMigration
+      attr_writer :test
+      def change
+        create_table("new_horses") do |t|
+          t.column :breed, :string
+        end
+        reversible do |dir|
+          @test.yield :both
+          dir.up    { @test.yield :up }
+          dir.down  { @test.yield :down }
+        end
+        revert do
+          create_table("horses") do |t|
+            t.column :content, :text
+            t.column :remind_at, :datetime
+          end
+        end
+      end
+    end
+
+    class NonInvertibleMigration < SilentMigration
+      def change
+        create_table("horses") do |t|
+          t.column :content, :text
+          t.column :remind_at, :datetime
+        end
+        remove_column "horses", :content
+      end
+    end
+
+    class RemoveIndexMigration1 < SilentMigration
+      def self.up
+        create_table("horses") do |t|
+          t.column :name, :string
+          t.column :color, :string
+          t.index [:name, :color]
+        end
+      end
+    end
+
+    class RemoveIndexMigration2 < SilentMigration
+      def change
+        change_table("horses") do |t|
+          t.remove_index [:name, :color]
+        end
+      end
+    end
+
+    class LegacyMigration < ActiveRecord::Migration
+      def self.up
+        create_table("horses") do |t|
+          t.column :content, :text
+          t.column :remind_at, :datetime
+        end
+      end
+
+      def self.down
+        drop_table("horses")
+      end
+    end
+
+    class RevertWholeMigration < SilentMigration
+      def initialize(name = self.class.name, version = nil, migration)
+        @migration = migration
+        super(name, version)
+      end
+
+      def change
+        revert @migration
+      end
+    end
+
+    class NestedRevertWholeMigration < RevertWholeMigration
+      def change
+        revert { super }
+      end
+    end
+
+    def teardown
+      %w[horses new_horses].each do |table|
+        if ActiveRecord::Base.connection.table_exists?(table)
+          ActiveRecord::Base.connection.drop_table(table)
+        end
+      end
+    end
+
+    def test_no_reverse
+      migration = NonInvertibleMigration.new
+      migration.migrate(:up)
+      assert_raises(IrreversibleMigration) do
+        migration.migrate(:down)
+      end
+    end
+
+    def test_exception_on_removing_index_without_column_option
+      RemoveIndexMigration1.new.migrate(:up)
+      migration = RemoveIndexMigration2.new
+      migration.migrate(:up)
+
+      assert_raises(IrreversibleMigration) do
+        migration.migrate(:down)
+      end
+    end
+
+    def test_migrate_up
+      migration = InvertibleMigration.new
+      migration.migrate(:up)
+      assert migration.connection.table_exists?("horses"), "horses should exist"
+    end
+
+    def test_migrate_down
+      migration = InvertibleMigration.new
+      migration.migrate :up
+      migration.migrate :down
+      assert !migration.connection.table_exists?("horses")
+    end
+
+    def test_migrate_revert
+      migration = InvertibleMigration.new
+      revert = InvertibleRevertMigration.new
+      migration.migrate :up
+      revert.migrate :up
+      assert !migration.connection.table_exists?("horses")
+      revert.migrate :down
+      assert migration.connection.table_exists?("horses")
+      migration.migrate :down
+      assert !migration.connection.table_exists?("horses")
+    end
+
+    def test_migrate_revert_by_part
+      InvertibleMigration.new.migrate :up
+      received = []
+      migration = InvertibleByPartsMigration.new
+      migration.test = ->(dir){
+        assert migration.connection.table_exists?("horses")
+        assert migration.connection.table_exists?("new_horses")
+        received << dir
+      }
+      migration.migrate :up
+      assert_equal [:both, :up], received
+      assert !migration.connection.table_exists?("horses")
+      assert migration.connection.table_exists?("new_horses")
+      migration.migrate :down
+      assert_equal [:both, :up, :both, :down], received
+      assert migration.connection.table_exists?("horses")
+      assert !migration.connection.table_exists?("new_horses")
+    end
+
+    def test_migrate_revert_whole_migration
+      migration = InvertibleMigration.new
+      [LegacyMigration, InvertibleMigration].each do |klass|
+        revert = RevertWholeMigration.new(klass)
+        migration.migrate :up
+        revert.migrate :up
+        assert !migration.connection.table_exists?("horses")
+        revert.migrate :down
+        assert migration.connection.table_exists?("horses")
+        migration.migrate :down
+        assert !migration.connection.table_exists?("horses")
+      end
+    end
+
+    def test_migrate_nested_revert_whole_migration
+      revert = NestedRevertWholeMigration.new(InvertibleRevertMigration)
+      revert.migrate :down
+      assert revert.connection.table_exists?("horses")
+      revert.migrate :up
+      assert !revert.connection.table_exists?("horses")
+    end
+
+    def test_revert_order
+      block = Proc.new{|t| t.string :name }
+      recorder = ActiveRecord::Migration::CommandRecorder.new(ActiveRecord::Base.connection)
+      recorder.instance_eval do
+        create_table("apples", &block)
+        revert do
+          create_table("bananas", &block)
+          revert do
+            create_table("clementines")
+            create_table("dates")
+          end
+          create_table("elderberries")
+        end
+        revert do
+          create_table("figs")
+          create_table("grapes")
+        end
+      end
+      assert_equal [[:create_table, ["apples"], block], [:drop_table, ["elderberries"], nil],
+                    [:create_table, ["clementines"], nil], [:create_table, ["dates"], nil],
+                    [:drop_table, ["bananas"], block], [:drop_table, ["grapes"], nil],
+                    [:drop_table, ["figs"], nil]], recorder.commands
+    end
+
+    def test_legacy_up
+      LegacyMigration.migrate :up
+      assert ActiveRecord::Base.connection.table_exists?("horses"), "horses should exist"
+    end
+
+    def test_legacy_down
+      LegacyMigration.migrate :up
+      LegacyMigration.migrate :down
+      assert !ActiveRecord::Base.connection.table_exists?("horses"), "horses should not exist"
+    end
+
+    def test_up
+      LegacyMigration.up
+      assert ActiveRecord::Base.connection.table_exists?("horses"), "horses should exist"
+    end
+
+    def test_down
+      LegacyMigration.up
+      LegacyMigration.down
+      assert !ActiveRecord::Base.connection.table_exists?("horses"), "horses should not exist"
+    end
+
+    def test_migrate_down_with_table_name_prefix
+      ActiveRecord::Base.table_name_prefix = 'p_'
+      ActiveRecord::Base.table_name_suffix = '_s'
+      migration = InvertibleMigration.new
+      migration.migrate(:up)
+      assert_nothing_raised { migration.migrate(:down) }
+      assert !ActiveRecord::Base.connection.table_exists?("p_horses_s"), "p_horses_s should not exist"
+    ensure
+      ActiveRecord::Base.table_name_prefix = ActiveRecord::Base.table_name_suffix = ''
+    end
+
+  end
+end

data/test/cases/json_serialization_test.rb

@@ -0,0 +1,300 @@
+require "cases/helper"
+require 'models/contact'
+require 'models/post'
+require 'models/author'
+require 'models/tagging'
+require 'models/tag'
+require 'models/comment'
+
+module JsonSerializationHelpers
+  private
+
+  def set_include_root_in_json(value)
+    original_root_in_json = ActiveRecord::Base.include_root_in_json
+    ActiveRecord::Base.include_root_in_json = value
+    yield
+  ensure
+    ActiveRecord::Base.include_root_in_json = original_root_in_json
+  end
+end
+
+class JsonSerializationTest < ActiveRecord::TestCase
+  include JsonSerializationHelpers
+
+  class NamespacedContact < Contact
+    column :name, :string
+  end
+
+  def setup
+    @contact = Contact.new(
+      :name        => 'Konata Izumi',
+      :age         => 16,
+      :avatar      => 'binarydata',
+      :created_at  => Time.utc(2006, 8, 1),
+      :awesome     => true,
+      :preferences => { :shows => 'anime' }
+    )
+  end
+
+  def test_should_demodulize_root_in_json
+    set_include_root_in_json(true) do
+      @contact = NamespacedContact.new name: 'whatever'
+      json = @contact.to_json
+      assert_match %r{^\{"namespaced_contact":\{}, json
+    end
+  end
+
+  def test_should_include_root_in_json
+    set_include_root_in_json(true) do
+      json = @contact.to_json
+
+      assert_match %r{^\{"contact":\{}, json
+      assert_match %r{"name":"Konata Izumi"}, json
+      assert_match %r{"age":16}, json
+      assert json.include?(%("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
+      assert_match %r{"awesome":true}, json
+      assert_match %r{"preferences":\{"shows":"anime"\}}, json
+    end
+  end
+
+  def test_should_encode_all_encodable_attributes
+    json = @contact.to_json
+
+    assert_match %r{"name":"Konata Izumi"}, json
+    assert_match %r{"age":16}, json
+    assert json.include?(%("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
+    assert_match %r{"awesome":true}, json
+    assert_match %r{"preferences":\{"shows":"anime"\}}, json
+  end
+
+  def test_should_allow_attribute_filtering_with_only
+    json = @contact.to_json(:only => [:name, :age])
+
+    assert_match %r{"name":"Konata Izumi"}, json
+    assert_match %r{"age":16}, json
+    assert_no_match %r{"awesome":true}, json
+    assert !json.include?(%("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
+    assert_no_match %r{"preferences":\{"shows":"anime"\}}, json
+  end
+
+  def test_should_allow_attribute_filtering_with_except
+    json = @contact.to_json(:except => [:name, :age])
+
+    assert_no_match %r{"name":"Konata Izumi"}, json
+    assert_no_match %r{"age":16}, json
+    assert_match %r{"awesome":true}, json
+    assert json.include?(%("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
+    assert_match %r{"preferences":\{"shows":"anime"\}}, json
+  end
+
+  def test_methods_are_called_on_object
+    # Define methods on fixture.
+    def @contact.label; "Has cheezburger"; end
+    def @contact.favorite_quote; "Constraints are liberating"; end
+
+    # Single method.
+    assert_match %r{"label":"Has cheezburger"}, @contact.to_json(:only => :name, :methods => :label)
+
+    # Both methods.
+    methods_json = @contact.to_json(:only => :name, :methods => [:label, :favorite_quote])
+    assert_match %r{"label":"Has cheezburger"}, methods_json
+    assert_match %r{"favorite_quote":"Constraints are liberating"}, methods_json
+  end
+
+  def test_uses_serializable_hash_with_only_option
+    def @contact.serializable_hash(options=nil)
+      super(only: %w(name))
+    end
+
+    json = @contact.to_json
+    assert_match %r{"name":"Konata Izumi"}, json
+    assert_no_match %r{awesome}, json
+    assert_no_match %r{age}, json
+  end
+
+  def test_uses_serializable_hash_with_except_option
+    def @contact.serializable_hash(options=nil)
+      super(except: %w(age))
+    end
+
+    json = @contact.to_json
+    assert_match %r{"name":"Konata Izumi"}, json
+    assert_match %r{"awesome":true}, json
+    assert_no_match %r{age}, json
+  end
+
+  def test_does_not_include_inheritance_column_from_sti
+    @contact = ContactSti.new(@contact.attributes)
+    assert_equal 'ContactSti', @contact.type
+
+    json = @contact.to_json
+    assert_match %r{"name":"Konata Izumi"}, json
+    assert_no_match %r{type}, json
+    assert_no_match %r{ContactSti}, json
+  end
+
+  def test_serializable_hash_with_default_except_option_and_excluding_inheritance_column_from_sti
+    @contact = ContactSti.new(@contact.attributes)
+    assert_equal 'ContactSti', @contact.type
+
+    def @contact.serializable_hash(options={})
+      super({ except: %w(age) }.merge!(options))
+    end
+
+    json = @contact.to_json
+    assert_match %r{"name":"Konata Izumi"}, json
+    assert_no_match %r{age}, json
+    assert_no_match %r{type}, json
+    assert_no_match %r{ContactSti}, json
+  end
+
+  def test_serializable_hash_should_not_modify_options_in_argument
+    options = { :only => :name }
+    @contact.serializable_hash(options)
+
+    assert_nil options[:except]
+  end
+end
+
+class DatabaseConnectedJsonEncodingTest < ActiveRecord::TestCase
+  fixtures :authors, :posts, :comments, :tags, :taggings
+
+  include JsonSerializationHelpers
+
+  def setup
+    @david = authors(:david)
+    @mary = authors(:mary)
+  end
+
+  def test_includes_uses_association_name
+    json = @david.to_json(:include => :posts)
+
+    assert_match %r{"posts":\[}, json
+
+    assert_match %r{"id":1}, json
+    assert_match %r{"name":"David"}, json
+
+    assert_match %r{"author_id":1}, json
+    assert_match %r{"title":"Welcome to the weblog"}, json
+    assert_match %r{"body":"Such a lovely day"}, json
+
+    assert_match %r{"title":"So I was thinking"}, json
+    assert_match %r{"body":"Like I hopefully always am"}, json
+  end
+
+  def test_includes_uses_association_name_and_applies_attribute_filters
+    json = @david.to_json(:include => { :posts => { :only => :title } })
+
+    assert_match %r{"name":"David"}, json
+    assert_match %r{"posts":\[}, json
+
+    assert_match %r{"title":"Welcome to the weblog"}, json
+    assert_no_match %r{"body":"Such a lovely day"}, json
+
+    assert_match %r{"title":"So I was thinking"}, json
+    assert_no_match %r{"body":"Like I hopefully always am"}, json
+  end
+
+  def test_includes_fetches_second_level_associations
+    json = @david.to_json(:include => { :posts => { :include => { :comments => { :only => :body } } } })
+
+    assert_match %r{"name":"David"}, json
+    assert_match %r{"posts":\[}, json
+
+    assert_match %r{"comments":\[}, json
+    assert_match %r{\{"body":"Thank you again for the welcome"\}}, json
+    assert_match %r{\{"body":"Don't think too hard"\}}, json
+    assert_no_match %r{"post_id":}, json
+  end
+
+  def test_includes_fetches_nth_level_associations
+    json = @david.to_json(
+      :include => {
+        :posts => {
+          :include => {
+            :taggings => {
+              :include => {
+                :tag => { :only => :name }
+              }
+            }
+          }
+        }
+    })
+
+    assert_match %r{"name":"David"}, json
+    assert_match %r{"posts":\[}, json
+
+    assert_match %r{"taggings":\[}, json
+    assert_match %r{"tag":\{"name":"General"\}}, json
+  end
+
+  def test_includes_doesnt_merge_opts_from_base
+    json = @david.to_json(
+      :only => :id,
+      :include => :posts
+    )
+
+    assert_match %{"title":"Welcome to the weblog"}, json
+  end
+
+  def test_should_not_call_methods_on_associations_that_dont_respond
+    def @david.favorite_quote; "Constraints are liberating"; end
+    json = @david.to_json(:include => :posts, :methods => :favorite_quote)
+
+    assert !@david.posts.first.respond_to?(:favorite_quote)
+    assert_match %r{"favorite_quote":"Constraints are liberating"}, json
+    assert_equal %r{"favorite_quote":}.match(json).size, 1
+  end
+
+  def test_should_allow_only_option_for_list_of_authors
+    set_include_root_in_json(false) do
+      authors = [@david, @mary]
+      assert_equal %([{"name":"David"},{"name":"Mary"}]), ActiveSupport::JSON.encode(authors, only: :name)
+    end
+  end
+
+  def test_should_allow_except_option_for_list_of_authors
+    set_include_root_in_json(false) do
+      authors = [@david, @mary]
+      encoded = ActiveSupport::JSON.encode(authors, except: [
+        :name, :author_address_id, :author_address_extra_id,
+        :organization_id, :owned_essay_id
+      ])
+      assert_equal %([{"id":1},{"id":2}]), encoded
+    end
+  end
+
+  def test_should_allow_includes_for_list_of_authors
+    authors = [@david, @mary]
+    json = ActiveSupport::JSON.encode(authors,
+      :only => :name,
+      :include => {
+        :posts => { :only => :id }
+      }
+    )
+
+    ['"name":"David"', '"posts":[', '{"id":1}', '{"id":2}', '{"id":4}',
+     '{"id":5}', '{"id":6}', '"name":"Mary"', '"posts":[', '{"id":7}', '{"id":9}'].each do |fragment|
+      assert json.include?(fragment), json
+     end
+  end
+
+  def test_should_allow_options_for_hash_of_authors
+    set_include_root_in_json(true) do
+      authors_hash = {
+        1 => @david,
+        2 => @mary
+      }
+      assert_equal %({"1":{"author":{"name":"David"}}}), ActiveSupport::JSON.encode(authors_hash, only: [1, :name])
+    end
+  end
+
+  def test_should_be_able_to_encode_relation
+    set_include_root_in_json(true) do
+      authors_relation = Author.where(id: [@david.id, @mary.id])
+
+      json = ActiveSupport::JSON.encode authors_relation, only: :name
+      assert_equal '[{"author":{"name":"David"}},{"author":{"name":"Mary"}}]', json
+    end
+  end
+end