arel-extensions 8.1.0 → 9.0.0

data/test/binary_value_test.rb

@@ -1,23 +0,0 @@
-require 'test_helper'
-
-class BinaryValueTest < ActiveSupport::TestCase
-
-  test 'binary value' do
-    query = Property.where( Arel::Nodes::BinaryValue.new("\x01\x01\x00\x00\x00\xC0K\x9B\x84\xD0.<@\b\x96\xA2n\x84%&@") )
-
-    assert_equal(<<~SQL.gsub(/( +|\n)/, ' ').strip, query.to_sql)
-      SELECT "properties".* FROM "properties"
-      WHERE '\\x0101000000c04b9b84d02e3c400896a26e84252640'
-    SQL
-  end
-
-  test 'hex encoded binary value' do
-    query = Property.where( Arel::Nodes::HexEncodedBinaryValue.new("0101000000c04b9b84d02e3c400896a26e84252640") )
-
-    assert_equal(<<~SQL.gsub(/( +|\n)/, ' ').strip, query.to_sql)
-      SELECT "properties".* FROM "properties"
-      WHERE '\\x0101000000c04b9b84d02e3c400896a26e84252640'
-    SQL
-  end
-
-end

data/test/database.rb

@@ -1,51 +0,0 @@
-ActiveRecord::Base.establish_connection({
-  adapter:  "postgis",
-  database: "arel-extensions-test",
-  encoding: "utf8"
-})
-
-db_config = ActiveRecord::Base.connection_db_config
-task = ActiveRecord::Tasks::PostgreSQLDatabaseTasks.new(db_config)
-task.drop
-task.create
-
-ActiveRecord::Migration.suppress_messages do
-  ActiveRecord::Schema.define do
-    enable_extension "postgis"
-
-    create_table "addresses", force: :cascade do |t|
-      t.integer  "name"
-      t.integer  "property_id"
-      t.geometry "location",             limit: {:type=>"Point", :srid=>"4326"}
-    end
-
-    create_table "properties", force: :cascade do |t|
-      t.string   "name",                 limit: 255
-      t.tsvector 'vector_col'
-      t.jsonb     'metadata'
-    end
-
-  end
-end
-
-class Address < ActiveRecord::Base
-  belongs_to :property
-end
-
-class Property < ActiveRecord::Base
-  has_many :addresses
-end
-
-class SunstoneRecord < ActiveRecord::Base
-  self.abstract_class = true
-end
-
-class SunstoneAddress < SunstoneRecord
-  belongs_to :property, class_name: 'SunstoneProperty'
-end
-
-class SunstoneProperty < SunstoneRecord
-  has_many :addresses, class_name: 'SunstoneAddress'
-end
-
-SunstoneRecord.establish_connection(adapter: 'sunstone', url: 'http://example.com')

data/test/gis_test.rb

@@ -1,23 +0,0 @@
-require 'test_helper'
-
-class GISTest < ActiveSupport::TestCase
-
-  test 'intersects' do
-    query = Address.arel_table['location'].intersects('POINT (28.182869232095754 11.073276002261096)')
-
-    assert_equal(<<~SQL.gsub(/( +|\n)/, ' ').strip, query.to_sql)
-      ST_Intersects("addresses"."location", '0101000000c04b9b84d02e3c400896a26e84252640')
-    SQL
-  end
-
-  test 'within' do
-    query = Address.arel_table['location'].within('POINT (28.182869232095754 11.073276002261096)')
-
-    assert_equal(<<~SQL.gsub(/( +|\n)/, ' ').strip, query.to_sql)
-      ST_Within("addresses"."location", '0101000000c04b9b84d02e3c400896a26e84252640')
-    SQL
-
-    result = Address.where(query).first
-  end
-
-end

data/test/order_test.rb

@@ -1,83 +0,0 @@
-require 'test_helper'
-
-class OrderTest < ActiveSupport::TestCase
-
-  test '::order(column.asc)' do
-    assert_sql(<<~SQL, Property.order(Property.arel_table[:id].asc))
-      SELECT "properties".* FROM "properties" ORDER BY "properties"."id" ASC
-    SQL
-  end
-
-  test '::order(column1.asc, column2.asc)' do
-    assert_sql(<<~SQL, Property.order(Property.arel_table[:id].asc, Property.arel_table[:name].asc))
-      SELECT "properties".* FROM "properties" ORDER BY "properties"."id" ASC, "properties"."name" ASC
-    SQL
-  end
-
-  test '::order(column.desc)' do
-    assert_sql(<<~SQL, Property.order(Property.arel_table[:id].desc))
-      SELECT "properties".* FROM "properties" ORDER BY "properties"."id" DESC
-    SQL
-  end
-
-  test '::order(column.asc(:nulls_first))' do
-    assert_sql(<<~SQL, Property.order(Property.arel_table[:id].asc(:nulls_first)))
-      SELECT "properties".* FROM "properties" ORDER BY "properties"."id" ASC NULLS FIRST
-    SQL
-  end
-  
-  test '::order(column.asc(:nulls_last))' do
-    assert_sql(<<~SQL, Property.order(Property.arel_table[:id].asc(:nulls_last)))
-      SELECT "properties".* FROM "properties" ORDER BY "properties"."id" ASC NULLS LAST
-    SQL
-  end
-
-  test '::order(column.desc(:nulls_first))' do
-    assert_sql(<<~SQL, Property.order(Property.arel_table[:id].desc(:nulls_first)))
-      SELECT "properties".* FROM "properties" ORDER BY "properties"."id" DESC NULLS FIRST
-    SQL
-  end
-  
-  test '::order(column.desc(:nulls_last))' do
-    assert_sql(<<~SQL, Property.order(Property.arel_table[:id].desc(:nulls_last)))
-      SELECT "properties".* FROM "properties" ORDER BY "properties"."id" DESC NULLS LAST
-    SQL
-  end
-
-  # Test reversing orders
-  test '::order(column.asc.reverse)' do
-    assert_sql(<<~SQL, Property.order(Property.arel_table[:id].asc.reverse))
-      SELECT "properties".* FROM "properties" ORDER BY "properties"."id" DESC
-    SQL
-  end
-
-  test '::order(column.desc.reverse)' do
-    assert_sql(<<~SQL, Property.order(Property.arel_table[:id].desc.reverse))
-      SELECT "properties".* FROM "properties" ORDER BY "properties"."id" ASC
-    SQL
-  end
-
-  test '::order(column.asc(:nulls_first).reverse)' do
-    assert_sql(<<~SQL, Property.order(Property.arel_table[:id].asc(:nulls_first).reverse))
-      SELECT "properties".* FROM "properties" ORDER BY "properties"."id" DESC NULLS LAST
-    SQL
-  end
-  
-  test '::order(column.asc(:nulls_last).reverse)' do
-    assert_sql(<<~SQL, Property.order(Property.arel_table[:id].asc(:nulls_last).reverse))
-      SELECT "properties".* FROM "properties" ORDER BY "properties"."id" DESC NULLS FIRST
-    SQL
-  end
-
-  test '::order(column.desc(:nulls_first).reverse)' do
-    assert_sql(<<~SQL, Property.order(Property.arel_table[:id].desc(:nulls_first).reverse))
-      SELECT "properties".* FROM "properties" ORDER BY "properties"."id" ASC NULLS LAST
-    SQL
-  end
-  
-  test '::order(column.desc(:nulls_last).reverse)' do
-    assert_sql(<<~SQL, Property.order(Property.arel_table[:id].desc(:nulls_last).reverse))
-      SELECT "properties".* FROM "properties" ORDER BY "properties"."id" ASC NULLS FIRST
-    SQL
-  end
-end

data/test/sunstone_test.rb

@@ -1,149 +0,0 @@
-require 'test_helper'
-
-class SunstoneTest < ActiveSupport::TestCase
-
-  # schema do
-  #   create_table "properties", force: :cascade do |t|
-  #     t.jsonb     'metadata'
-  #   end
-  # end
-
-  # class Property < ActiveRecord::Base
-  # end
-
-  # test "::filter json_column: STRING throws an error" do
-  #   assert_raises(ActiveRecord::UnkownFilterError) do
-  #     Property.filter(metadata: 'string').load
-  #   end
-  # end
-  
-  # test "::filter json_column: {eq: JSON_HASH}" do
-  #   query = Property.where(metadata: {eq: {json: 'string'}})
-  #   assert_equal(<<-SQL.strip.gsub(/\s+/, ' '), query.to_sql.strip)
-  #     SELECT "properties".*
-  #     FROM "properties"
-  #     WHERE "properties"."metadata" = '{\"json\":\"string\"}'
-  #   SQL
-  # end
-  
-  test "::filter json_column: {contains: JSON_HASH}" do
-    query = SunstoneProperty.where(SunstoneProperty.arel_table['metadata'].contains({json: 'string'}))
-    assert_sar(query, 'GET', '/sunstone_properties', {
-      where: {metadata: {contains: { json: 'string' }}}
-    })
-    
-    # query = Property.where(metadata: {contains: {json: 'string'}})
-    # assert_equal(<<-SQL.strip.gsub(/\s+/, ' '), query.to_sql.strip)
-    #   SELECT "properties".*
-    #   FROM "properties"
-    #   WHERE "properties"."metadata" @> '{\"json\":\"string\"}'
-    # SQL
-  end
-
-  # test "::filter json_column: {contained_by: JSON_HASH}" do
-  #   query = Property.filter(metadata: {contained_by: {json: 'string'}})
-  #   assert_equal(<<-SQL.strip.gsub(/\s+/, ' '), query.to_sql.strip)
-  #     SELECT "properties".*
-  #     FROM "properties"
-  #     WHERE "properties"."metadata" <@ '{\"json\":\"string\"}'
-  #   SQL
-  # end
-  
-  # test "::filter json_column: {has_key: STRING}" do
-  #   query = Property.filter(metadata: {has_key: 'string'})
-  #   assert_equal(<<-SQL.strip.gsub(/\s+/, ' '), query.to_sql.strip)
-  #     SELECT "properties".*
-  #     FROM "properties"
-  #     WHERE "properties"."metadata" ? 'string'
-  #   SQL
-  # end
-  
-  # test "::filter json_column.subkey: {eq: JSON_HASH}" do
-  #   query = Property.filter("metadata.subkey" => {eq: 'string'})
-  #   assert_equal(<<-SQL.strip.gsub(/\s+/, ' '), query.to_sql.strip)
-  #     SELECT "properties".*
-  #     FROM "properties"
-  #     WHERE "properties"."metadata"#>'{subkey}' = 'string'
-  #   SQL
-  # end
-  
-  # test "::filter json_column: BOOLEAN" do
-  #   query = Property.filter(metadata: true)
-  #   assert_equal(<<-SQL.strip.gsub(/\s+/, ' '), query.to_sql.strip)
-  #     SELECT "properties".*
-  #     FROM "properties"
-  #     WHERE "properties"."metadata" IS NOT NULL
-  #   SQL
-    
-  #   query = Property.filter(metadata: "true")
-  #   assert_equal(<<-SQL.strip.gsub(/\s+/, ' '), query.to_sql.strip)
-  #     SELECT "properties".*
-  #     FROM "properties"
-  #     WHERE "properties"."metadata" IS NOT NULL
-  #   SQL
-    
-  #   query = Property.filter(metadata: false)
-  #   assert_equal(<<-SQL.strip.gsub(/\s+/, ' '), query.to_sql.strip)
-  #     SELECT "properties".*
-  #     FROM "properties"
-  #     WHERE "properties"."metadata" IS NULL
-  #   SQL
-    
-  #   query = Property.filter(metadata: "false")
-  #   assert_equal(<<-SQL.strip.gsub(/\s+/, ' '), query.to_sql.strip)
-  #     SELECT "properties".*
-  #     FROM "properties"
-  #     WHERE "properties"."metadata" IS NULL
-  #   SQL
-  # end
-
-  test '::order(column.asc)' do
-    query = SunstoneProperty.order(SunstoneProperty.arel_table[:id].asc)
-    assert_sar(query, 'GET', '/sunstone_properties', {
-      order: [{ id: :asc }]
-    })
-  end
-
-  test '::order(column1.asc, column2.asc)' do
-    query = SunstoneProperty.order(SunstoneProperty.arel_table[:id].asc, SunstoneProperty.arel_table[:name].asc)
-    assert_sar(query, 'GET', '/sunstone_properties', {
-      order: [{ id: :asc }, { name: :asc }]
-    })
-  end
-
-  test '::order(column.desc)' do
-    query = SunstoneProperty.order(SunstoneProperty.arel_table[:id].desc)
-    assert_sar(query, 'GET', '/sunstone_properties', {
-      order: [{ id: :desc }]
-    })
-  end
-
-  test '::order(column.asc(:nulls_first))' do
-    query = SunstoneProperty.order(SunstoneProperty.arel_table[:id].asc(:nulls_first))
-    assert_sar(query, 'GET', '/sunstone_properties', {
-      order: [{ id: { asc: :nulls_first } }]
-    })
-  end
-  
-  test '::order(column.asc(:nulls_last))' do
-    query = SunstoneProperty.order(SunstoneProperty.arel_table[:id].asc(:nulls_last))
-    assert_sar(query, 'GET', '/sunstone_properties', {
-      order: [{ id: { asc: :nulls_last } }]
-    })
-  end
-
-  test '::order(column.desc(:nulls_first))' do
-    query = SunstoneProperty.order(SunstoneProperty.arel_table[:id].desc(:nulls_first))
-    assert_sar(query, 'GET', '/sunstone_properties', {
-      order: [{ id: { desc: :nulls_first } }]
-    })
-  end
-  
-  test '::order(column.desc(:nulls_last))' do
-    query = SunstoneProperty.order(SunstoneProperty.arel_table[:id].desc(:nulls_last))
-    assert_sar(query, 'GET', '/sunstone_properties', {
-      order: [{ id: { desc: :nulls_last } }]
-    })
-  end
-
-end

data/test/test_helper.rb

@@ -1,209 +0,0 @@
-# To make testing/debugging easier, test within this source tree versus an
-# installed gem
-$LOAD_PATH << File.expand_path('../lib', __FILE__)
-
-# require 'simplecov'
-# SimpleCov.start do
-#   add_group 'lib', 'sunstone/lib'
-#   add_group 'ext', 'sunstone/ext'
-# end
-
-require 'rgeo'
-require 'debug'
-require "minitest/autorun"
-require 'minitest/reporters'
-require 'webmock/minitest'
-# require 'mocha/minitest'
-require 'active_record'
-require 'sunstone'
-require 'arel/extensions'
-require 'activerecord-postgis-adapter'
-
-# Setup the test db
-ActiveSupport.test_order = :random
-require File.expand_path('../database', __FILE__)
-
-Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
-
-$debugging = false
-
-# File 'lib/active_support/testing/declarative.rb', somewhere in rails....
-class ActiveSupport::TestCase
-  include WebMock::API
-
-  # File 'lib/active_support/testing/declarative.rb'
-  def self.test(name, &block)
-    test_name = "test_#{name.gsub(/\s+/, '_')}".to_sym
-    defined = method_defined? test_name
-    raise "#{test_name} is already defined in #{self}" if defined
-    if block_given?
-      define_method(test_name, &block)
-    else
-      define_method(test_name) do
-        skip "No implementation provided for #{name}"
-      end
-    end
-  end
-
-  def webmock(method, path, query=nil)
-    query = deep_transform_query(query) if query
-
-    stub_request(method, /^#{ActiveRecord::Base.connection.instance_variable_get(:@connection).url}/).with do |req|
-      if query
-        req&.uri&.path == path && req.uri.query && unpack(req.uri.query.sub(/=true$/, '')) == query
-      else
-        req&.uri&.path == path && req.uri.query.nil?
-      end
-    end
-  end
-
-  def setup
-    sunstone_schema = {
-      addresses: {
-        columns: {
-          id: { type: :integer, primary_key: true, null: false, array: false },
-          name: { type: :string, primary_key: false, null: true, array: false },
-          property_id: { type: :integer, primary_key: false, null: true, array: false }
-        }
-      },
-      properties: {
-        columns: {
-          id: { type: :integer, primary_key: true, null: false, array: false },
-          name: { type: :string, primary_key: false, null: true, array: false },
-          metadata: { type: :json, primary_key: false, null: true, array: false }
-        }
-      }
-    }
-
-    req_stub = stub_request(:get, /^http:\/\/example.com/).with do |req|
-      case req.uri.path
-      when '/tables'
-        true
-      when /^\/\w+\/schema$/i
-        true
-      else
-        false
-      end
-    end
-
-    req_stub.to_return do |req|
-      case req.uri.path
-      when '/tables'
-        {
-          body: sunstone_schema.keys.to_json,
-          headers: { 'StandardAPI-Version' => '5.0.0.5' }
-        }
-      when /^\/(\w+)\/schema$/i
-        {
-          body: sunstone_schema[$1.to_sym].to_json,
-          headers: { 'StandardAPI-Version' => '5.0.0.5' }
-        }
-      end
-    end
-  end
-
-  def debug
-    ActiveRecord::Base.logger = Logger.new(STDOUT)
-    $debugging = true
-    yield
-  ensure
-    ActiveRecord::Base.logger = nil
-    $debugging = false
-  end
-
-
-  class SQLLogger
-    class << self
-      attr_accessor :ignored_sql, :log, :log_all
-      def clear_log; self.log = []; self.log_all = []; end
-    end
-
-    self.clear_log
-
-    self.ignored_sql = [/^PRAGMA/i, /^SELECT currval/i, /^SELECT CAST/i, /^SELECT @@IDENTITY/i, /^SELECT @@ROWCOUNT/i, /^SAVEPOINT/i, /^ROLLBACK TO SAVEPOINT/i, /^RELEASE SAVEPOINT/i, /^SHOW max_identifier_length/i, /^BEGIN/i, /^COMMIT/i]
-
-    # FIXME: this needs to be refactored so specific database can add their own
-    # ignored SQL, or better yet, use a different notification for the queries
-    # instead examining the SQL content.
-    oracle_ignored     = [/^select .*nextval/i, /^SAVEPOINT/, /^ROLLBACK TO/, /^\s*select .* from all_triggers/im, /^\s*select .* from all_constraints/im, /^\s*select .* from all_tab_cols/im]
-    mysql_ignored      = [/^SHOW FULL TABLES/i, /^SHOW FULL FIELDS/, /^SHOW CREATE TABLE /i, /^SHOW VARIABLES /, /^\s*SELECT (?:column_name|table_name)\b.*\bFROM information_schema\.(?:key_column_usage|tables)\b/im]
-    postgresql_ignored = [/^\s*select\b.*\bfrom\b.*pg_namespace\b/im, /^\s*select tablename\b.*from pg_tables\b/im, /^\s*select\b.*\battname\b.*\bfrom\b.*\bpg_attribute\b/im, /^SHOW search_path/i]
-    sqlite3_ignored =    [/^\s*SELECT name\b.*\bFROM sqlite_master/im, /^\s*SELECT sql\b.*\bFROM sqlite_master/im]
-
-    [oracle_ignored, mysql_ignored, postgresql_ignored, sqlite3_ignored].each do |db_ignored_sql|
-      ignored_sql.concat db_ignored_sql
-    end
-
-    attr_reader :ignore
-
-    def initialize(ignore = Regexp.union(self.class.ignored_sql))
-      @ignore = ignore
-    end
-
-    def call(name, start, finish, message_id, values)
-      sql = values[:sql]
-
-      # FIXME: this seems bad. we should probably have a better way to indicate
-      # the query was cached
-      return if 'CACHE' == values[:name]
-
-      self.class.log_all << sql
-      unless ignore =~ sql
-        if $debugging
-        puts caller.select { |l| l.starts_with?(File.expand_path('../../lib', __FILE__)) }
-        puts "\n\n"
-        end
-      end
-      self.class.log << sql unless ignore =~ sql
-    end
-  end
-  ActiveSupport::Notifications.subscribe('sql.active_record', SQLLogger.new)
-
-  def deep_transform_query(object)
-    case object
-    when Hash
-      object.each_with_object({}) do |(key, value), result|
-        result[key.to_s] = deep_transform_query(value)
-      end
-    when Array
-      object.map {|e| deep_transform_query(e) }
-    when Symbol
-      object.to_s
-    else
-      object
-    end
-  end
-
-  def assert_sar(query, method, path, query_params = {}, body = nil)
-    sar = query.to_sar
-
-    assert_equal method, sar.method
-    assert_equal path, sar.path.split('?').first
-    assert_equal deep_transform_query(query_params), MessagePack.unpack(CGI::unescape(sar.path.split('?').last))
-    if body.nil?
-      assert_nil sar.body
-    else
-      assert_equal body, sar.body
-    end
-  end
-
-  def assert_sql(expected, query)
-    assert_equal expected.strip, query.to_sql.strip.gsub(/\s+/, ' ')
-  end
-  # test/unit backwards compatibility methods
-  alias :assert_raise :assert_raises
-  alias :assert_not_empty :refute_empty
-  alias :assert_not_equal :refute_equal
-  alias :assert_not_in_delta :refute_in_delta
-  alias :assert_not_in_epsilon :refute_in_epsilon
-  alias :assert_not_includes :refute_includes
-  alias :assert_not_instance_of :refute_instance_of
-  alias :assert_not_kind_of :refute_kind_of
-  alias :assert_no_match :refute_match
-  alias :assert_not_nil :refute_nil
-  alias :assert_not_operator :refute_operator
-  alias :assert_not_predicate :refute_predicate
-  alias :assert_not_respond_to :refute_respond_to
-  alias :assert_not_same :refute_same
-
-end

data/test/ts_test.rb

@@ -1,151 +0,0 @@
-require 'test_helper'
-
-class TSTest < ActiveSupport::TestCase
-
-  test 'tsquery(query)' do
-    query = Property.where( Arel::Nodes::TSQuery.new('query') )
-
-    assert_equal(<<~SQL.gsub(/( +|\n)/, ' ').strip, query.to_sql)
-      SELECT "properties".* FROM "properties"
-      WHERE to_tsquery('query')
-    SQL
-  end
-  
-  test 'tsquery(query, language: lang)' do
-    query = Property.where( Arel::Nodes::TSQuery.new('query', language: 'lang') )
-
-    assert_equal(<<~SQL.gsub(/( +|\n)/, ' ').strip, query.to_sql)
-      SELECT "properties".* FROM "properties"
-      WHERE to_tsquery('lang', 'query')
-    SQL
-  end
-  
-  test 'tsvector(attribute)' do
-    query = Property.where( Arel::Nodes::TSVector.new(Property.arel_table[:name]) )
-
-    assert_equal(<<~SQL.gsub(/( +|\n)/, ' ').strip, query.to_sql)
-      SELECT "properties".* FROM "properties"
-      WHERE to_tsvector("properties"."name")
-    SQL
-  end
-  
-  test 'tsvector(text)' do
-    query = Property.where( Arel::Nodes::TSVector.new(
-      Arel::Nodes::Quoted.new("my data O'Malley")
-    ))
-
-    assert_equal(<<~SQL.gsub(/( +|\n)/, ' ').strip, query.to_sql)
-      SELECT "properties".* FROM "properties"
-      WHERE to_tsvector('my data O''Malley')
-    SQL
-  end
-
-  test 'tsvector(attribute, language: lang)' do
-    query = Property.where( Arel::Nodes::TSVector.new(Property.arel_table[:name], language: 'lang') )
-
-    assert_equal(<<~SQL.gsub(/( +|\n)/, ' ').strip, query.to_sql)
-      SELECT "properties".* FROM "properties"
-      WHERE to_tsvector('lang', "properties"."name")
-    SQL
-  end
-
-  test 'ts_match(attrbute, tsquery)' do
-    query = Property.where(
-      Arel::Nodes::TSMatch.new(
-        Property.arel_table[:name],
-        Arel::Nodes::TSQuery.new('query')
-      )
-    )
-
-    assert_equal(<<~SQL.gsub(/( +|\n)/, ' ').strip, query.to_sql)
-      SELECT "properties".* FROM "properties"
-      WHERE "properties"."name" @@ to_tsquery('query')
-    SQL
-  end
-
-  test 'ts_match(tsvector, tsquery)' do
-    query = Property.where(
-      Arel::Nodes::TSMatch.new(
-        Arel::Nodes::TSVector.new(Property.arel_table[:name]),
-        Arel::Nodes::TSQuery.new('query')
-      )
-    )
-
-    assert_equal(<<~SQL.gsub(/( +|\n)/, ' ').strip, query.to_sql)
-      SELECT "properties".* FROM "properties"
-      WHERE to_tsvector("properties"."name") @@ to_tsquery('query')
-    SQL
-  end
-
-  test 'ts_rank(attribute, tsquery)' do
-    query = Property.where(
-      Arel::Nodes::TSRank.new(
-        Property.arel_table[:name],
-        Arel::Nodes::TSQuery.new('query')
-      )
-    )
-    
-    assert_equal(<<~SQL.gsub(/( +|\n)/, ' ').strip, query.to_sql)
-      SELECT "properties".* FROM "properties"
-      WHERE ts_rank("properties"."name", to_tsquery('query'))
-    SQL
-  end
-    
-  test 'ts_rank(tsvector, tsquery)' do
-    query = Property.where(
-      Arel::Nodes::TSRank.new(
-        Arel::Nodes::TSVector.new(Property.arel_table[:name]),
-        Arel::Nodes::TSQuery.new('query')
-      )
-    )
-    
-    assert_equal(<<~SQL.gsub(/( +|\n)/, ' ').strip, query.to_sql)
-      SELECT "properties".* FROM "properties"
-      WHERE ts_rank(to_tsvector("properties"."name"), to_tsquery('query'))
-    SQL
-  end
-
-  test 'ts_rank_cd(attribute, tsquery)' do
-    query = Property.where(
-      Arel::Nodes::TSRankCD.new(
-        Property.arel_table[:name],
-        Arel::Nodes::TSQuery.new('query')
-      )
-    )
-    
-    assert_equal(<<~SQL.gsub(/( +|\n)/, ' ').strip, query.to_sql)
-      SELECT "properties".* FROM "properties"
-      WHERE ts_rank_cd("properties"."name", to_tsquery('query'))
-    SQL
-  end
-    
-  test 'ts_rank_cd(tsvector, tsquery)' do
-    query = Property.where(
-      Arel::Nodes::TSRankCD.new(
-        Arel::Nodes::TSVector.new(Property.arel_table[:name]),
-        Arel::Nodes::TSQuery.new('query')
-      )
-    )
-    
-    assert_equal(<<~SQL.gsub(/( +|\n)/, ' ').strip, query.to_sql)
-      SELECT "properties".* FROM "properties"
-      WHERE ts_rank_cd(to_tsvector("properties"."name"), to_tsquery('query'))
-    SQL
-  end
-
-  test 'ts_rank_cd(tsvector, tsquery, normalization)' do
-    query = Property.where(
-      Arel::Nodes::TSRankCD.new(
-        Arel::Nodes::TSVector.new(Property.arel_table[:name]),
-        Arel::Nodes::TSQuery.new('query'),
-        5
-      )
-    )
-    
-    assert_equal(<<~SQL.gsub(/( +|\n)/, ' ').strip, query.to_sql)
-      SELECT "properties".* FROM "properties"
-      WHERE ts_rank_cd(to_tsvector("properties"."name"), to_tsquery('query'), 5)
-    SQL
-  end
-
-end