From 4c0a3d48804a363c7e9272519665a21f601b5248 Mon Sep 17 00:00:00 2001 From: Matthew Draper Date: Sat, 24 Feb 2018 17:15:50 +1030 Subject: Arel: rubocop -a --- .../test/cases/arel/visitors/depth_first_test.rb | 7 +- .../arel/visitors/dispatch_contamination_test.rb | 14 +- activerecord/test/cases/arel/visitors/dot_test.rb | 5 +- .../test/cases/arel/visitors/ibm_db_test.rb | 10 +- .../test/cases/arel/visitors/informix_test.rb | 16 +- .../test/cases/arel/visitors/mssql_test.rb | 30 ++-- .../test/cases/arel/visitors/mysql_test.rb | 35 ++-- .../test/cases/arel/visitors/oracle12_test.rb | 19 ++- .../test/cases/arel/visitors/oracle_test.rb | 61 +++---- .../test/cases/arel/visitors/postgres_test.rb | 77 ++++----- .../test/cases/arel/visitors/sqlite_test.rb | 17 +- .../test/cases/arel/visitors/to_sql_test.rb | 185 +++++++++++---------- 12 files changed, 242 insertions(+), 234 deletions(-) (limited to 'activerecord/test/cases/arel/visitors') diff --git a/activerecord/test/cases/arel/visitors/depth_first_test.rb b/activerecord/test/cases/arel/visitors/depth_first_test.rb index b841d119d2..3baccc7316 100644 --- a/activerecord/test/cases/arel/visitors/depth_first_test.rb +++ b/activerecord/test/cases/arel/visitors/depth_first_test.rb @@ -1,11 +1,12 @@ # frozen_string_literal: true -require_relative '../helper' + +require_relative "../helper" module Arel module Visitors class TestDepthFirst < Arel::Test Collector = Struct.new(:calls) do - def call object + def call(object) calls << object end end @@ -164,7 +165,7 @@ module Arel def test_table relation = Arel::Table.new(:users) @visitor.accept relation - assert_equal ['users', relation], @collector.calls + assert_equal ["users", relation], @collector.calls end def test_array diff --git a/activerecord/test/cases/arel/visitors/dispatch_contamination_test.rb b/activerecord/test/cases/arel/visitors/dispatch_contamination_test.rb index eb278cde4c..a07a1a050a 100644 --- a/activerecord/test/cases/arel/visitors/dispatch_contamination_test.rb +++ b/activerecord/test/cases/arel/visitors/dispatch_contamination_test.rb @@ -1,6 +1,7 @@ # frozen_string_literal: true -require_relative '../helper' -require 'concurrent' + +require_relative "../helper" +require "concurrent" module Arel module Visitors @@ -10,14 +11,14 @@ module Arel @barrier = Concurrent::CyclicBarrier.new(2) end - def visit_Arel_Visitors_DummySuperNode node + def visit_Arel_Visitors_DummySuperNode(node) 42 end # This is terrible, but it's the only way to reliably reproduce # the possible race where two threads attempt to correct the # dispatch hash at the same time. - def send *args + def send(*args) super rescue # Both threads try (and fail) to dispatch to the subclass's name @@ -43,7 +44,7 @@ module Arel @table = Table.new(:users) end - it 'dispatches properly after failing upwards' do + it "dispatches properly after failing upwards" do node = Nodes::Union.new(Nodes::True.new, Nodes::False.new) assert_equal "( TRUE UNION FALSE )", node.to_sql @@ -52,7 +53,7 @@ module Arel assert_equal "( TRUE UNION FALSE )", node.to_sql end - it 'is threadsafe when implementing superclass fallback' do + it "is threadsafe when implementing superclass fallback" do visitor = DummyVisitor.new main_thread_finished = Concurrent::Event.new @@ -69,4 +70,3 @@ module Arel end end end - diff --git a/activerecord/test/cases/arel/visitors/dot_test.rb b/activerecord/test/cases/arel/visitors/dot_test.rb index 048482c3ca..98f3bab620 100644 --- a/activerecord/test/cases/arel/visitors/dot_test.rb +++ b/activerecord/test/cases/arel/visitors/dot_test.rb @@ -1,5 +1,6 @@ # frozen_string_literal: true -require_relative '../helper' + +require_relative "../helper" module Arel module Visitors @@ -23,7 +24,7 @@ module Arel end def test_named_function - func = Nodes::NamedFunction.new 'omg', 'omg' + func = Nodes::NamedFunction.new "omg", "omg" @visitor.accept func, Collectors::PlainString.new end diff --git a/activerecord/test/cases/arel/visitors/ibm_db_test.rb b/activerecord/test/cases/arel/visitors/ibm_db_test.rb index d7569eedc3..7163cb34d3 100644 --- a/activerecord/test/cases/arel/visitors/ibm_db_test.rb +++ b/activerecord/test/cases/arel/visitors/ibm_db_test.rb @@ -1,5 +1,6 @@ # frozen_string_literal: true -require_relative '../helper' + +require_relative "../helper" module Arel module Visitors @@ -8,18 +9,18 @@ module Arel @visitor = IBM_DB.new Table.engine.connection end - def compile node + def compile(node) @visitor.accept(node, Collectors::SQLString.new).value end - it 'uses FETCH FIRST n ROWS to limit results' do + it "uses FETCH FIRST n ROWS to limit results" do stmt = Nodes::SelectStatement.new stmt.limit = Nodes::Limit.new(1) sql = compile(stmt) sql.must_be_like "SELECT FETCH FIRST 1 ROWS ONLY" end - it 'uses FETCH FIRST n ROWS in updates with a limit' do + it "uses FETCH FIRST n ROWS in updates with a limit" do table = Table.new(:users) stmt = Nodes::UpdateStatement.new stmt.relation = table @@ -28,7 +29,6 @@ module Arel sql = compile(stmt) sql.must_be_like "UPDATE \"users\" WHERE \"users\".\"id\" IN (SELECT \"users\".\"id\" FROM \"users\" FETCH FIRST 1 ROWS ONLY)" end - end end end diff --git a/activerecord/test/cases/arel/visitors/informix_test.rb b/activerecord/test/cases/arel/visitors/informix_test.rb index bb6ff42f05..b0b031cca3 100644 --- a/activerecord/test/cases/arel/visitors/informix_test.rb +++ b/activerecord/test/cases/arel/visitors/informix_test.rb @@ -1,5 +1,6 @@ # frozen_string_literal: true -require_relative '../helper' + +require_relative "../helper" module Arel module Visitors @@ -8,18 +9,18 @@ module Arel @visitor = Informix.new Table.engine.connection end - def compile node + def compile(node) @visitor.accept(node, Collectors::SQLString.new).value end - it 'uses FIRST n to limit results' do + it "uses FIRST n to limit results" do stmt = Nodes::SelectStatement.new stmt.limit = Nodes::Limit.new(1) sql = compile(stmt) sql.must_be_like "SELECT FIRST 1" end - it 'uses FIRST n in updates with a limit' do + it "uses FIRST n in updates with a limit" do table = Table.new(:users) stmt = Nodes::UpdateStatement.new stmt.relation = table @@ -29,14 +30,14 @@ module Arel sql.must_be_like "UPDATE \"users\" WHERE \"users\".\"id\" IN (SELECT FIRST 1 \"users\".\"id\" FROM \"users\")" end - it 'uses SKIP n to jump results' do + it "uses SKIP n to jump results" do stmt = Nodes::SelectStatement.new stmt.offset = Nodes::Offset.new(10) sql = compile(stmt) sql.must_be_like "SELECT SKIP 10" end - it 'uses SKIP before FIRST' do + it "uses SKIP before FIRST" do stmt = Nodes::SelectStatement.new stmt.limit = Nodes::Limit.new(1) stmt.offset = Nodes::Offset.new(1) @@ -44,7 +45,7 @@ module Arel sql.must_be_like "SELECT SKIP 1 FIRST 1" end - it 'uses INNER JOIN to perform joins' do + it "uses INNER JOIN to perform joins" do core = Nodes::SelectCore.new table = Table.new(:posts) core.source = Nodes::JoinSource.new(table, [table.create_join(Table.new(:comments))]) @@ -53,7 +54,6 @@ module Arel sql = compile(stmt) sql.must_be_like 'SELECT FROM "posts" INNER JOIN "comments"' end - end end end diff --git a/activerecord/test/cases/arel/visitors/mssql_test.rb b/activerecord/test/cases/arel/visitors/mssql_test.rb index 4e81678813..340376c3d6 100644 --- a/activerecord/test/cases/arel/visitors/mssql_test.rb +++ b/activerecord/test/cases/arel/visitors/mssql_test.rb @@ -1,5 +1,6 @@ # frozen_string_literal: true -require_relative '../helper' + +require_relative "../helper" module Arel module Visitors @@ -9,17 +10,17 @@ module Arel @table = Arel::Table.new "users" end - def compile node + def compile(node) @visitor.accept(node, Collectors::SQLString.new).value end - it 'should not modify query if no offset or limit' do + it "should not modify query if no offset or limit" do stmt = Nodes::SelectStatement.new sql = compile(stmt) sql.must_be_like "SELECT" end - it 'should go over table PK if no .order() or .group()' do + it "should go over table PK if no .order() or .group()" do stmt = Nodes::SelectStatement.new stmt.cores.first.from = @table stmt.limit = Nodes::Limit.new(10) @@ -27,7 +28,7 @@ module Arel sql.must_be_like "SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY \"users\".\"id\") as _row_num FROM \"users\") as _t WHERE _row_num BETWEEN 1 AND 10" end - it 'caches the PK lookup for order' do + it "caches the PK lookup for order" do connection = Minitest::Mock.new connection.expect(:primary_key, ["id"], ["users"]) @@ -46,7 +47,7 @@ module Arel connection.verify end - it 'should use TOP for limited deletes' do + it "should use TOP for limited deletes" do stmt = Nodes::DeleteStatement.new stmt.relation = @table stmt.limit = Nodes::Limit.new(10) @@ -55,23 +56,23 @@ module Arel sql.must_be_like "DELETE TOP (10) FROM \"users\"" end - it 'should go over query ORDER BY if .order()' do + it "should go over query ORDER BY if .order()" do stmt = Nodes::SelectStatement.new stmt.limit = Nodes::Limit.new(10) - stmt.orders << Nodes::SqlLiteral.new('order_by') + stmt.orders << Nodes::SqlLiteral.new("order_by") sql = compile(stmt) sql.must_be_like "SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY order_by) as _row_num) as _t WHERE _row_num BETWEEN 1 AND 10" end - it 'should go over query GROUP BY if no .order() and there is .group()' do + it "should go over query GROUP BY if no .order() and there is .group()" do stmt = Nodes::SelectStatement.new - stmt.cores.first.groups << Nodes::SqlLiteral.new('group_by') + stmt.cores.first.groups << Nodes::SqlLiteral.new("group_by") stmt.limit = Nodes::Limit.new(10) sql = compile(stmt) sql.must_be_like "SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY group_by) as _row_num GROUP BY group_by) as _t WHERE _row_num BETWEEN 1 AND 10" end - it 'should use BETWEEN if both .limit() and .offset' do + it "should use BETWEEN if both .limit() and .offset" do stmt = Nodes::SelectStatement.new stmt.limit = Nodes::Limit.new(10) stmt.offset = Nodes::Offset.new(20) @@ -79,21 +80,20 @@ module Arel sql.must_be_like "SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY ) as _row_num) as _t WHERE _row_num BETWEEN 21 AND 30" end - it 'should use >= if only .offset' do + it "should use >= if only .offset" do stmt = Nodes::SelectStatement.new stmt.offset = Nodes::Offset.new(20) sql = compile(stmt) sql.must_be_like "SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY ) as _row_num) as _t WHERE _row_num >= 21" end - it 'should generate subquery for .count' do + it "should generate subquery for .count" do stmt = Nodes::SelectStatement.new stmt.limit = Nodes::Limit.new(10) - stmt.cores.first.projections << Nodes::Count.new('*') + stmt.cores.first.projections << Nodes::Count.new("*") sql = compile(stmt) sql.must_be_like "SELECT COUNT(1) as count_id FROM (SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY ) as _row_num) as _t WHERE _row_num BETWEEN 1 AND 10) AS subquery" end - end end end diff --git a/activerecord/test/cases/arel/visitors/mysql_test.rb b/activerecord/test/cases/arel/visitors/mysql_test.rb index f9b468b1d2..9d3bad8516 100644 --- a/activerecord/test/cases/arel/visitors/mysql_test.rb +++ b/activerecord/test/cases/arel/visitors/mysql_test.rb @@ -1,5 +1,6 @@ # frozen_string_literal: true -require_relative '../helper' + +require_relative "../helper" module Arel module Visitors @@ -8,24 +9,24 @@ module Arel @visitor = MySQL.new Table.engine.connection end - def compile node + def compile(node) @visitor.accept(node, Collectors::SQLString.new).value end - it 'squashes parenthesis on multiple unions' do - subnode = Nodes::Union.new Arel.sql('left'), Arel.sql('right') - node = Nodes::Union.new subnode, Arel.sql('topright') - assert_equal 1, compile(node).scan('(').length + it "squashes parenthesis on multiple unions" do + subnode = Nodes::Union.new Arel.sql("left"), Arel.sql("right") + node = Nodes::Union.new subnode, Arel.sql("topright") + assert_equal 1, compile(node).scan("(").length - subnode = Nodes::Union.new Arel.sql('left'), Arel.sql('right') - node = Nodes::Union.new Arel.sql('topleft'), subnode - assert_equal 1, compile(node).scan('(').length + subnode = Nodes::Union.new Arel.sql("left"), Arel.sql("right") + node = Nodes::Union.new Arel.sql("topleft"), subnode + assert_equal 1, compile(node).scan("(").length end ### # :'( # http://dev.mysql.com/doc/refman/5.0/en/select.html#id3482214 - it 'defaults limit to 18446744073709551615' do + it "defaults limit to 18446744073709551615" do stmt = Nodes::SelectStatement.new stmt.offset = Nodes::Offset.new(1) sql = compile(stmt) @@ -39,20 +40,20 @@ module Arel assert_equal("UPDATE \"users\" LIMIT 'omg'", compile(sc)) end - it 'uses DUAL for empty from' do + it "uses DUAL for empty from" do stmt = Nodes::SelectStatement.new sql = compile(stmt) sql.must_be_like "SELECT FROM DUAL" end - describe 'locking' do - it 'defaults to FOR UPDATE when locking' do - node = Nodes::Lock.new(Arel.sql('FOR UPDATE')) + describe "locking" do + it "defaults to FOR UPDATE when locking" do + node = Nodes::Lock.new(Arel.sql("FOR UPDATE")) compile(node).must_be_like "FOR UPDATE" end - it 'allows a custom string to be used as a lock' do - node = Nodes::Lock.new(Arel.sql('LOCK IN SHARE MODE')) + it "allows a custom string to be used as a lock" do + node = Nodes::Lock.new(Arel.sql("LOCK IN SHARE MODE")) compile(node).must_be_like "LOCK IN SHARE MODE" end end @@ -68,7 +69,7 @@ module Arel it "concats a string" do @table = Table.new(:users) - query = @table[:name].concat(Nodes.build_quoted('abc')) + query = @table[:name].concat(Nodes.build_quoted("abc")) compile(query).must_be_like %{ CONCAT("users"."name", 'abc') } diff --git a/activerecord/test/cases/arel/visitors/oracle12_test.rb b/activerecord/test/cases/arel/visitors/oracle12_test.rb index ef2050b7c9..83a2ee36ca 100644 --- a/activerecord/test/cases/arel/visitors/oracle12_test.rb +++ b/activerecord/test/cases/arel/visitors/oracle12_test.rb @@ -1,5 +1,6 @@ # frozen_string_literal: true -require_relative '../helper' + +require_relative "../helper" module Arel module Visitors @@ -9,11 +10,11 @@ module Arel @table = Table.new(:users) end - def compile node + def compile(node) @visitor.accept(node, Collectors::SQLString.new).value end - it 'modified except to be minus' do + it "modified except to be minus" do left = Nodes::SqlLiteral.new("SELECT * FROM users WHERE age > 10") right = Nodes::SqlLiteral.new("SELECT * FROM users WHERE age > 20") sql = compile Nodes::Except.new(left, right) @@ -22,7 +23,7 @@ module Arel } end - it 'generates select options offset then limit' do + it "generates select options offset then limit" do stmt = Nodes::SelectStatement.new stmt.offset = Nodes::Offset.new(1) stmt.limit = Nodes::Limit.new(10) @@ -30,18 +31,18 @@ module Arel sql.must_be_like "SELECT OFFSET 1 ROWS FETCH FIRST 10 ROWS ONLY" end - describe 'locking' do - it 'generates ArgumentError if limit and lock are used' do + describe "locking" do + it "generates ArgumentError if limit and lock are used" do stmt = Nodes::SelectStatement.new stmt.limit = Nodes::Limit.new(10) - stmt.lock = Nodes::Lock.new(Arel.sql('FOR UPDATE')) + stmt.lock = Nodes::Lock.new(Arel.sql("FOR UPDATE")) assert_raises ArgumentError do compile(stmt) end end - it 'defaults to FOR UPDATE when locking' do - node = Nodes::Lock.new(Arel.sql('FOR UPDATE')) + it "defaults to FOR UPDATE when locking" do + node = Nodes::Lock.new(Arel.sql("FOR UPDATE")) compile(node).must_be_like "FOR UPDATE" end end diff --git a/activerecord/test/cases/arel/visitors/oracle_test.rb b/activerecord/test/cases/arel/visitors/oracle_test.rb index 0737774fbf..e1dfe40cf9 100644 --- a/activerecord/test/cases/arel/visitors/oracle_test.rb +++ b/activerecord/test/cases/arel/visitors/oracle_test.rb @@ -1,5 +1,6 @@ # frozen_string_literal: true -require_relative '../helper' + +require_relative "../helper" module Arel module Visitors @@ -9,79 +10,79 @@ module Arel @table = Table.new(:users) end - def compile node + def compile(node) @visitor.accept(node, Collectors::SQLString.new).value end - it 'modifies order when there is distinct and first value' do + it "modifies order when there is distinct and first value" do # *sigh* select = "DISTINCT foo.id, FIRST_VALUE(projects.name) OVER (foo) AS alias_0__" stmt = Nodes::SelectStatement.new stmt.cores.first.projections << Nodes::SqlLiteral.new(select) - stmt.orders << Nodes::SqlLiteral.new('foo') + stmt.orders << Nodes::SqlLiteral.new("foo") sql = compile(stmt) sql.must_be_like %{ SELECT #{select} ORDER BY alias_0__ } end - it 'is idempotent with crazy query' do + it "is idempotent with crazy query" do # *sigh* select = "DISTINCT foo.id, FIRST_VALUE(projects.name) OVER (foo) AS alias_0__" stmt = Nodes::SelectStatement.new stmt.cores.first.projections << Nodes::SqlLiteral.new(select) - stmt.orders << Nodes::SqlLiteral.new('foo') + stmt.orders << Nodes::SqlLiteral.new("foo") sql = compile(stmt) sql2 = compile(stmt) sql.must_equal sql2 end - it 'splits orders with commas' do + it "splits orders with commas" do # *sigh* select = "DISTINCT foo.id, FIRST_VALUE(projects.name) OVER (foo) AS alias_0__" stmt = Nodes::SelectStatement.new stmt.cores.first.projections << Nodes::SqlLiteral.new(select) - stmt.orders << Nodes::SqlLiteral.new('foo, bar') + stmt.orders << Nodes::SqlLiteral.new("foo, bar") sql = compile(stmt) sql.must_be_like %{ SELECT #{select} ORDER BY alias_0__, alias_1__ } end - it 'splits orders with commas and function calls' do + it "splits orders with commas and function calls" do # *sigh* select = "DISTINCT foo.id, FIRST_VALUE(projects.name) OVER (foo) AS alias_0__" stmt = Nodes::SelectStatement.new stmt.cores.first.projections << Nodes::SqlLiteral.new(select) - stmt.orders << Nodes::SqlLiteral.new('NVL(LOWER(bar, foo), foo) DESC, UPPER(baz)') + stmt.orders << Nodes::SqlLiteral.new("NVL(LOWER(bar, foo), foo) DESC, UPPER(baz)") sql = compile(stmt) sql.must_be_like %{ SELECT #{select} ORDER BY alias_0__ DESC, alias_1__ } end - describe 'Nodes::SelectStatement' do - describe 'limit' do - it 'adds a rownum clause' do + describe "Nodes::SelectStatement" do + describe "limit" do + it "adds a rownum clause" do stmt = Nodes::SelectStatement.new stmt.limit = Nodes::Limit.new(10) sql = compile stmt sql.must_be_like %{ SELECT WHERE ROWNUM <= 10 } end - it 'is idempotent' do + it "is idempotent" do stmt = Nodes::SelectStatement.new - stmt.orders << Nodes::SqlLiteral.new('foo') + stmt.orders << Nodes::SqlLiteral.new("foo") stmt.limit = Nodes::Limit.new(10) sql = compile stmt sql2 = compile stmt sql.must_equal sql2 end - it 'creates a subquery when there is order_by' do + it "creates a subquery when there is order_by" do stmt = Nodes::SelectStatement.new - stmt.orders << Nodes::SqlLiteral.new('foo') + stmt.orders << Nodes::SqlLiteral.new("foo") stmt.limit = Nodes::Limit.new(10) sql = compile stmt sql.must_be_like %{ @@ -89,9 +90,9 @@ module Arel } end - it 'creates a subquery when there is group by' do + it "creates a subquery when there is group by" do stmt = Nodes::SelectStatement.new - stmt.cores.first.groups << Nodes::SqlLiteral.new('foo') + stmt.cores.first.groups << Nodes::SqlLiteral.new("foo") stmt.limit = Nodes::Limit.new(10) sql = compile stmt sql.must_be_like %{ @@ -99,10 +100,10 @@ module Arel } end - it 'creates a subquery when there is DISTINCT' do + it "creates a subquery when there is DISTINCT" do stmt = Nodes::SelectStatement.new stmt.cores.first.set_quantifier = Arel::Nodes::Distinct.new - stmt.cores.first.projections << Nodes::SqlLiteral.new('id') + stmt.cores.first.projections << Nodes::SqlLiteral.new("id") stmt.limit = Arel::Nodes::Limit.new(10) sql = compile stmt sql.must_be_like %{ @@ -110,7 +111,7 @@ module Arel } end - it 'creates a different subquery when there is an offset' do + it "creates a different subquery when there is an offset" do stmt = Nodes::SelectStatement.new stmt.limit = Nodes::Limit.new(10) stmt.offset = Nodes::Offset.new(10) @@ -125,7 +126,7 @@ module Arel } end - it 'creates a subquery when there is limit and offset with BindParams' do + it "creates a subquery when there is limit and offset with BindParams" do stmt = Nodes::SelectStatement.new stmt.limit = Nodes::Limit.new(Nodes::BindParam.new(1)) stmt.offset = Nodes::Offset.new(Nodes::BindParam.new(1)) @@ -140,7 +141,7 @@ module Arel } end - it 'is idempotent with different subquery' do + it "is idempotent with different subquery" do stmt = Nodes::SelectStatement.new stmt.limit = Nodes::Limit.new(10) stmt.offset = Nodes::Offset.new(10) @@ -150,8 +151,8 @@ module Arel end end - describe 'only offset' do - it 'creates a select from subquery with rownum condition' do + describe "only offset" do + it "creates a select from subquery with rownum condition" do stmt = Nodes::SelectStatement.new stmt.offset = Nodes::Offset.new(10) sql = compile stmt @@ -166,7 +167,7 @@ module Arel end end - it 'modified except to be minus' do + it "modified except to be minus" do left = Nodes::SqlLiteral.new("SELECT * FROM users WHERE age > 10") right = Nodes::SqlLiteral.new("SELECT * FROM users WHERE age > 20") sql = compile Nodes::Except.new(left, right) @@ -175,9 +176,9 @@ module Arel } end - describe 'locking' do - it 'defaults to FOR UPDATE when locking' do - node = Nodes::Lock.new(Arel.sql('FOR UPDATE')) + describe "locking" do + it "defaults to FOR UPDATE when locking" do + node = Nodes::Lock.new(Arel.sql("FOR UPDATE")) compile(node).must_be_like "FOR UPDATE" end end diff --git a/activerecord/test/cases/arel/visitors/postgres_test.rb b/activerecord/test/cases/arel/visitors/postgres_test.rb index 6aa786b14f..ba37afecfb 100644 --- a/activerecord/test/cases/arel/visitors/postgres_test.rb +++ b/activerecord/test/cases/arel/visitors/postgres_test.rb @@ -1,5 +1,6 @@ # frozen_string_literal: true -require_relative '../helper' + +require_relative "../helper" module Arel module Visitors @@ -10,19 +11,19 @@ module Arel @attr = @table[:id] end - def compile node + def compile(node) @visitor.accept(node, Collectors::SQLString.new).value end - describe 'locking' do - it 'defaults to FOR UPDATE' do - compile(Nodes::Lock.new(Arel.sql('FOR UPDATE'))).must_be_like %{ + describe "locking" do + it "defaults to FOR UPDATE" do + compile(Nodes::Lock.new(Arel.sql("FOR UPDATE"))).must_be_like %{ FOR UPDATE } end - it 'allows a custom string to be used as a lock' do - node = Nodes::Lock.new(Arel.sql('FOR SHARE')) + it "allows a custom string to be used as a lock" do + node = Nodes::Lock.new(Arel.sql("FOR SHARE")) compile(node).must_be_like %{ FOR SHARE } @@ -32,42 +33,42 @@ module Arel it "should escape LIMIT" do sc = Arel::Nodes::SelectStatement.new sc.limit = Nodes::Limit.new(Nodes.build_quoted("omg")) - sc.cores.first.projections << Arel.sql('DISTINCT ON') + sc.cores.first.projections << Arel.sql("DISTINCT ON") sc.orders << Arel.sql("xyz") - sql = compile(sc) + sql = compile(sc) assert_match(/LIMIT 'omg'/, sql) - assert_equal 1, sql.scan(/LIMIT/).length, 'should have one limit' + assert_equal 1, sql.scan(/LIMIT/).length, "should have one limit" end - it 'should support DISTINCT ON' do + it "should support DISTINCT ON" do core = Arel::Nodes::SelectCore.new - core.set_quantifier = Arel::Nodes::DistinctOn.new(Arel.sql('aaron')) - assert_match 'DISTINCT ON ( aaron )', compile(core) + core.set_quantifier = Arel::Nodes::DistinctOn.new(Arel.sql("aaron")) + assert_match "DISTINCT ON ( aaron )", compile(core) end - it 'should support DISTINCT' do + it "should support DISTINCT" do core = Arel::Nodes::SelectCore.new core.set_quantifier = Arel::Nodes::Distinct.new - assert_equal 'SELECT DISTINCT', compile(core) + assert_equal "SELECT DISTINCT", compile(core) end - it 'encloses LATERAL queries in parens' do - subquery = @table.project(:id).where(@table[:name].matches('foo%')) + it "encloses LATERAL queries in parens" do + subquery = @table.project(:id).where(@table[:name].matches("foo%")) compile(subquery.lateral).must_be_like %{ LATERAL (SELECT id FROM "users" WHERE "users"."name" ILIKE 'foo%') } end - it 'produces LATERAL queries with alias' do - subquery = @table.project(:id).where(@table[:name].matches('foo%')) - compile(subquery.lateral('bar')).must_be_like %{ + it "produces LATERAL queries with alias" do + subquery = @table.project(:id).where(@table[:name].matches("foo%")) + compile(subquery.lateral("bar")).must_be_like %{ LATERAL (SELECT id FROM "users" WHERE "users"."name" ILIKE 'foo%') bar } end describe "Nodes::Matches" do it "should know how to visit" do - node = @table[:name].matches('foo%') + node = @table[:name].matches("foo%") node.must_be_kind_of Nodes::Matches node.case_sensitive.must_equal(false) compile(node).must_be_like %{ @@ -76,7 +77,7 @@ module Arel end it "should know how to visit case sensitive" do - node = @table[:name].matches('foo%', nil, true) + node = @table[:name].matches("foo%", nil, true) node.case_sensitive.must_equal(true) compile(node).must_be_like %{ "users"."name" LIKE 'foo%' @@ -84,14 +85,14 @@ module Arel end it "can handle ESCAPE" do - node = @table[:name].matches('foo!%', '!') + node = @table[:name].matches("foo!%", "!") compile(node).must_be_like %{ "users"."name" ILIKE 'foo!%' ESCAPE '!' } end - it 'can handle subqueries' do - subquery = @table.project(:id).where(@table[:name].matches('foo%')) + it "can handle subqueries" do + subquery = @table.project(:id).where(@table[:name].matches("foo%")) node = @attr.in subquery compile(node).must_be_like %{ "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" ILIKE 'foo%') @@ -101,7 +102,7 @@ module Arel describe "Nodes::DoesNotMatch" do it "should know how to visit" do - node = @table[:name].does_not_match('foo%') + node = @table[:name].does_not_match("foo%") node.must_be_kind_of Nodes::DoesNotMatch node.case_sensitive.must_equal(false) compile(node).must_be_like %{ @@ -110,7 +111,7 @@ module Arel end it "should know how to visit case sensitive" do - node = @table[:name].does_not_match('foo%', nil, true) + node = @table[:name].does_not_match("foo%", nil, true) node.case_sensitive.must_equal(true) compile(node).must_be_like %{ "users"."name" NOT LIKE 'foo%' @@ -118,14 +119,14 @@ module Arel end it "can handle ESCAPE" do - node = @table[:name].does_not_match('foo!%', '!') + node = @table[:name].does_not_match("foo!%", "!") compile(node).must_be_like %{ "users"."name" NOT ILIKE 'foo!%' ESCAPE '!' } end - it 'can handle subqueries' do - subquery = @table.project(:id).where(@table[:name].does_not_match('foo%')) + it "can handle subqueries" do + subquery = @table.project(:id).where(@table[:name].does_not_match("foo%")) node = @attr.in subquery compile(node).must_be_like %{ "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" NOT ILIKE 'foo%') @@ -135,7 +136,7 @@ module Arel describe "Nodes::Regexp" do it "should know how to visit" do - node = @table[:name].matches_regexp('foo.*') + node = @table[:name].matches_regexp("foo.*") node.must_be_kind_of Nodes::Regexp node.case_sensitive.must_equal(true) compile(node).must_be_like %{ @@ -144,7 +145,7 @@ module Arel end it "can handle case insensitive" do - node = @table[:name].matches_regexp('foo.*', false) + node = @table[:name].matches_regexp("foo.*", false) node.must_be_kind_of Nodes::Regexp node.case_sensitive.must_equal(false) compile(node).must_be_like %{ @@ -152,8 +153,8 @@ module Arel } end - it 'can handle subqueries' do - subquery = @table.project(:id).where(@table[:name].matches_regexp('foo.*')) + it "can handle subqueries" do + subquery = @table.project(:id).where(@table[:name].matches_regexp("foo.*")) node = @attr.in subquery compile(node).must_be_like %{ "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" ~ 'foo.*') @@ -163,7 +164,7 @@ module Arel describe "Nodes::NotRegexp" do it "should know how to visit" do - node = @table[:name].does_not_match_regexp('foo.*') + node = @table[:name].does_not_match_regexp("foo.*") node.must_be_kind_of Nodes::NotRegexp node.case_sensitive.must_equal(true) compile(node).must_be_like %{ @@ -172,15 +173,15 @@ module Arel end it "can handle case insensitive" do - node = @table[:name].does_not_match_regexp('foo.*', false) + node = @table[:name].does_not_match_regexp("foo.*", false) node.case_sensitive.must_equal(false) compile(node).must_be_like %{ "users"."name" !~* 'foo.*' } end - it 'can handle subqueries' do - subquery = @table.project(:id).where(@table[:name].does_not_match_regexp('foo.*')) + it "can handle subqueries" do + subquery = @table.project(:id).where(@table[:name].does_not_match_regexp("foo.*")) node = @attr.in subquery compile(node).must_be_like %{ "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" !~ 'foo.*') diff --git a/activerecord/test/cases/arel/visitors/sqlite_test.rb b/activerecord/test/cases/arel/visitors/sqlite_test.rb index 23f66ee096..6650b6ff3a 100644 --- a/activerecord/test/cases/arel/visitors/sqlite_test.rb +++ b/activerecord/test/cases/arel/visitors/sqlite_test.rb @@ -1,5 +1,6 @@ # frozen_string_literal: true -require_relative '../helper' + +require_relative "../helper" module Arel module Visitors @@ -8,23 +9,23 @@ module Arel @visitor = SQLite.new Table.engine.connection_pool end - it 'defaults limit to -1' do + it "defaults limit to -1" do stmt = Nodes::SelectStatement.new stmt.offset = Nodes::Offset.new(1) sql = @visitor.accept(stmt, Collectors::SQLString.new).value sql.must_be_like "SELECT LIMIT -1 OFFSET 1" end - it 'does not support locking' do - node = Nodes::Lock.new(Arel.sql('FOR UPDATE')) - assert_equal '', @visitor.accept(node, Collectors::SQLString.new).value + it "does not support locking" do + node = Nodes::Lock.new(Arel.sql("FOR UPDATE")) + assert_equal "", @visitor.accept(node, Collectors::SQLString.new).value end - it 'does not support boolean' do + it "does not support boolean" do node = Nodes::True.new() - assert_equal '1', @visitor.accept(node, Collectors::SQLString.new).value + assert_equal "1", @visitor.accept(node, Collectors::SQLString.new).value node = Nodes::False.new() - assert_equal '0', @visitor.accept(node, Collectors::SQLString.new).value + assert_equal "0", @visitor.accept(node, Collectors::SQLString.new).value end end end diff --git a/activerecord/test/cases/arel/visitors/to_sql_test.rb b/activerecord/test/cases/arel/visitors/to_sql_test.rb index 1503bcd578..ce836eded7 100644 --- a/activerecord/test/cases/arel/visitors/to_sql_test.rb +++ b/activerecord/test/cases/arel/visitors/to_sql_test.rb @@ -1,10 +1,11 @@ # frozen_string_literal: true -require_relative '../helper' -require 'bigdecimal' + +require_relative "../helper" +require "bigdecimal" module Arel module Visitors - describe 'the to_sql visitor' do + describe "the to_sql visitor" do before do @conn = FakeRecord::Base.new @visitor = ToSql.new @conn.connection @@ -12,24 +13,24 @@ module Arel @attr = @table[:id] end - def compile node + def compile(node) @visitor.accept(node, Collectors::SQLString.new).value end - it 'works with BindParams' do + it "works with BindParams" do node = Nodes::BindParam.new(1) sql = compile node - sql.must_be_like '?' + sql.must_be_like "?" end - it 'does not quote BindParams used as part of a Values' do + it "does not quote BindParams used as part of a Values" do bp = Nodes::BindParam.new(1) values = Nodes::Values.new([bp]) sql = compile values - sql.must_be_like 'VALUES (?)' + sql.must_be_like "VALUES (?)" end - it 'can define a dispatch method' do + it "can define a dispatch method" do visited = false viz = Class.new(Arel::Visitors::Visitor) { define_method(:hello) do |node, c| @@ -37,117 +38,117 @@ module Arel end def dispatch - { Arel::Table => 'hello' } + { Arel::Table => "hello" } end }.new viz.accept(@table, Collectors::SQLString.new) - assert visited, 'hello method was called' + assert visited, "hello method was called" end - it 'should not quote sql literals' do + it "should not quote sql literals" do node = @table[Arel.star] sql = compile node sql.must_be_like '"users".*' end - it 'should visit named functions' do - function = Nodes::NamedFunction.new('omg', [Arel.star]) - assert_equal 'omg(*)', compile(function) + it "should visit named functions" do + function = Nodes::NamedFunction.new("omg", [Arel.star]) + assert_equal "omg(*)", compile(function) end - it 'should chain predications on named functions' do - function = Nodes::NamedFunction.new('omg', [Arel.star]) + it "should chain predications on named functions" do + function = Nodes::NamedFunction.new("omg", [Arel.star]) sql = compile(function.eq(2)) sql.must_be_like %{ omg(*) = 2 } end - it 'should handle nil with named functions' do - function = Nodes::NamedFunction.new('omg', [Arel.star]) + it "should handle nil with named functions" do + function = Nodes::NamedFunction.new("omg", [Arel.star]) sql = compile(function.eq(nil)) sql.must_be_like %{ omg(*) IS NULL } end - it 'should visit built-in functions' do + it "should visit built-in functions" do function = Nodes::Count.new([Arel.star]) - assert_equal 'COUNT(*)', compile(function) + assert_equal "COUNT(*)", compile(function) function = Nodes::Sum.new([Arel.star]) - assert_equal 'SUM(*)', compile(function) + assert_equal "SUM(*)", compile(function) function = Nodes::Max.new([Arel.star]) - assert_equal 'MAX(*)', compile(function) + assert_equal "MAX(*)", compile(function) function = Nodes::Min.new([Arel.star]) - assert_equal 'MIN(*)', compile(function) + assert_equal "MIN(*)", compile(function) function = Nodes::Avg.new([Arel.star]) - assert_equal 'AVG(*)', compile(function) + assert_equal "AVG(*)", compile(function) end - it 'should visit built-in functions operating on distinct values' do + it "should visit built-in functions operating on distinct values" do function = Nodes::Count.new([Arel.star]) function.distinct = true - assert_equal 'COUNT(DISTINCT *)', compile(function) + assert_equal "COUNT(DISTINCT *)", compile(function) function = Nodes::Sum.new([Arel.star]) function.distinct = true - assert_equal 'SUM(DISTINCT *)', compile(function) + assert_equal "SUM(DISTINCT *)", compile(function) function = Nodes::Max.new([Arel.star]) function.distinct = true - assert_equal 'MAX(DISTINCT *)', compile(function) + assert_equal "MAX(DISTINCT *)", compile(function) function = Nodes::Min.new([Arel.star]) function.distinct = true - assert_equal 'MIN(DISTINCT *)', compile(function) + assert_equal "MIN(DISTINCT *)", compile(function) function = Nodes::Avg.new([Arel.star]) function.distinct = true - assert_equal 'AVG(DISTINCT *)', compile(function) + assert_equal "AVG(DISTINCT *)", compile(function) end - it 'works with lists' do - function = Nodes::NamedFunction.new('omg', [Arel.star, Arel.star]) - assert_equal 'omg(*, *)', compile(function) + it "works with lists" do + function = Nodes::NamedFunction.new("omg", [Arel.star, Arel.star]) + assert_equal "omg(*, *)", compile(function) end - describe 'Nodes::Equality' do + describe "Nodes::Equality" do it "should escape strings" do - test = Table.new(:users)[:name].eq 'Aaron Patterson' + test = Table.new(:users)[:name].eq "Aaron Patterson" compile(test).must_be_like %{ "users"."name" = 'Aaron Patterson' } end - it 'should handle false' do + it "should handle false" do table = Table.new(:users) val = Nodes.build_quoted(false, table[:active]) sql = compile Nodes::Equality.new(val, val) sql.must_be_like %{ 'f' = 'f' } end - it 'should handle nil' do + it "should handle nil" do sql = compile Nodes::Equality.new(@table[:name], nil) sql.must_be_like %{ "users"."name" IS NULL } end end - describe 'Nodes::Grouping' do - it 'wraps nested groupings in brackets only once' do - sql = compile Nodes::Grouping.new(Nodes::Grouping.new(Nodes.build_quoted('foo'))) + describe "Nodes::Grouping" do + it "wraps nested groupings in brackets only once" do + sql = compile Nodes::Grouping.new(Nodes::Grouping.new(Nodes.build_quoted("foo"))) sql.must_equal "('foo')" end end - describe 'Nodes::NotEqual' do - it 'should handle false' do + describe "Nodes::NotEqual" do + it "should handle false" do val = Nodes.build_quoted(false, @table[:active]) sql = compile Nodes::NotEqual.new(@table[:active], val) sql.must_be_like %{ "users"."active" != 'f' } end - it 'should handle nil' do + it "should handle nil" do val = Nodes.build_quoted(nil, @table[:active]) sql = compile Nodes::NotEqual.new(@table[:name], val) sql.must_be_like %{ "users"."name" IS NOT NULL } @@ -225,7 +226,7 @@ module Arel end it "should visit_Hash" do - compile(Nodes.build_quoted({:a => 1})) + compile(Nodes.build_quoted(a: 1)) end it "should visit_Set" do @@ -233,7 +234,7 @@ module Arel end it "should visit_BigDecimal" do - compile Nodes.build_quoted(BigDecimal('2.14')) + compile Nodes.build_quoted(BigDecimal("2.14")) end it "should visit_Date" do @@ -296,21 +297,21 @@ module Arel describe "Nodes::Matches" do it "should know how to visit" do - node = @table[:name].matches('foo%') + node = @table[:name].matches("foo%") compile(node).must_be_like %{ "users"."name" LIKE 'foo%' } end it "can handle ESCAPE" do - node = @table[:name].matches('foo!%', '!') + node = @table[:name].matches("foo!%", "!") compile(node).must_be_like %{ "users"."name" LIKE 'foo!%' ESCAPE '!' } end - it 'can handle subqueries' do - subquery = @table.project(:id).where(@table[:name].matches('foo%')) + it "can handle subqueries" do + subquery = @table.project(:id).where(@table[:name].matches("foo%")) node = @attr.in subquery compile(node).must_be_like %{ "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" LIKE 'foo%') @@ -320,21 +321,21 @@ module Arel describe "Nodes::DoesNotMatch" do it "should know how to visit" do - node = @table[:name].does_not_match('foo%') + node = @table[:name].does_not_match("foo%") compile(node).must_be_like %{ "users"."name" NOT LIKE 'foo%' } end it "can handle ESCAPE" do - node = @table[:name].does_not_match('foo!%', '!') + node = @table[:name].does_not_match("foo!%", "!") compile(node).must_be_like %{ "users"."name" NOT LIKE 'foo!%' ESCAPE '!' } end - it 'can handle subqueries' do - subquery = @table.project(:id).where(@table[:name].does_not_match('foo%')) + it "can handle subqueries" do + subquery = @table.project(:id).where(@table[:name].does_not_match("foo%")) node = @attr.in subquery compile(node).must_be_like %{ "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" NOT LIKE 'foo%') @@ -361,24 +362,24 @@ module Arel it "should return 1=0 when empty right which is always false" do node = @attr.in [] - compile(node).must_equal '1=0' + compile(node).must_equal "1=0" end - it 'can handle two dot ranges' do + it "can handle two dot ranges" do node = @attr.between 1..3 compile(node).must_be_like %{ "users"."id" BETWEEN 1 AND 3 } end - it 'can handle three dot ranges' do + it "can handle three dot ranges" do node = @attr.between 1...3 compile(node).must_be_like %{ "users"."id" >= 1 AND "users"."id" < 3 } end - it 'can handle ranges bounded by infinity' do + it "can handle ranges bounded by infinity" do node = @attr.between 1..Float::INFINITY compile(node).must_be_like %{ "users"."id" >= 1 @@ -395,9 +396,9 @@ module Arel compile(node).must_be_like %{1=1} end - it 'can handle subqueries' do + it "can handle subqueries" do table = Table.new(:users) - subquery = table.project(:id).where(table[:name].eq('Aaron')) + subquery = table.project(:id).where(table[:name].eq("Aaron")) node = @attr.in subquery compile(node).must_be_like %{ "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" = 'Aaron') @@ -459,7 +460,7 @@ module Arel it "should handle arbitrary operators" do node = Arel::Nodes::InfixOperation.new( - '&&', + "&&", Arel::Attributes::String.new(Table.new(:products), :name), Arel::Attributes::String.new(Table.new(:products), :name) ) @@ -474,7 +475,7 @@ module Arel end it "should handle arbitrary operators" do - node = Arel::Nodes::UnaryOperation.new('!', Arel::Attributes::String.new(Table.new(:products), :active)) + node = Arel::Nodes::UnaryOperation.new("!", Arel::Attributes::String.new(Table.new(:products), :active)) compile(node).must_equal %( ! "products"."active") end end @@ -489,24 +490,24 @@ module Arel it "should return 1=1 when empty right which is always true" do node = @attr.not_in [] - compile(node).must_equal '1=1' + compile(node).must_equal "1=1" end - it 'can handle two dot ranges' do + it "can handle two dot ranges" do node = @attr.not_between 1..3 compile(node).must_equal( %{("users"."id" < 1 OR "users"."id" > 3)} ) end - it 'can handle three dot ranges' do + it "can handle three dot ranges" do node = @attr.not_between 1...3 compile(node).must_equal( %{("users"."id" < 1 OR "users"."id" >= 3)} ) end - it 'can handle ranges bounded by infinity' do + it "can handle ranges bounded by infinity" do node = @attr.not_between 1..Float::INFINITY compile(node).must_be_like %{ "users"."id" < 1 @@ -523,9 +524,9 @@ module Arel compile(node).must_be_like %{1=0} end - it 'can handle subqueries' do + it "can handle subqueries" do table = Table.new(:users) - subquery = table.project(:id).where(table[:name].eq('Aaron')) + subquery = table.project(:id).where(table[:name].eq("Aaron")) node = @attr.not_in subquery compile(node).must_be_like %{ "users"."id" NOT IN (SELECT id FROM "users" WHERE "users"."name" = 'Aaron') @@ -533,7 +534,7 @@ module Arel end end - describe 'Constants' do + describe "Constants" do it "should handle true" do test = Table.new(:users).create_true compile(test).must_be_like %{ @@ -549,19 +550,19 @@ module Arel end end - describe 'TableAlias' do + describe "TableAlias" do it "should use the underlying table for checking columns" do - test = Table.new(:users).alias('zomgusers')[:id].eq '3' + test = Table.new(:users).alias("zomgusers")[:id].eq "3" compile(test).must_be_like %{ "zomgusers"."id" = '3' } end end - describe 'distinct on' do - it 'raises not implemented error' do + describe "distinct on" do + it "raises not implemented error" do core = Arel::Nodes::SelectCore.new - core.set_quantifier = Arel::Nodes::DistinctOn.new(Arel.sql('aaron')) + core.set_quantifier = Arel::Nodes::DistinctOn.new(Arel.sql("aaron")) assert_raises(NotImplementedError) do compile(core) @@ -569,9 +570,9 @@ module Arel end end - describe 'Nodes::Regexp' do - it 'raises not implemented error' do - node = Arel::Nodes::Regexp.new(@table[:name], Nodes.build_quoted('foo%')) + describe "Nodes::Regexp" do + it "raises not implemented error" do + node = Arel::Nodes::Regexp.new(@table[:name], Nodes.build_quoted("foo%")) assert_raises(NotImplementedError) do compile(node) @@ -579,9 +580,9 @@ module Arel end end - describe 'Nodes::NotRegexp' do - it 'raises not implemented error' do - node = Arel::Nodes::NotRegexp.new(@table[:name], Nodes.build_quoted('foo%')) + describe "Nodes::NotRegexp" do + it "raises not implemented error" do + node = Arel::Nodes::NotRegexp.new(@table[:name], Nodes.build_quoted("foo%")) assert_raises(NotImplementedError) do compile(node) @@ -589,10 +590,10 @@ module Arel end end - describe 'Nodes::Case' do - it 'supports simple case expressions' do + describe "Nodes::Case" do + it "supports simple case expressions" do node = Arel::Nodes::Case.new(@table[:name]) - .when('foo').then(1) + .when("foo").then(1) .else(0) compile(node).must_be_like %{ @@ -600,7 +601,7 @@ module Arel } end - it 'supports extended case expressions' do + it "supports extended case expressions" do node = Arel::Nodes::Case.new .when(@table[:name].in(%w(foo bar))).then(1) .else(0) @@ -610,19 +611,19 @@ module Arel } end - it 'works without default branch' do + it "works without default branch" do node = Arel::Nodes::Case.new(@table[:name]) - .when('foo').then(1) + .when("foo").then(1) compile(node).must_be_like %{ CASE "users"."name" WHEN 'foo' THEN 1 END } end - it 'allows chaining multiple conditions' do + it "allows chaining multiple conditions" do node = Arel::Nodes::Case.new(@table[:name]) - .when('foo').then(1) - .when('bar').then(2) + .when("foo").then(1) + .when("bar").then(2) .else(0) compile(node).must_be_like %{ @@ -630,7 +631,7 @@ module Arel } end - it 'supports #when with two arguments and no #then' do + it "supports #when with two arguments and no #then" do node = Arel::Nodes::Case.new @table[:name] { foo: 1, bar: 0 }.reduce(node) { |_node, pair| _node.when(*pair) } @@ -640,8 +641,8 @@ module Arel } end - it 'can be chained as a predicate' do - node = @table[:name].when('foo').then('bar').else('baz') + it "can be chained as a predicate" do + node = @table[:name].when("foo").then("bar").else("baz") compile(node).must_be_like %{ CASE "users"."name" WHEN 'foo' THEN 'bar' ELSE 'baz' END -- cgit v1.2.3