ibm_db 5.6.1 → 5.7.0

data/test/cases/adapters/trilogy/trilogy_rake_test.rb

@@ -0,0 +1,433 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "active_record/tasks/database_tasks"
+
+module ActiveRecord
+  class TrilogyDBCreateTest < ActiveRecord::TestCase
+    def setup
+      @connection = Class.new do
+        def create_database(*); end
+        def error_number(_); end
+      end.new
+      @configuration = {
+        "adapter"  => "trilogy",
+        "database" => "my-app-db"
+      }
+      $stdout, @original_stdout = StringIO.new, $stdout
+      $stderr, @original_stderr = StringIO.new, $stderr
+    end
+
+    def teardown
+      $stdout, $stderr = @original_stdout, @original_stderr
+    end
+
+    def test_establishes_connection_without_database
+      db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new("default_env", "primary", @configuration)
+
+      mock = Minitest::Mock.new
+      mock.expect(:call, nil, [adapter: "trilogy", database: nil])
+      mock.expect(:call, nil, [db_config])
+
+      ActiveRecord::Base.stub(:lease_connection, @connection) do
+        ActiveRecord::Base.stub(:establish_connection, mock) do
+          ActiveRecord::Tasks::DatabaseTasks.create(db_config)
+        end
+      end
+
+      assert_mock(mock)
+    end
+
+    def test_creates_database_with_no_default_options
+      with_stubbed_connection_establish_connection do
+        assert_called_with(@connection, :create_database, ["my-app-db", {}]) do
+          ActiveRecord::Tasks::DatabaseTasks.create @configuration
+        end
+      end
+    end
+
+    def test_creates_database_with_given_encoding
+      with_stubbed_connection_establish_connection do
+        assert_called_with(@connection, :create_database, ["my-app-db", charset: "latin1"]) do
+          ActiveRecord::Tasks::DatabaseTasks.create @configuration.merge("encoding" => "latin1")
+        end
+      end
+    end
+
+    def test_creates_database_with_given_collation
+      with_stubbed_connection_establish_connection do
+        assert_called_with(
+          @connection,
+          :create_database,
+          ["my-app-db", collation: "latin1_swedish_ci"]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.create @configuration.merge("collation" => "latin1_swedish_ci")
+        end
+      end
+    end
+
+    def test_when_database_created_successfully_outputs_info_to_stdout
+      with_stubbed_connection_establish_connection do
+        ActiveRecord::Tasks::DatabaseTasks.create @configuration
+
+        assert_equal "Created database 'my-app-db'\n", $stdout.string
+      end
+    end
+
+    def test_create_when_database_exists_outputs_info_to_stderr
+      with_stubbed_connection_establish_connection do
+        ActiveRecord::Base.lease_connection.stub(
+          :create_database,
+          proc { raise ActiveRecord::DatabaseAlreadyExists }
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.create @configuration
+
+          assert_equal "Database 'my-app-db' already exists\n", $stderr.string
+        end
+      end
+    end
+
+    private
+      def with_stubbed_connection_establish_connection(&block)
+        ActiveRecord::Base.stub(:establish_connection, nil) do
+          ActiveRecord::Base.stub(:lease_connection, @connection, &block)
+        end
+      end
+  end
+
+  class MysqlDBCreateWithInvalidPermissionsTest < ActiveRecord::TestCase
+    def setup
+      @error         = Trilogy::BaseError.new("Invalid permissions")
+      @configuration = {
+        "adapter"  => "trilogy",
+        "database" => "my-app-db",
+        "username" => "pat",
+        "password" => "wossname"
+      }
+      $stdout, @original_stdout = StringIO.new, $stdout
+      $stderr, @original_stderr = StringIO.new, $stderr
+    end
+
+    def teardown
+      $stdout, $stderr = @original_stdout, @original_stderr
+    end
+
+    def test_raises_error
+      ActiveRecord::Base.stub(:establish_connection, -> * { raise @error }) do
+        assert_raises(Trilogy::BaseError, "Invalid permissions") do
+          ActiveRecord::Tasks::DatabaseTasks.create @configuration
+        end
+      end
+    end
+  end
+
+  class MySQLDBDropTest < ActiveRecord::TestCase
+    def setup
+      @connection    = Class.new { def drop_database(name); end }.new
+      @configuration = {
+        "adapter"  => "trilogy",
+        "database" => "my-app-db"
+      }
+      $stdout, @original_stdout = StringIO.new, $stdout
+      $stderr, @original_stderr = StringIO.new, $stderr
+    end
+
+    def teardown
+      $stdout, $stderr = @original_stdout, @original_stderr
+    end
+
+    def test_establishes_connection_to_mysql_database
+      db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new("default_env", "primary", @configuration)
+
+      ActiveRecord::Base.stub(:lease_connection, @connection) do
+        assert_called_with(
+          ActiveRecord::Base,
+          :establish_connection,
+          [db_config]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.drop(db_config)
+        end
+      end
+    end
+
+    def test_drops_database
+      with_stubbed_connection_establish_connection do
+        assert_called_with(@connection, :drop_database, ["my-app-db"]) do
+          ActiveRecord::Tasks::DatabaseTasks.drop @configuration
+        end
+      end
+    end
+
+    def test_when_database_dropped_successfully_outputs_info_to_stdout
+      with_stubbed_connection_establish_connection do
+        ActiveRecord::Tasks::DatabaseTasks.drop @configuration
+
+        assert_equal "Dropped database 'my-app-db'\n", $stdout.string
+      end
+    end
+
+    private
+      def with_stubbed_connection_establish_connection(&block)
+        ActiveRecord::Base.stub(:establish_connection, nil) do
+          ActiveRecord::Base.stub(:lease_connection, @connection, &block)
+        end
+      end
+  end
+
+  class MySQLPurgeTest < ActiveRecord::TestCase
+    def setup
+      @connection    = Class.new { def recreate_database(*); end }.new
+      @configuration = {
+        "adapter"  => "trilogy",
+        "database" => "test-db"
+      }
+    end
+
+    def test_establishes_connection_without_database
+      db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new("default_env", "primary", @configuration)
+
+      ActiveRecord::Base.stub(:lease_connection, @connection) do
+        assert_called(ActiveRecord::Base, :establish_connection, times: 2) do
+          ActiveRecord::Tasks::DatabaseTasks.purge(db_config)
+        end
+      end
+    end
+
+    def test_recreates_database_with_no_default_options
+      with_stubbed_connection_establish_connection do
+        assert_called_with(@connection, :recreate_database, ["test-db", {}]) do
+          ActiveRecord::Tasks::DatabaseTasks.purge @configuration
+        end
+      end
+    end
+
+    def test_recreates_database_with_the_given_options
+      with_stubbed_connection_establish_connection do
+        assert_called_with(
+          @connection,
+          :recreate_database,
+          ["test-db", charset: "latin", collation: "latin1_swedish_ci"]
+        ) do
+          ActiveRecord::Tasks::DatabaseTasks.purge @configuration.merge(
+            "encoding" => "latin", "collation" => "latin1_swedish_ci")
+        end
+      end
+    end
+
+    private
+      def with_stubbed_connection_establish_connection(&block)
+        ActiveRecord::Base.stub(:establish_connection, nil) do
+          ActiveRecord::Base.stub(:lease_connection, @connection, &block)
+        end
+      end
+  end
+
+  class MysqlDBCharsetTest < ActiveRecord::TestCase
+    def setup
+      @connection    = Class.new { def charset; end }.new
+      @configuration = {
+        "adapter"  => "trilogy",
+        "database" => "my-app-db"
+      }
+    end
+
+    def test_db_retrieves_charset
+      ActiveRecord::Base.stub(:lease_connection, @connection) do
+        assert_called(@connection, :charset) do
+          ActiveRecord::Tasks::DatabaseTasks.charset @configuration
+        end
+      end
+    end
+  end
+
+  class MysqlDBCollationTest < ActiveRecord::TestCase
+    def setup
+      @connection    = Class.new { def collation; end }.new
+      @configuration = {
+        "adapter"  => "trilogy",
+        "database" => "my-app-db"
+      }
+    end
+
+    def test_db_retrieves_collation
+      ActiveRecord::Base.stub(:lease_connection, @connection) do
+        assert_called(@connection, :collation) do
+          ActiveRecord::Tasks::DatabaseTasks.collation @configuration
+        end
+      end
+    end
+  end
+
+  class MySQLStructureDumpTest < ActiveRecord::TestCase
+    def setup
+      @configuration = {
+        "adapter"  => "trilogy",
+        "database" => "test-db"
+      }
+    end
+
+    def test_structure_dump
+      filename = "awesome-file.sql"
+      assert_called_with(
+        Kernel,
+        :system,
+        ["mysqldump", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db"],
+        returns: true
+      ) do
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
+      end
+    end
+
+    def test_structure_dump_with_extra_flags
+      filename = "awesome-file.sql"
+      expected_command = ["mysqldump", "--noop", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db"]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        with_structure_dump_flags(["--noop"]) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
+        end
+      end
+    end
+
+    def test_structure_dump_with_hash_extra_flags_for_a_different_driver
+      filename = "awesome-file.sql"
+      expected_command = ["mysqldump", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db"]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        with_structure_dump_flags({ postgresql: ["--noop"] }) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
+        end
+      end
+    end
+
+    def test_structure_dump_with_hash_extra_flags_for_the_correct_driver
+      filename = "awesome-file.sql"
+      expected_command = ["mysqldump", "--noop", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db"]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        with_structure_dump_flags({ trilogy: ["--noop"] }) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
+        end
+      end
+    end
+
+    def test_structure_dump_with_ignore_tables
+      filename = "awesome-file.sql"
+      ActiveRecord::Base.lease_connection.stub(:data_sources, ["foo", "bar", "prefix_foo", "ignored_foo"]) do
+        ActiveRecord::SchemaDumper.stub(:ignore_tables, [/^prefix_/, "ignored_foo"]) do
+          assert_called_with(
+            Kernel,
+            :system,
+            ["mysqldump", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "--ignore-table=test-db.prefix_foo", "--ignore-table=test-db.ignored_foo", "test-db"],
+            returns: true
+          ) do
+            ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
+          end
+        end
+      end
+    end
+
+    def test_warn_when_external_structure_dump_command_execution_fails
+      filename = "awesome-file.sql"
+      assert_called_with(
+        Kernel,
+        :system,
+        ["mysqldump", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db"],
+        returns: false
+      ) do
+        e = assert_raise(RuntimeError) {
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(@configuration, filename)
+        }
+        assert_match(/^failed to execute: `mysqldump`$/, e.message)
+      end
+    end
+
+    def test_structure_dump_with_port_number
+      filename = "awesome-file.sql"
+      assert_called_with(
+        Kernel,
+        :system,
+        ["mysqldump", "--port=10000", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db"],
+        returns: true
+      ) do
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump(
+          @configuration.merge("port" => 10000),
+          filename)
+      end
+    end
+
+    def test_structure_dump_with_ssl
+      filename = "awesome-file.sql"
+      assert_called_with(
+        Kernel,
+        :system,
+        ["mysqldump", "--ssl-ca=ca.crt", "--result-file", filename, "--no-data", "--routines", "--skip-comments", "test-db"],
+        returns: true
+      ) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_dump(
+            @configuration.merge("sslca" => "ca.crt"),
+            filename)
+        end
+    end
+
+    private
+      def with_structure_dump_flags(flags)
+        old = ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = flags
+        yield
+      ensure
+        ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = old
+      end
+  end
+
+  class MySQLStructureLoadTest < ActiveRecord::TestCase
+    def setup
+      @configuration = {
+        "adapter"  => "trilogy",
+        "database" => "test-db"
+      }
+    end
+
+    def test_structure_load
+      filename = "awesome-file.sql"
+      expected_command = ["mysql", "--noop", "--execute", %{SET FOREIGN_KEY_CHECKS = 0; SOURCE #{filename}; SET FOREIGN_KEY_CHECKS = 1}, "--database", "test-db"]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        with_structure_load_flags(["--noop"]) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_load(@configuration, filename)
+        end
+      end
+    end
+
+    def test_structure_load_with_hash_extra_flags_for_a_different_driver
+      filename = "awesome-file.sql"
+      expected_command = ["mysql", "--execute", %{SET FOREIGN_KEY_CHECKS = 0; SOURCE #{filename}; SET FOREIGN_KEY_CHECKS = 1}, "--database", "test-db"]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        with_structure_load_flags({ postgresql: ["--noop"] }) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_load(@configuration, filename)
+        end
+      end
+    end
+
+    def test_structure_load_with_hash_extra_flags_for_the_correct_driver
+      filename = "awesome-file.sql"
+      expected_command = ["mysql", "--noop", "--execute", %{SET FOREIGN_KEY_CHECKS = 0; SOURCE #{filename}; SET FOREIGN_KEY_CHECKS = 1}, "--database", "test-db"]
+
+      assert_called_with(Kernel, :system, expected_command, returns: true) do
+        with_structure_load_flags({ trilogy: ["--noop"] }) do
+          ActiveRecord::Tasks::DatabaseTasks.structure_load(@configuration, filename)
+        end
+      end
+    end
+
+    private
+      def with_structure_load_flags(flags)
+        old = ActiveRecord::Tasks::DatabaseTasks.structure_load_flags
+        ActiveRecord::Tasks::DatabaseTasks.structure_load_flags = flags
+        yield
+      ensure
+        ActiveRecord::Tasks::DatabaseTasks.structure_load_flags = old
+      end
+  end
+end

data/test/cases/aggregations_test.rb

@@ -26,6 +26,8 @@ class AggregationsTest < ActiveRecord::TestCase
   end
 
   def test_immutable_value_objects
+    assert_raise(FrozenError) { customers(:david).balance.instance_eval { @amount = 20 } }
+
     customers(:david).balance = Money.new(100)
     assert_raise(FrozenError) { customers(:david).balance.instance_eval { @amount = 20 } }
   end
@@ -150,6 +152,20 @@ class AggregationsTest < ActiveRecord::TestCase
     customers(:barney).fullname_no_converter = { first: "Barney", last: "Stinson" }
     assert_equal({ first: "Barney", last: "Stinson" }.to_s, customers(:barney).name)
   end
+
+  def test_hash_mapping
+    assert_equal "Quiet Road", customers(:barney).address_hash_mapping.street
+    assert_equal "Peaceful Town", customers(:barney).address_hash_mapping.city
+    assert_equal "Tranquil Land", customers(:barney).address_hash_mapping.country
+  end
+
+  def test_value_object_with_hash_mapping_assignment_changes_model_attributes
+    customers(:barney).address_hash_mapping = Address.new("Lively Street", customers(:barney).address_city, customers(:barney).address_country)
+
+    customers(:barney).save
+
+    assert_equal "Lively Street", customers(:barney).address_street
+  end
 end
 
 class OverridingAggregationsTest < ActiveRecord::TestCase

data/test/cases/annotate_test.rb

@@ -7,40 +7,42 @@ class AnnotateTest < ActiveRecord::TestCase
   fixtures :posts
 
   def test_annotate_wraps_content_in_an_inline_comment
-    quoted_posts_id, quoted_posts = regexp_escape_table_name("posts.id"), regexp_escape_table_name("posts")
+    quoted_posts_id = Regexp.escape("#{quote_table_name("posts")}.id")
+    quoted_posts = Regexp.escape(quote_table_name("posts"))
 
-    assert_sql(%r{\ASELECT #{quoted_posts_id} FROM #{quoted_posts} /\* foo \*/}i) do
+    assert_queries_match(%r{SELECT #{quoted_posts_id} FROM #{quoted_posts} /\* foo \*/}i) do
       posts = Post.select(:id).annotate("foo")
       assert posts.first
     end
   end
 
   def test_annotate_is_sanitized
-    quoted_posts_id, quoted_posts = regexp_escape_table_name("posts.id"), regexp_escape_table_name("posts")
+    quoted_posts_id = Regexp.escape("#{quote_table_name("posts")}.id")
+    quoted_posts = Regexp.escape(quote_table_name("posts"))
 
-    assert_sql(%r{\ASELECT #{quoted_posts_id} FROM #{quoted_posts} /\* foo \*/}i) do
+    assert_queries_match(%r{SELECT #{quoted_posts_id} FROM #{quoted_posts} /\* \* /foo/ \* \*/}i) do
       posts = Post.select(:id).annotate("*/foo/*")
       assert posts.first
     end
 
-    assert_sql(%r{\ASELECT #{quoted_posts_id} FROM #{quoted_posts} /\* foo \*/}i) do
+    assert_queries_match(%r{SELECT #{quoted_posts_id} FROM #{quoted_posts} /\* \*\* //foo// \*\* \*/}i) do
       posts = Post.select(:id).annotate("**//foo//**")
       assert posts.first
     end
 
-    assert_sql(%r{\ASELECT #{quoted_posts_id} FROM #{quoted_posts} /\* foo \*/ /\* bar \*/}i) do
+    assert_queries_match(%r{SELECT #{quoted_posts_id} FROM #{quoted_posts} /\* \* \* //foo// \* \* \*/}i) do
+      posts = Post.select(:id).annotate("* *//foo//* *")
+      assert posts.first
+    end
+
+    assert_queries_match(%r{SELECT #{quoted_posts_id} FROM #{quoted_posts} /\* \* /foo/ \* \*/ /\* \* /bar \*/}i) do
       posts = Post.select(:id).annotate("*/foo/*").annotate("*/bar")
       assert posts.first
     end
 
-    assert_sql(%r{\ASELECT #{quoted_posts_id} FROM #{quoted_posts} /\* \+ MAX_EXECUTION_TIME\(1\) \*/}i) do
+    assert_queries_match(%r{SELECT #{quoted_posts_id} FROM #{quoted_posts} /\* \+ MAX_EXECUTION_TIME\(1\) \*/}i) do
       posts = Post.select(:id).annotate("+ MAX_EXECUTION_TIME(1)")
       assert posts.first
     end
   end
-
-  private
-    def regexp_escape_table_name(name)
-      Regexp.escape(Post.connection.quote_table_name(name))
-    end
 end