arel 6.0.0.beta2 → 6.0.0

data/test/collectors/test_bind_collector.rb

@@ -1,70 +0,0 @@
-require 'helper'
-require 'arel/collectors/bind'
-
-module Arel
-  module Collectors
-    class TestBindCollector < Arel::Test
-      def setup
-        @conn = FakeRecord::Base.new
-        @visitor = Visitors::ToSql.new @conn.connection
-        super
-      end
-
-      def collect node
-        @visitor.accept(node, Collectors::Bind.new)
-      end
-
-      def compile node
-        collect(node).value
-      end
-
-      def ast_with_binds bv
-        table = Table.new(:users)
-        manager = Arel::SelectManager.new Table.engine, table
-        manager.where(table[:age].eq(bv))
-        manager.where(table[:name].eq(bv))
-        manager.ast
-      end
-
-      def test_leaves_binds
-        node = Nodes::BindParam.new 'omg'
-        list = compile node
-        assert_equal node, list.first
-        assert_equal node.class, list.first.class
-      end
-
-      def test_adds_strings
-        bv = Nodes::BindParam.new('?')
-        list = compile ast_with_binds bv
-        assert_operator list.length, :>, 0
-        assert_equal bv, list.grep(Nodes::BindParam).first
-        assert_equal bv.class, list.grep(Nodes::BindParam).first.class
-      end
-
-      def test_substitute_binds
-        bv = Nodes::BindParam.new('?')
-        collector = collect ast_with_binds bv
-
-        values = collector.value
-
-        offsets = values.map.with_index { |v,i|
-          [v,i]
-        }.find_all { |(v,_)| Nodes::BindParam === v }.map(&:last)
-
-        list = collector.substitute_binds ["hello", "world"]
-        assert_equal "hello", list[offsets[0]]
-        assert_equal "world", list[offsets[1]]
-
-        assert_equal 'SELECT FROM "users" WHERE "users"."age" = hello AND "users"."name" = world', list.join
-      end
-
-      def test_compile
-        bv = Nodes::BindParam.new('?')
-        collector = collect ast_with_binds bv
-
-        sql = collector.compile ["hello", "world"]
-        assert_equal 'SELECT FROM "users" WHERE "users"."age" = hello AND "users"."name" = world', sql
-      end
-    end
-  end
-end

data/test/collectors/test_sql_string.rb

@@ -1,38 +0,0 @@
-require 'helper'
-require 'arel/collectors/bind'
-
-module Arel
-  module Collectors
-    class TestSqlString < Arel::Test
-      def setup
-        @conn = FakeRecord::Base.new
-        @visitor = Visitors::ToSql.new @conn.connection
-        super
-      end
-
-      def collect node
-        @visitor.accept(node, Collectors::SQLString.new)
-      end
-
-      def compile node
-        collect(node).value
-      end
-
-      def ast_with_binds bv
-        table = Table.new(:users)
-        manager = Arel::SelectManager.new Table.engine, table
-        manager.where(table[:age].eq(bv))
-        manager.where(table[:name].eq(bv))
-        manager.ast
-      end
-
-      def test_compile
-        bv = Nodes::BindParam.new('?')
-        collector = collect ast_with_binds bv
-
-        sql = collector.compile ["hello", "world"]
-        assert_equal 'SELECT FROM "users" WHERE "users"."age" = ? AND "users"."name" = ?', sql
-      end
-    end
-  end
-end

data/test/helper.rb

@@ -1,22 +0,0 @@
-require 'rubygems'
-require 'minitest/autorun'
-require 'fileutils'
-require 'arel'
-
-require 'support/fake_record'
-Arel::Table.engine = FakeRecord::Base.new
-
-class Object
-  def must_be_like other
-    gsub(/\s+/, ' ').strip.must_equal other.gsub(/\s+/, ' ').strip
-  end
-end
-
-module Arel
-  class Test < MiniTest::Test
-    def assert_like expected, actual
-      assert_equal expected.gsub(/\s+/, ' ').strip,
-                   actual.gsub(/\s+/, ' ').strip
-    end
-  end
-end

data/test/nodes/test_and.rb

@@ -1,20 +0,0 @@
-require 'helper'
-
-module Arel
-  module Nodes
-    describe 'And' do
-      describe 'equality' do
-        it 'is equal with equal ivars' do
-          array = [And.new(['foo', 'bar']), And.new(['foo', 'bar'])]
-          assert_equal 1, array.uniq.size
-        end
-
-        it 'is not equal with different ivars' do
-          array = [And.new(['foo', 'bar']), And.new(['foo', 'baz'])]
-          assert_equal 2, array.uniq.size
-        end
-      end
-    end
-  end
-end
-

data/test/nodes/test_as.rb

@@ -1,34 +0,0 @@
-require 'helper'
-
-module Arel
-  module Nodes
-    describe 'As' do
-      describe '#as' do
-        it 'makes an AS node' do
-          attr = Table.new(:users)[:id]
-          as = attr.as(Arel.sql('foo'))
-          assert_equal attr, as.left
-          assert_equal 'foo', as.right
-        end
-
-        it 'converts right to SqlLiteral if a string' do
-          attr = Table.new(:users)[:id]
-          as = attr.as('foo')
-          assert_kind_of Arel::Nodes::SqlLiteral, as.right
-        end
-      end
-
-      describe 'equality' do
-        it 'is equal with equal ivars' do
-          array = [As.new('foo', 'bar'), As.new('foo', 'bar')]
-          assert_equal 1, array.uniq.size
-        end
-
-        it 'is not equal with different ivars' do
-          array = [As.new('foo', 'bar'), As.new('foo', 'baz')]
-          assert_equal 2, array.uniq.size
-        end
-      end
-    end
-  end
-end

data/test/nodes/test_ascending.rb

@@ -1,44 +0,0 @@
-require 'helper'
-
-module Arel
-  module Nodes
-    class TestAscending < Minitest::Test
-      def test_construct
-        ascending = Ascending.new 'zomg'
-        assert_equal 'zomg', ascending.expr
-      end
-
-      def test_reverse
-        ascending = Ascending.new 'zomg'
-        descending = ascending.reverse
-        assert_kind_of Descending, descending
-        assert_equal ascending.expr, descending.expr
-      end
-
-      def test_direction
-        ascending = Ascending.new 'zomg'
-        assert_equal :asc, ascending.direction
-      end
-
-      def test_ascending?
-        ascending = Ascending.new 'zomg'
-        assert ascending.ascending?
-      end
-
-      def test_descending?
-        ascending = Ascending.new 'zomg'
-        assert !ascending.descending?
-      end
-
-      def test_equality_with_same_ivars
-        array = [Ascending.new('zomg'), Ascending.new('zomg')]
-        assert_equal 1, array.uniq.size
-      end
-
-      def test_inequality_with_different_ivars
-        array = [Ascending.new('zomg'), Ascending.new('zomg!')]
-        assert_equal 2, array.uniq.size
-      end
-    end
-  end
-end

data/test/nodes/test_bin.rb

@@ -1,33 +0,0 @@
-require 'helper'
-
-module Arel
-  module Nodes
-    class TestBin < Minitest::Test
-      def test_new
-        assert Arel::Nodes::Bin.new('zomg')
-      end
-
-      def test_default_to_sql
-        viz  = Arel::Visitors::ToSql.new Table.engine.connection_pool
-        node = Arel::Nodes::Bin.new(Arel.sql('zomg'))
-        assert_equal 'zomg', viz.accept(node, Collectors::SQLString.new).value
-      end
-
-      def test_mysql_to_sql
-        viz  = Arel::Visitors::MySQL.new Table.engine.connection_pool
-        node = Arel::Nodes::Bin.new(Arel.sql('zomg'))
-        assert_equal 'BINARY zomg', viz.accept(node, Collectors::SQLString.new).value
-      end
-
-      def test_equality_with_same_ivars
-        array = [Bin.new('zomg'), Bin.new('zomg')]
-        assert_equal 1, array.uniq.size
-      end
-
-      def test_inequality_with_different_ivars
-        array = [Bin.new('zomg'), Bin.new('zomg!')]
-        assert_equal 2, array.uniq.size
-      end
-    end
-  end
-end

data/test/nodes/test_binary.rb

@@ -1,26 +0,0 @@
-require 'helper'
-require 'set'
-
-module Arel
-  module Nodes
-    describe 'Binary' do
-      describe '#hash' do
-        it 'generates a hash based on its value' do
-          eq = Equality.new('foo', 'bar')
-          eq2 = Equality.new('foo', 'bar')
-          eq3 = Equality.new('bar', 'baz')
-
-          assert_equal eq.hash, eq2.hash
-          refute_equal eq.hash, eq3.hash
-        end
-
-        it 'generates a hash specific to its class' do
-          eq = Equality.new('foo', 'bar')
-          neq = NotEqual.new('foo', 'bar')
-
-          refute_equal eq.hash, neq.hash
-        end
-      end
-    end
-  end
-end

data/test/nodes/test_count.rb

@@ -1,33 +0,0 @@
-require 'helper'
-
-describe Arel::Nodes::Count do
-  describe "as" do
-    it 'should alias the count' do
-      table = Arel::Table.new :users
-      table[:id].count.as('foo').to_sql.must_be_like %{
-        COUNT("users"."id") AS foo
-      }
-    end
-  end
-
-  describe "eq" do
-    it "should compare the count" do
-      table = Arel::Table.new :users
-      table[:id].count.eq(2).to_sql.must_be_like %{
-        COUNT("users"."id") = 2
-      }
-    end
-  end
-
-  describe 'equality' do
-    it 'is equal with equal ivars' do
-      array = [Arel::Nodes::Count.new('foo'), Arel::Nodes::Count.new('foo')]
-      assert_equal 1, array.uniq.size
-    end
-
-    it 'is not equal with different ivars' do
-      array = [Arel::Nodes::Count.new('foo'), Arel::Nodes::Count.new('foo!')]
-      assert_equal 2, array.uniq.size
-    end
-  end
-end

data/test/nodes/test_delete_statement.rb

@@ -1,34 +0,0 @@
-require 'helper'
-
-describe Arel::Nodes::DeleteStatement do
-  describe "#clone" do
-    it "clones wheres" do
-      statement = Arel::Nodes::DeleteStatement.new
-      statement.wheres = %w[a b c]
-
-      dolly = statement.clone
-      dolly.wheres.must_equal statement.wheres
-      dolly.wheres.wont_be_same_as statement.wheres
-    end
-  end
-
-  describe 'equality' do
-    it 'is equal with equal ivars' do
-      statement1 = Arel::Nodes::DeleteStatement.new
-      statement1.wheres = %w[a b c]
-      statement2 = Arel::Nodes::DeleteStatement.new
-      statement2.wheres = %w[a b c]
-      array = [statement1, statement2]
-      assert_equal 1, array.uniq.size
-    end
-
-    it 'is not equal with different ivars' do
-      statement1 = Arel::Nodes::DeleteStatement.new
-      statement1.wheres = %w[a b c]
-      statement2 = Arel::Nodes::DeleteStatement.new
-      statement2.wheres = %w[1 2 3]
-      array = [statement1, statement2]
-      assert_equal 2, array.uniq.size
-    end
-  end
-end

data/test/nodes/test_descending.rb

@@ -1,44 +0,0 @@
-require 'helper'
-
-module Arel
-  module Nodes
-    class TestDescending < Minitest::Test
-      def test_construct
-        descending = Descending.new 'zomg'
-        assert_equal 'zomg', descending.expr
-      end
-
-      def test_reverse
-        descending = Descending.new 'zomg'
-        ascending = descending.reverse
-        assert_kind_of Ascending, ascending
-        assert_equal descending.expr, ascending.expr
-      end
-
-      def test_direction
-        descending = Descending.new 'zomg'
-        assert_equal :desc, descending.direction
-      end
-
-      def test_ascending?
-        descending = Descending.new 'zomg'
-        assert !descending.ascending?
-      end
-
-      def test_descending?
-        descending = Descending.new 'zomg'
-        assert descending.descending?
-      end
-
-      def test_equality_with_same_ivars
-        array = [Descending.new('zomg'), Descending.new('zomg')]
-        assert_equal 1, array.uniq.size
-      end
-
-      def test_inequality_with_different_ivars
-        array = [Descending.new('zomg'), Descending.new('zomg!')]
-        assert_equal 2, array.uniq.size
-      end
-    end
-  end
-end

data/test/nodes/test_distinct.rb

@@ -1,20 +0,0 @@
-require 'helper'
-
-module Arel
-  module Nodes
-    describe 'Distinct' do
-      describe 'equality' do
-        it 'is equal to other distinct nodes' do
-          array = [Distinct.new, Distinct.new]
-          assert_equal 1, array.uniq.size
-        end
-
-        it 'is not equal with other nodes' do
-          array = [Distinct.new, Node.new]
-          assert_equal 2, array.uniq.size
-        end
-      end
-    end
-  end
-end
-

data/test/nodes/test_equality.rb

@@ -1,84 +0,0 @@
-require 'helper'
-
-module Arel
-  module Nodes
-    describe 'equality' do
-      # FIXME: backwards compat
-      describe 'backwards compat' do
-        describe 'operator' do
-          it 'returns :==' do
-            attr = Table.new(:users)[:id]
-            left  = attr.eq(10)
-            left.operator.must_equal :==
-          end
-        end
-
-        describe 'operand1' do
-          it "should equal left" do
-            attr = Table.new(:users)[:id]
-            left  = attr.eq(10)
-            left.left.must_equal left.operand1
-          end
-        end
-
-        describe 'operand2' do
-          it "should equal right" do
-            attr = Table.new(:users)[:id]
-            left  = attr.eq(10)
-            left.right.must_equal left.operand2
-          end
-        end
-
-        describe 'to_sql' do
-          it 'takes an engine' do
-            engine = FakeRecord::Base.new
-            engine.connection.extend Module.new {
-              attr_accessor :quote_count
-              def quote(*args) @quote_count += 1; super; end
-              def quote_column_name(*args) @quote_count += 1; super; end
-              def quote_table_name(*args) @quote_count += 1; super; end
-            }
-            engine.connection.quote_count = 0
-
-            attr = Table.new(:users)[:id]
-            test = attr.eq(10)
-            test.to_sql engine
-            engine.connection.quote_count.must_equal 3
-          end
-        end
-      end
-
-      describe 'or' do
-        it 'makes an OR node' do
-          attr = Table.new(:users)[:id]
-          left  = attr.eq(10)
-          right = attr.eq(11)
-          node  = left.or right
-          node.expr.left.must_equal left
-          node.expr.right.must_equal right
-        end
-      end
-
-      describe 'and' do
-        it 'makes and AND node' do
-          attr = Table.new(:users)[:id]
-          left  = attr.eq(10)
-          right = attr.eq(11)
-          node  = left.and right
-          node.left.must_equal left
-          node.right.must_equal right
-        end
-      end
-
-      it 'is equal with equal ivars' do
-        array = [Equality.new('foo', 'bar'), Equality.new('foo', 'bar')]
-        assert_equal 1, array.uniq.size
-      end
-
-      it 'is not equal with different ivars' do
-        array = [Equality.new('foo', 'bar'), Equality.new('foo', 'baz')]
-        assert_equal 2, array.uniq.size
-      end
-    end
-  end
-end