activerecord-refined 0.3.0 → 0.3.2

data/test/test_block_syntax.rb

@@ -2,31 +2,31 @@ require_relative 'test_helper'
 
 class TestBlockSyntax < Minitest::Test
   def test_equal
-    assert_match(/WHERE "users"."name" = 'matz'/, User.where { :name == 'matz' }.to_sql)
+    assert_sql(/WHERE "users"."name" = 'matz'/, User.where { :name == 'matz' }.to_sql)
   end
 
   def test_not_equal
-    assert_match(/WHERE "users"."name" != 'nobu'/, User.where { :name != 'nobu' }.to_sql)
+    assert_sql(/WHERE "users"."name" != 'nobu'/, User.where { :name != 'nobu' }.to_sql)
   end
 
   def test_greater_than
-    assert_match(/WHERE "users"."age" > 3/, User.where { :age > 3 }.to_sql)
+    assert_sql(/WHERE "users"."age" > 3/, User.where { :age > 3 }.to_sql)
   end
 
   def test_greater_than_or_equal
-    assert_match(/WHERE "users"."age" >= 18/, User.where { :age >= 18 }.to_sql)
+    assert_sql(/WHERE "users"."age" >= 18/, User.where { :age >= 18 }.to_sql)
   end
 
   def test_less_than
-    assert_match(/WHERE "users"."age" < 60/, User.where { :age < 60 }.to_sql)
+    assert_sql(/WHERE "users"."age" < 60/, User.where { :age < 60 }.to_sql)
   end
 
   def test_less_than_or_equal
-    assert_match(/WHERE "users"."age" <= 35/, User.where { :age <= 35 }.to_sql)
+    assert_sql(/WHERE "users"."age" <= 35/, User.where { :age <= 35 }.to_sql)
   end
 
   def test_like
-    assert_match(/WHERE "users"."name" LIKE 'tender%'/, User.where { :name =~ 'tender%' }.to_sql)
+    assert_sql(/WHERE "users"."name" LIKE 'tender%'/, User.where { :name.like?('tender%') }.to_sql)
   end
 
   def test_outside_of_where_block
@@ -34,149 +34,279 @@ class TestBlockSyntax < Minitest::Test
   end
 
   def test_and
-    assert_match(/WHERE "users"."name" = 'matz' AND "users"."age" > 18/,
+    assert_sql(/WHERE "users"."name" = 'matz' AND "users"."age" > 18/,
       User.where { (:name == 'matz') & (:age > 18) }.to_sql)
   end
 
   def test_or
-    assert_match(/WHERE \(?\"users\".\"name\" = 'matz' OR \"users\".\"name\" = 'nobu'\)?/,
+    assert_sql(/WHERE \(?\"users\".\"name\" = 'matz' OR \"users\".\"name\" = 'nobu'\)?/,
       User.where { (:name == 'matz') | (:name == 'nobu') }.to_sql)
   end
 
   def test_not
-    assert_match(/WHERE NOT \(?\"users\".\"name\" = 'matz'\)?/,
+    assert_sql(/WHERE NOT \(?\"users\".\"name\" = 'matz'\)?/,
       User.where { !(:name == 'matz') }.to_sql)
   end
 
   def test_complex_combination
     sql = User.where { ((:name == 'matz') & (:age > 18)) | !(:name == 'nobu') }.to_sql
-    assert_match(/"users"."name" = 'matz'/, sql)
-    assert_match(/"users"."age" > 18/, sql)
-    assert_match(/NOT/, sql)
-    assert_match(/OR/, sql)
+    assert_sql(/"users"."name" = 'matz'/, sql)
+    assert_sql(/"users"."age" > 18/, sql)
+    assert_sql(/NOT/, sql)
+    assert_sql(/OR/, sql)
   end
 
-  def test_between
-    assert_match(/WHERE "users"."age" BETWEEN 18 AND 65/,
-      User.where { :age == (18..65) }.to_sql)
+  def test_like_qualified
+    assert_sql(/WHERE "users"."name" LIKE 'tender%'/,
+      User.where { :users[:name].like?('tender%') }.to_sql)
   end
 
   def test_not_like
-    assert_match(/WHERE "users"."name" NOT LIKE 'tender%'/,
-      User.where { :name !~ 'tender%' }.to_sql)
+    assert_sql(/WHERE NOT \("users"."name" LIKE 'tender%'\)/,
+      User.where { !:name.like?('tender%') }.to_sql)
+  end
+
+  def test_start_with
+    assert_sql(/WHERE "users"."name" LIKE 'tender%' ESCAPE '\\'/,
+      User.where { :name.start_with?('tender') }.to_sql)
+  end
+
+  def test_end_with
+    assert_sql(/WHERE "users"."name" LIKE '%love' ESCAPE '\\'/,
+      User.where { :name.end_with?('love') }.to_sql)
+  end
+
+  def test_include
+    assert_sql(/WHERE "users"."name" LIKE '%der%' ESCAPE '\\'/,
+      User.where { :name.include?('der') }.to_sql)
+  end
+
+  def test_start_with_escapes_wildcards
+    assert_sql(/WHERE "users"."name" LIKE '100\\%\\_%' ESCAPE '\\'/,
+      User.where { :name.start_with?('100%_') }.to_sql)
+  end
+
+  def test_include_escapes_wildcards
+    assert_sql(/WHERE "users"."name" LIKE '%100\\%%' ESCAPE '\\'/,
+      User.where { :name.include?('100%') }.to_sql)
+  end
+
+  def test_regexp
+    skip_without_regexp_support
+    assert_sql(/WHERE "users"."name" #{regexp_operator} '\^ma'/,
+      User.where { :name =~ '^ma' }.to_sql)
+  end
+
+  def test_not_regexp
+    skip_without_regexp_support
+    assert_sql(/WHERE "users"."name" #{not_regexp_operator} '\^ma'/,
+      User.where { :name !~ '^ma' }.to_sql)
+  end
+
+  def test_regexp_qualified
+    skip_without_regexp_support
+    assert_sql(/WHERE "users"."name" #{regexp_operator} '\^ma'/,
+      User.where { :users[:name] =~ '^ma' }.to_sql)
+  end
+
+  def test_regexp_on_function
+    skip_without_regexp_support
+    assert_sql(/WHERE UPPER\("users"."name"\) #{regexp_operator} '\^MA'/,
+      User.where { upper(:name) =~ '^MA' }.to_sql)
+  end
+
+  def test_regexp_literal
+    skip_without_regexp_support
+    assert_sql(/WHERE "users"."name" #{regexp_operator} 'love\$'/,
+      User.where { :name =~ /love$/ }.to_sql)
+  end
+
+  # Rejected while the block runs, so this holds on every adapter.
+  def test_regexp_literal_with_options_is_rejected
+    assert_raises(ArgumentError) { User.where { :name =~ /^ma/i } }
+  end
+
+  def test_between
+    assert_sql(/WHERE "users"."age" BETWEEN 18 AND 65/,
+      User.where { :age.between?(18, 65) }.to_sql)
+  end
+
+  def test_in_range
+    assert_sql(/WHERE "users"."age" BETWEEN 18 AND 65/,
+      User.where { :age.in?(18..65) }.to_sql)
+  end
+
+  def test_in_endless_range
+    assert_sql(/WHERE "users"."age" >= 18/,
+      User.where { :age.in?(18..) }.to_sql)
+  end
+
+  def test_in_exclusive_range
+    assert_sql(/WHERE "users"."age" >= 18 AND "users"."age" < 65/,
+      User.where { :age.in?(18...65) }.to_sql)
   end
 
   def test_not_between
-    # Arel expands a bounded NOT BETWEEN into an OR of comparisons
-    assert_match(/WHERE \("users"."age" < 18 OR "users"."age" > 65\)/,
-      User.where { :age != (18..65) }.to_sql)
+    assert_sql(/WHERE NOT \("users"."age" BETWEEN 18 AND 65\)/,
+      User.where { !:age.between?(18, 65) }.to_sql)
   end
 
   def test_is_null
-    assert_match(/WHERE "users"."name" IS NULL/,
+    assert_sql(/WHERE "users"."name" IS NULL/,
       User.where { :name.null? }.to_sql)
   end
 
   def test_is_null_qualified
-    assert_match(/WHERE "users"."name" IS NULL/,
+    assert_sql(/WHERE "users"."name" IS NULL/,
       User.where { :users[:name].null? }.to_sql)
   end
 
   def test_in
-    assert_match(/WHERE "users"."age" IN \(1, 2, 3\)/,
-      User.where { :age == [1, 2, 3] }.to_sql)
+    assert_sql(/WHERE "users"."age" IN \(1, 2, 3\)/,
+      User.where { :age.in?([1, 2, 3]) }.to_sql)
+  end
+
+  def test_in_qualified
+    assert_sql(/WHERE "users"."age" IN \(1, 2, 3\)/,
+      User.where { :users[:age].in?([1, 2, 3]) }.to_sql)
   end
 
   def test_not_in
-    assert_match(/WHERE "users"."age" NOT IN \(1, 2, 3\)/,
-      User.where { :age != [1, 2, 3] }.to_sql)
+    assert_sql(/WHERE NOT \("users"."age" IN \(1, 2, 3\)\)/,
+      User.where { !:age.in?([1, 2, 3]) }.to_sql)
+  end
+
+  # == passes a Range or an Array through as a value rather than expanding it,
+  # so that it compares against a PostgreSQL range or array column. The SQL
+  # literal depends on the column type, so assert on the Arel node instead.
+  def test_equal_range_is_an_equality
+    node = ActiveRecord::Refined::AST::Comparison.new(:period, :==, 18..65).
+      to_arel(User.arel_table)
+    assert_instance_of(Arel::Nodes::Equality, node)
+    assert_equal(18..65, node.right.value)
+  end
+
+  def test_equal_array_is_an_equality
+    node = ActiveRecord::Refined::AST::Comparison.new(:tags, :==, [1, 2, 3]).
+      to_arel(User.arel_table)
+    assert_instance_of(Arel::Nodes::Equality, node)
+    assert_equal([1, 2, 3], node.right.value)
+  end
+
+  def test_not_equal_array_is_an_inequality
+    node = ActiveRecord::Refined::AST::Comparison.new(:tags, :!=, [1, 2, 3]).
+      to_arel(User.arel_table)
+    assert_instance_of(Arel::Nodes::NotEqual, node)
+    assert_equal([1, 2, 3], node.right.value)
   end
 
   def test_qualified_column
-    assert_match(/WHERE "users"."name" = 'matz'/,
+    assert_sql(/WHERE "users"."name" = 'matz'/,
       User.where { :users[:name] == 'matz' }.to_sql)
   end
 
   def test_column_to_column_comparison
     sql = User.where { :users[:name] == :users[:age] }.to_sql
-    assert_match(/"users"."name" = "users"."age"/, sql)
+    assert_sql(/"users"."name" = "users"."age"/, sql)
   end
 
   def test_joins_with_block
     sql = Author.joins(:posts) { :posts[:author_id] == :authors[:id] }.to_sql
-    assert_match(/INNER JOIN "posts" ON "posts"."author_id" = "authors"."id"/, sql)
+    assert_sql(/INNER JOIN "posts" ON "posts"."author_id" = "authors"."id"/, sql)
   end
 
   def test_left_outer_joins_with_block
     sql = Author.left_outer_joins(:posts) { :posts[:author_id] == :authors[:id] }.to_sql
-    assert_match(/LEFT OUTER JOIN "posts" ON "posts"."author_id" = "authors"."id"/, sql)
+    assert_sql(/LEFT OUTER JOIN "posts" ON "posts"."author_id" = "authors"."id"/, sql)
   end
 
   def test_select_aggregate
-    assert_match(/SELECT SUM\("users"."age"\)/,
+    assert_sql(/SELECT SUM\("users"."age"\)/,
       User.select { :age.sum }.to_sql)
   end
 
   def test_select_aggregate_qualified
-    assert_match(/SELECT COUNT\("users"."id"\)/,
+    assert_sql(/SELECT COUNT\("users"."id"\)/,
       User.select { :users[:id].count }.to_sql)
   end
 
   def test_select_average
-    assert_match(/SELECT AVG\("users"."age"\)/,
+    assert_sql(/SELECT AVG\("users"."age"\)/,
       User.select { :age.average }.to_sql)
   end
 
   def test_select_maximum
-    assert_match(/SELECT MAX\("users"."age"\)/,
+    assert_sql(/SELECT MAX\("users"."age"\)/,
       User.select { :age.maximum }.to_sql)
   end
 
   def test_select_minimum
-    assert_match(/SELECT MIN\("users"."age"\)/,
+    assert_sql(/SELECT MIN\("users"."age"\)/,
       User.select { :age.minimum }.to_sql)
   end
 
   def test_having_aggregate
     sql = User.group(:name).having { :age.sum > 100 }.to_sql
-    assert_match(/GROUP BY "users"."name"/, sql)
-    assert_match(/HAVING SUM\("users"."age"\) > 100/, sql)
+    assert_sql(/GROUP BY "users"."name"/, sql)
+    assert_sql(/HAVING SUM\("users"."age"\) > 100/, sql)
   end
 
   def test_select_avg_function
-    assert_match(/SELECT AVG\("users"."age"\)/,
+    assert_sql(/SELECT AVG\("users"."age"\)/,
       User.select { avg(:age) }.to_sql)
   end
 
   def test_select_count_function
-    assert_match(/SELECT COUNT\("users"."id"\)/,
+    assert_sql(/SELECT COUNT\("users"."id"\)/,
       User.select { count(:id) }.to_sql)
   end
 
+  def test_select_count_star
+    assert_sql(/SELECT COUNT\(\*\)/,
+      User.select { count(:*) }.to_sql)
+  end
+
+  def test_select_count_star_alias
+    assert_sql(/SELECT COUNT\(\*\) AS cnt/,
+      User.select { count(:*).as(:cnt) }.to_sql)
+  end
+
+  def test_having_count_star
+    sql = Author.joins(:posts) { :posts[:author_id] == :authors[:id] }.
+      group { :authors[:id] }.
+      having { count(:*) > 1 }.to_sql
+    assert_sql(/HAVING COUNT\(\*\) > 1/, sql)
+  end
+
+  def test_order_count_star
+    assert_sql(/ORDER BY COUNT\(\*\) DESC/,
+      User.group(:name).order { count(:*).desc }.to_sql)
+  end
+
   def test_select_sum_function
-    assert_match(/SELECT SUM\("users"."age"\)/,
+    assert_sql(/SELECT SUM\("users"."age"\)/,
       User.select { sum(:age) }.to_sql)
   end
 
   def test_select_min_function
-    assert_match(/SELECT MIN\("users"."age"\)/,
+    assert_sql(/SELECT MIN\("users"."age"\)/,
       User.select { min(:age) }.to_sql)
   end
 
   def test_select_max_function
-    assert_match(/SELECT MAX\("users"."age"\)/,
+    assert_sql(/SELECT MAX\("users"."age"\)/,
       User.select { max(:age) }.to_sql)
   end
 
   def test_function_qualified_column
-    assert_match(/SELECT AVG\("users"."age"\)/,
+    assert_sql(/SELECT AVG\("users"."age"\)/,
       User.select { avg(:users[:age]) }.to_sql)
   end
 
   def test_having_function
     sql = User.group(:name).having { sum(:age) > 100 }.to_sql
-    assert_match(/GROUP BY "users"."name"/, sql)
-    assert_match(/HAVING SUM\("users"."age"\) > 100/, sql)
+    assert_sql(/GROUP BY "users"."name"/, sql)
+    assert_sql(/HAVING SUM\("users"."age"\) > 100/, sql)
   end
 
   def test_function_and_method_syntax_match
@@ -185,123 +315,138 @@ class TestBlockSyntax < Minitest::Test
   end
 
   def test_upper_function
-    assert_match(/SELECT UPPER\("users"."name"\)/,
+    assert_sql(/SELECT UPPER\("users"."name"\)/,
       User.select { upper(:name) }.to_sql)
   end
 
   def test_lower_function
-    assert_match(/SELECT LOWER\("users"."name"\)/,
+    assert_sql(/SELECT LOWER\("users"."name"\)/,
       User.select { lower(:name) }.to_sql)
   end
 
   def test_length_function_in_where
-    assert_match(/WHERE LENGTH\("users"."name"\) > 3/,
+    assert_sql(/WHERE LENGTH\("users"."name"\) > 3/,
       User.where { length(:name) > 3 }.to_sql)
   end
 
   def test_coalesce_function_with_literal
-    assert_match(/SELECT COALESCE\("users"."name", 'unknown'\)/,
+    assert_sql(/SELECT COALESCE\("users"."name", 'unknown'\)/,
       User.select { coalesce(:name, 'unknown') }.to_sql)
   end
 
   def test_function_comparison
-    assert_match(/WHERE UPPER\("users"."name"\) = 'MATZ'/,
+    assert_sql(/WHERE UPPER\("users"."name"\) = 'MATZ'/,
       User.where { upper(:name) == 'MATZ' }.to_sql)
   end
 
+  def test_function_like
+    assert_sql(/WHERE UPPER\("users"."name"\) LIKE 'MA%'/,
+      User.where { upper(:name).like?('MA%') }.to_sql)
+  end
+
+  def test_function_in
+    assert_sql(/WHERE UPPER\("users"."name"\) IN \('MATZ', 'NOBU'\)/,
+      User.where { upper(:name).in?(%w[MATZ NOBU]) }.to_sql)
+  end
+
+  def test_aggregate_in
+    assert_sql(/HAVING SUM\("users"."age"\) BETWEEN 1 AND 10/,
+      User.group(:name).having { :age.sum.in?(1..10) }.to_sql)
+  end
+
   def test_nested_function
-    assert_match(/SELECT UPPER\(COALESCE\("users"."name", 'x'\)\)/,
+    assert_sql(/SELECT UPPER\(COALESCE\("users"."name", 'x'\)\)/,
       User.select { upper(coalesce(:name, 'x')) }.to_sql)
   end
 
   def test_function_qualified_column_arg
-    assert_match(/SELECT UPPER\("users"."name"\)/,
+    assert_sql(/SELECT UPPER\("users"."name"\)/,
       User.select { upper(:users[:name]) }.to_sql)
   end
 
   def test_select_multiple_fields
-    assert_match(/SELECT UPPER\("users"."name"\), "users"."age"/,
+    assert_sql(/SELECT UPPER\("users"."name"\), "users"."age"/,
       User.select { [upper(:name), :age] }.to_sql)
   end
 
   def test_select_multiple_columns
-    assert_match(/SELECT "users"."name", "users"."age"/,
+    assert_sql(/SELECT "users"."name", "users"."age"/,
       User.select { [:name, :age] }.to_sql)
   end
 
   def test_select_multiple_with_aggregate
-    assert_match(/SELECT "users"."name", SUM\("users"."age"\)/,
+    assert_sql(/SELECT "users"."name", SUM\("users"."age"\)/,
       User.select { [:name, sum(:age)] }.to_sql)
   end
 
   def test_select_function_with_alias
-    assert_match(/SELECT UPPER\("users"."name"\) AS upper_name, "users"."age"/,
+    assert_sql(/SELECT UPPER\("users"."name"\) AS upper_name, "users"."age"/,
       User.select { [upper(:name).as(:upper_name), :age] }.to_sql)
   end
 
   def test_select_column_alias
-    assert_match(/SELECT "users"."name" AS n/,
+    assert_sql(/SELECT "users"."name" AS n/,
       User.select { :name.as(:n) }.to_sql)
   end
 
   def test_select_qualified_column_alias
-    assert_match(/SELECT "users"."name" AS n/,
+    assert_sql(/SELECT "users"."name" AS n/,
       User.select { :users[:name].as(:n) }.to_sql)
   end
 
   def test_select_aggregate_alias
-    assert_match(/SELECT COUNT\("users"."id"\) AS cnt/,
+    assert_sql(/SELECT COUNT\("users"."id"\) AS cnt/,
       User.select { count(:id).as(:cnt) }.to_sql)
   end
 
   def test_order_default_asc
-    assert_match(/ORDER BY "users"."age"/,
+    assert_sql(/ORDER BY "users"."age"/,
       User.order { :age }.to_sql)
   end
 
   def test_order_desc
-    assert_match(/ORDER BY "users"."age" DESC/,
+    assert_sql(/ORDER BY "users"."age" DESC/,
       User.order { :age.desc }.to_sql)
   end
 
   def test_order_asc
-    assert_match(/ORDER BY "users"."age" ASC/,
+    assert_sql(/ORDER BY "users"."age" ASC/,
       User.order { :age.asc }.to_sql)
   end
 
   def test_order_multiple
-    assert_match(/ORDER BY "users"."age" DESC, "users"."name" ASC/,
+    assert_sql(/ORDER BY "users"."age" DESC, "users"."name" ASC/,
       User.order { [:age.desc, :name.asc] }.to_sql)
   end
 
   def test_order_qualified_column
-    assert_match(/ORDER BY "users"."name" DESC/,
+    assert_sql(/ORDER BY "users"."name" DESC/,
       User.order { :users[:name].desc }.to_sql)
   end
 
   def test_group_single
-    assert_match(/GROUP BY "users"."name"/,
+    assert_sql(/GROUP BY "users"."name"/,
       User.group { :name }.to_sql)
   end
 
   def test_group_multiple
-    assert_match(/GROUP BY "users"."name", "users"."age"/,
+    assert_sql(/GROUP BY "users"."name", "users"."age"/,
       User.group { [:name, :age] }.to_sql)
   end
 
   def test_group_qualified_column
-    assert_match(/GROUP BY "users"."name"/,
+    assert_sql(/GROUP BY "users"."name"/,
       User.group { :users[:name] }.to_sql)
   end
 
   def test_group_with_having
     sql = User.group { :name }.having { sum(:age) > 100 }.to_sql
-    assert_match(/GROUP BY "users"."name"/, sql)
-    assert_match(/HAVING SUM\("users"."age"\) > 100/, sql)
+    assert_sql(/GROUP BY "users"."name"/, sql)
+    assert_sql(/HAVING SUM\("users"."age"\) > 100/, sql)
   end
 
   def test_default_where_syntax
-    assert_match(/WHERE "users"."name" = 'Ruby' AND "users"."age" = 19/,
+    assert_sql(/WHERE "users"."name" = 'Ruby' AND "users"."age" = 19/,
       User.where(name: 'Ruby', age: 19).to_sql)
   end
 end

data/test/test_helper.rb

@@ -5,9 +5,89 @@ require 'minitest/autorun'
 Bundler.require
 
 require 'active_record'
+require 'etc'
 
-config = {:adapter => 'sqlite3', :database => ':memory:'}
-ActiveRecord::Base.establish_connection(config)
+# Which database to generate SQL for.  The tests only build queries, so any
+# server reachable without further setup will do; the devcontainer runs
+# PostgreSQL and MariaDB on localhost with a passwordless account named after
+# the container user.
+#
+#   rake test                  # sqlite3
+#   ADAPTER=postgresql rake test
+#   ADAPTER=mysql2 rake test
+#   rake test:all              # all three in turn
+ADAPTER = ENV.fetch('ADAPTER', 'sqlite3')
+
+DATABASE_NAME = 'activerecord_refined_test'.freeze
+
+DATABASE_CONFIG =
+  case ADAPTER
+  when 'sqlite3'
+    {adapter: 'sqlite3', database: ':memory:'}
+  when 'postgresql', 'mysql2'
+    {
+      adapter: ADAPTER,
+      host: ENV.fetch('DB_HOST', '127.0.0.1'),
+      username: ENV.fetch('DB_USERNAME') { Etc.getlogin },
+      password: ENV['DB_PASSWORD'],
+      database: DATABASE_NAME,
+    }
+  else
+    raise ArgumentError, "unknown ADAPTER: #{ADAPTER}"
+  end
+
+# The server databases persist between runs, so create one on first use.
+unless ADAPTER == 'sqlite3'
+  maintenance_database = ADAPTER == 'postgresql' ? 'postgres' : 'mysql'
+  ActiveRecord::Base.establish_connection(
+    DATABASE_CONFIG.merge(database: maintenance_database))
+  begin
+    ActiveRecord::Base.lease_connection.create_database(DATABASE_NAME)
+  rescue ActiveRecord::DatabaseAlreadyExists
+  end
+  ActiveRecord::Base.remove_connection
+end
+
+ActiveRecord::Base.establish_connection(DATABASE_CONFIG)
+
+module SqlAssertions
+  # Arel spells the regexp match differently per adapter, and raises on the
+  # ones missing from this list.
+  REGEXP_OPERATORS = {
+    'postgresql' => ['~', '!~'],
+    'mysql2' => ['REGEXP', 'NOT REGEXP'],
+  }.freeze
+
+  def skip_without_regexp_support
+    skip "#{ADAPTER} has no regexp operator" unless REGEXP_OPERATORS.key?(ADAPTER)
+  end
+
+  def regexp_operator
+    Regexp.escape(REGEXP_OPERATORS.fetch(ADAPTER).first)
+  end
+
+  def not_regexp_operator
+    Regexp.escape(REGEXP_OPERATORS.fetch(ADAPTER).last)
+  end
+
+  # MySQL quotes identifiers with backticks instead of double quotes, and
+  # doubles the backslashes inside string literals because backslash is itself
+  # an escape character there.  Normalising both lets a single expectation
+  # cover every adapter.
+  def normalize_sql(sql)
+    sql.tr('`', '"').gsub("\\\\") { "\\" }
+  end
+
+  # Takes a relation or the SQL string of one.
+  def assert_sql(pattern, relation_or_sql)
+    sql = relation_or_sql.respond_to?(:to_sql) ? relation_or_sql.to_sql : relation_or_sql
+    assert_match(pattern, normalize_sql(sql))
+  end
+end
+
+class Minitest::Test
+  include SqlAssertions
+end
 
 class User < ActiveRecord::Base
 end
@@ -22,6 +102,9 @@ end
 
 class CreateAllTables < ActiveRecord::Migration[8.1]
   def up
+    drop_table(:users, if_exists: true)
+    drop_table(:authors, if_exists: true)
+    drop_table(:posts, if_exists: true)
     create_table(:users) {|t| t.string :name; t.integer :age}
     create_table(:authors) {|t| t.string :name}
     create_table(:posts) {|t| t.string :title; t.integer :author_id}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-refined
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.2
 platform: ruby
 authors:
   - Shugo Maeda
@@ -80,12 +80,16 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+  - .github/workflows/push_gem.yml
+  - .github/workflows/test.yml
   - .gitignore
   - Gemfile
   - LICENSE.txt
   - README.md
   - Rakefile
   - activerecord-refined.gemspec
+  - examples/aggregations.rb
+  - examples/complex_joins.rb
   - lib/active_record/refined.rb
   - lib/active_record/refined/ast.rb
   - lib/activerecord-refined.rb
@@ -113,7 +117,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.1.0.dev
 specification_version: 4
-summary: ActiveRecord + Ruby 2.0 refinements
+summary: "ActiveRecord + Ruby 4.1 Proc#refined"
 test_files:
   - test/test_block_syntax.rb
   - test/test_helper.rb