activerecord-cockroachdb-adapter 8.0.3 → 8.1.1

data/test/cases/associations/eager_load_nested_include_test.rb

@@ -0,0 +1,111 @@
+# This test has been copied to fix a bug in the test setup. It can be removed
+# once the bug has been fixed and released in Rails.
+# See test/excludes/EagerLoadPolyAssocsTest.rb
+
+require "cases/helper_cockroachdb"
+
+# Load dependencies from ActiveRecord test suite
+require "models/post"
+require "models/tag"
+require "models/author"
+require "models/comment"
+require "models/category"
+require "models/categorization"
+require "models/tagging"
+
+module CockroachDB
+  module Remembered
+    extend ActiveSupport::Concern
+
+    included do
+      after_create :remember
+    private
+      def remember; self.class.remembered << self; end
+    end
+
+    module ClassMethods
+      # The test setup bug is fixed here. @@remembered was being shared by every
+      # class that included the Remembered module. Instead, we can use
+      # @remembered which will be unique to each included class.
+      def remembered; @remembered ||= []; end
+      def sample; remembered.sample; end
+    end
+  end
+
+  class ShapeExpression < ActiveRecord::Base
+    belongs_to :shape, polymorphic: true
+    belongs_to :paint, polymorphic: true
+  end
+
+  class Circle < ActiveRecord::Base
+    has_many :shape_expressions, as: :shape
+    include Remembered
+  end
+  class Square < ActiveRecord::Base
+    has_many :shape_expressions, as: :shape
+    include Remembered
+  end
+  class Triangle < ActiveRecord::Base
+    has_many :shape_expressions, as: :shape
+    include Remembered
+  end
+  class PaintColor < ActiveRecord::Base
+    has_many   :shape_expressions, as: :paint
+    belongs_to :non_poly, foreign_key: "non_poly_one_id", class_name: "NonPolyOne"
+    include Remembered
+  end
+  class PaintTexture < ActiveRecord::Base
+    has_many   :shape_expressions, as: :paint
+    belongs_to :non_poly, foreign_key: "non_poly_two_id", class_name: "NonPolyTwo"
+    include Remembered
+  end
+  class NonPolyOne < ActiveRecord::Base
+    has_many :paint_colors
+    include Remembered
+  end
+  class NonPolyTwo < ActiveRecord::Base
+    has_many :paint_textures
+    include Remembered
+  end
+
+  class EagerLoadPolyAssocsTest < ActiveRecord::TestCase
+    NUM_SIMPLE_OBJS = 50
+    NUM_SHAPE_EXPRESSIONS = 100
+
+    def setup
+      generate_test_object_graphs
+    end
+
+    teardown do
+      [Circle, Square, Triangle, PaintColor, PaintTexture,
+       ShapeExpression, NonPolyOne, NonPolyTwo].each(&:delete_all)
+    end
+
+    def generate_test_object_graphs
+      1.upto(NUM_SIMPLE_OBJS) do
+        [Circle, Square, Triangle, NonPolyOne, NonPolyTwo].map(&:create!)
+      end
+      1.upto(NUM_SIMPLE_OBJS) do
+        PaintColor.create!(non_poly_one_id: NonPolyOne.sample.id)
+        PaintTexture.create!(non_poly_two_id: NonPolyTwo.sample.id)
+      end
+      1.upto(NUM_SHAPE_EXPRESSIONS) do
+        shape_type = [Circle, Square, Triangle].sample
+        paint_type = [PaintColor, PaintTexture].sample
+        ShapeExpression.create!(shape_type: shape_type.to_s, shape_id: shape_type.sample.id,
+                                paint_type: paint_type.to_s, paint_id: paint_type.sample.id)
+      end
+    end
+
+    def test_include_query
+      res = ShapeExpression.all.merge!(includes: [ :shape, { paint: :non_poly } ]).to_a
+      assert_equal NUM_SHAPE_EXPRESSIONS, res.size
+      assert_queries_count(0) do
+        res.each do |se|
+          assert_not_nil se.paint.non_poly, "this is the association that was loading incorrectly before the change"
+          assert_not_nil se.shape, "just making sure other associations still work"
+        end
+      end
+    end
+  end
+end

data/test/cases/associations/left_outer_join_association_test.rb

@@ -0,0 +1,30 @@
+require "cases/helper_cockroachdb"
+
+# Load dependencies from ActiveRecord test suite
+require "models/post"
+require "models/author"
+
+module CockroachDB
+  class LeftOuterJoinAssociationTest < ActiveRecord::TestCase
+    fixtures :author_addresses, :authors, :posts
+
+    # This replaces the same test that's been excluded from
+    # LeftOuterJoinAssociationTest. The query has been updated to guarantee the
+    # result order.
+    # See test/excludes/LeftOuterJoinAssociationTest.rb
+    def test_construct_finder_sql_applies_aliases_tables_on_association_conditions
+      result = Author.left_outer_joins(:thinking_posts, :welcome_posts).order(:id).to_a
+      assert_equal authors(:david), result.first
+    end
+
+    # This replaces the same test that's been excluded from
+    # LeftOuterJoinAssociationTest. The select query has been updated so the
+    # integer columns are casted to strings for concatenation.
+    # See test/excludes/LeftOuterJoinAssociationTest.rb
+    def test_does_not_override_select
+      authors = Author.select("authors.name, #{%{(authors.author_address_id::STRING || ' ' || authors.author_address_extra_id::STRING) as addr_id}}").left_outer_joins(:posts)
+      assert_predicate authors, :any?
+      assert_respond_to authors.first, :addr_id
+    end
+  end
+end

data/test/cases/associations_test.rb

@@ -0,0 +1,108 @@
+require "cases/helper_cockroachdb"
+
+require "support/connection_helper"
+
+require "models/bird"
+require "models/parrot"
+require "models/pirate"
+require "models/price_estimate"
+require "models/ship"
+require "models/treasure"
+
+module CockroachDB
+  class WithAnnotationsTest < ActiveRecord::TestCase
+    self.use_transactional_tests = false
+
+    fixtures :pirates, :treasures, :parrots
+
+    def test_belongs_to_with_annotation_includes_a_query_comment
+      pirate = SpacePirate.where.not(parrot_id: nil).first
+      assert pirate, "should have a Pirate record"
+
+      log = capture_sql do
+        pirate.parrot
+      end
+      assert_not_predicate log, :empty?
+      assert_predicate log.select { |query| query.match?(%r{/\*}) }, :empty?
+
+      assert_queries_match(%r{/\* that tells jokes \*/}) do
+        pirate.parrot_with_annotation
+      end
+    end
+
+    def test_has_and_belongs_to_many_with_annotation_includes_a_query_comment
+      pirate = SpacePirate.first
+      assert pirate, "should have a Pirate record"
+
+      log = capture_sql do
+        pirate.parrots.first
+      end
+      assert_not_predicate log, :empty?
+      assert_predicate log.select { |query| query.match?(%r{/\*}) }, :empty?
+
+      assert_queries_match(%r{/\* that are very colorful \*/}) do
+        pirate.parrots_with_annotation.first
+      end
+    end
+
+    def test_has_one_with_annotation_includes_a_query_comment
+      pirate = SpacePirate.first
+      assert pirate, "should have a Pirate record"
+
+      log = capture_sql do
+        pirate.ship
+      end
+      assert_not_predicate log, :empty?
+      assert_predicate log.select { |query| query.match?(%r{/\*}) }, :empty?
+
+      assert_queries_match(%r{/\* that is a rocket \*/}) do
+        pirate.ship_with_annotation
+      end
+    end
+
+    def test_has_many_with_annotation_includes_a_query_comment
+      pirate = SpacePirate.first
+      assert pirate, "should have a Pirate record"
+
+      log = capture_sql do
+        pirate.birds.first
+      end
+      assert_not_predicate log, :empty?
+      assert_predicate log.select { |query| query.match?(%r{/\*}) }, :empty?
+
+      assert_queries_match(%r{/\* that are also parrots \*/}) do
+        pirate.birds_with_annotation.first
+      end
+    end
+
+    def test_has_many_through_with_annotation_includes_a_query_comment
+      pirate = SpacePirate.first
+      assert pirate, "should have a Pirate record"
+
+      log = capture_sql do
+        pirate.treasure_estimates.first
+      end
+      assert_not_predicate log, :empty?
+      assert_predicate log.select { |query| query.match?(%r{/\*}) }, :empty?
+
+      assert_queries_match(%r{/\* yarrr \*/}) do
+        pirate.treasure_estimates_with_annotation.first
+      end
+    end
+
+    def test_has_many_through_with_annotation_includes_a_query_comment_when_eager_loading
+      pirate = SpacePirate.first
+      assert pirate, "should have a Pirate record"
+
+      log = capture_sql do
+        pirate.treasure_estimates.first
+      end
+      assert_not_predicate log, :empty?
+      assert_predicate log.select { |query| query.match?(%r{/\*}) }, :empty?
+
+      assert_queries_match(%r{/\* yarrr \*/}) do
+        SpacePirate.includes(:treasure_estimates_with_annotation, :treasures).first
+      end
+    end
+  end
+end

data/test/cases/base_test.rb

@@ -0,0 +1,31 @@
+require "cases/helper_cockroachdb"
+
+module CockroachDB
+  class BasicsTest < ActiveRecord::TestCase
+    # This replaces the same test that's been excluded from BasicsTest. It's
+    # exactly the same, except badchar has an entry for CockroachDBAdapter.
+    def test_column_names_are_escaped
+      conn      = ActiveRecord::Base.lease_connection
+      classname = conn.class.name[/[^:]*$/]
+      badchar   = {
+        "SQLite3Adapter"    => '"',
+        "Mysql2Adapter"     => "`",
+        "PostgreSQLAdapter" => '"',
+        "OracleAdapter"     => '"',
+        "FbAdapter"         => '"',
+        "CockroachDBAdapter" => '"'
+      }.fetch(classname) {
+        raise "need a bad char for #{classname}"
+      }
+
+      quoted = conn.quote_column_name "foo#{badchar}bar"
+      if current_adapter?(:OracleAdapter)
+        # Oracle does not allow double quotes in table and column names at all
+        # therefore quoting removes them
+        assert_equal("#{badchar}foobar#{badchar}", quoted)
+      else
+        assert_equal("#{badchar}foo#{badchar * 2}bar#{badchar}", quoted)
+      end
+    end
+  end
+end

data/test/cases/comment_test.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "support/schema_dumping_helper"
+
+# Copy of comment_test from ActiveRecord with all but two tests removed.
+# We can get these tests to pass by enabling an experimental feature in
+# setup, so we exclude them from the AR test cases and run them here.
+if ActiveRecord::Base.lease_connection.supports_comments?
+  module CockroachDB
+    class CommentTest < ActiveRecord::TestCase
+      include SchemaDumpingHelper
+
+      self.use_transactional_tests = false
+
+      class Commented < ActiveRecord::Base
+        self.table_name = "commenteds"
+      end
+
+      setup do
+        @connection = ActiveRecord::Base.lease_connection
+
+        @connection.create_table("commenteds", comment: "A table with comment", force: true) do |t|
+          t.string  "name",    comment: "Comment should help clarify the column purpose"
+          t.boolean "obvious", comment: "Question is: should you comment obviously named objects?"
+          t.string  "content"
+          t.index   "name",    comment: %Q["Very important" index that powers all the performance.\nAnd it's fun!]
+        end
+
+        Commented.reset_column_information
+      end
+
+      teardown do
+        @connection.drop_table "commenteds", if_exists: true
+      end
+
+      # This test is modified from the original
+      # The original changes the column type from a boolean to a string,
+      # but once this happens, comment changes don't work, so I'm not altering
+      # the type here.
+      def test_remove_comment_from_column
+        @connection.change_column :commenteds, :obvious, :boolean, comment: nil
+
+        Commented.reset_column_information
+        column = Commented.columns_hash["obvious"]
+
+        assert_equal :boolean, column.type
+        assert_nil column.comment
+      end
+
+      def test_schema_dump_with_comments
+        # Do all the stuff from other tests
+        @connection.add_column    :commenteds, :rating, :integer, comment: "I am running out of imagination"
+        @connection.change_column :commenteds, :content, :string, comment: "Whoa, content describes itself!"
+        @connection.change_column :commenteds, :content, :string
+        @connection.change_column :commenteds, :obvious, :boolean, comment: nil
+        @connection.add_index     :commenteds, :obvious, name: "idx_obvious", comment: "We need to see obvious comments"
+
+        # And check that these changes are reflected in dump
+        output = dump_table_schema "commenteds"
+        assert_match %r[create_table "commenteds",.*\s+comment: "A table with comment"], output
+        assert_match %r[t\.string\s+"name",\s+comment: "Comment should help clarify the column purpose"], output
+        assert_match %r[t\.boolean\s+"obvious"\n], output
+        assert_match %r[t\.string\s+"content",\s+comment: "Whoa, content describes itself!"], output
+        if current_adapter?(:OracleAdapter)
+          assert_match %r[t\.integer\s+"rating",\s+precision: 38,\s+comment: "I am running out of imagination"], output
+        else
+          assert_match %r[t\.bigint\s+"rating",\s+comment: "I am running out of imagination"], output
+          assert_match %r[t\.index\s+.+\s+comment: "\\\"Very important\\\" index that powers all the performance.\\nAnd it's fun!"], output
+          assert_match %r[t\.index\s+.+\s+name: "idx_obvious",\s+comment: "We need to see obvious comments"], output
+        end
+      end
+    end
+  end
+end

data/test/cases/connection_adapters/type_test.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "cases/helper_cockroachdb"
+require "models/account"
+
+module CockroachDB
+  module ConnectionAdapters
+    class TypeTest < ActiveRecord::TestCase
+      fixtures :accounts
+      class FakeModel < ActiveRecord::Base
+        establish_connection(
+          adapter: "fake"
+        )
+      end
+      def test_type_can_be_used_with_various_db
+        skip "Fails in CI, see issue #341"
+        assert_equal(
+          :postgresql,
+          ActiveRecord::Type.adapter_name_from(Account)
+        )
+        assert_equal(
+           :fake,
+           ActiveRecord::Type.adapter_name_from(FakeModel)
+        )
+      end
+    end
+  end
+end

data/test/cases/database_configurations/resolver_test.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "cases/helper_cockroachdb"
+require "support/copy_cat"
+
+module CockroachDB
+  class ResolverTest < ::ActiveRecord::ConnectionAdapters::PoolConfig::ResolverTest
+    CopyCat.copy_methods(self, ::ActiveRecord::ConnectionAdapters::PoolConfig::ResolverTest,
+      :test_url_invalid_adapter) do
+        # We're not in the ActiveRecord namespace anymore.
+        def on_const(node)
+          return unless node in [:const, nil, :AdapterNotFound|:Base]
+
+          insert_before(node.loc.expression, "ActiveRecord::")
+        end
+
+        def on_str(node)
+          return unless node in [:str, /\ADatabase config/]
+
+          replace(node.loc.expression, node.children.first.sub("abstract,", "abstract, cockroachdb,").inspect)
+        end
+    end
+  end
+end

data/test/cases/defaults_test.rb

@@ -0,0 +1,45 @@
+require "cases/helper_cockroachdb"
+
+# Load dependencies from ActiveRecord test suite
+require "support/schema_dumping_helper"
+
+module CockroachDB
+  class DefaultExpressionTest < ActiveRecord::TestCase
+    include SchemaDumpingHelper
+
+    # This replaces the same test that's been excluded from
+    # PostgresqlDefaultExpressionTest. The assertions have updated to match
+    # against CockroachDB's current_date() and current_timestamp() functions.
+    # See test/excludes/PostgresqlDefaultExpressionTest.rb.
+    test "schema dump includes default expression" do
+      output = dump_table_schema("defaults")
+
+      assert_match %r/t\.date\s+"modified_date",\s+default: -> { \"current_date\(\)\" }/, output
+      assert_match %r/t\.datetime\s+"modified_time",\s+default: -> { "current_timestamp\(\)" }/, output
+
+      assert_match %r/t\.date\s+"modified_date_function",\s+default: -> { "now\(\)" }/, output
+      assert_match %r/t\.datetime\s+"modified_time_function",\s+default: -> { "now\(\)" }/, output
+    end
+  end
+
+  class DefaultNumbersTest < ActiveRecord::TestCase
+    class DefaultNumber < ActiveRecord::Base; end
+
+    setup do
+      @connection = ActiveRecord::Base.lease_connection
+      @connection.create_table :default_numbers do |t|
+        t.decimal :decimal_number, precision: 32, scale: 16, default: 0
+      end
+    end
+
+    teardown do
+      @connection.drop_table :default_numbers, if_exists: true
+    end
+
+    def test_default_decimal_zero_with_large_scale
+      record = DefaultNumber.new
+      assert_equal 0.0, record.decimal_number
+      assert_equal 0.0, record.decimal_number_before_type_cast
+    end
+  end
+end

data/test/cases/dirty_test.rb

@@ -0,0 +1,24 @@
+require "cases/helper"
+
+module CockroachDB
+  class DirtyTest < ActiveRecord::TestCase
+    self.use_transactional_tests = false
+
+    class Testings < ActiveRecord::Base; end
+
+    # This replaces the same test that's been excluded from DirtyTest. We can
+    # run it here with use_transactional_tests set to false.
+    # See test/excludes/DirtyTest.rb
+    def test_field_named_field
+      ActiveRecord::Base.lease_connection.create_table :testings do |t|
+        t.string :field
+      end
+      assert_nothing_raised do
+        Testings.new.attributes
+      end
+    ensure
+      ActiveRecord::Base.lease_connection.drop_table :testings, if_exists: true
+      ActiveRecord::Base.clear_cache!
+    end
+  end
+end