arel 6.0.0.beta2 → 6.0.0

data/test/nodes/test_extract.rb

@@ -1,41 +0,0 @@
-require 'helper'
-
-describe Arel::Nodes::Extract do
-  it "should extract field" do
-    table = Arel::Table.new :users
-    table[:timestamp].extract('date').to_sql.must_be_like %{
-      EXTRACT(DATE FROM "users"."timestamp")
-    }
-  end
-
-  describe "as" do
-    it 'should alias the extract' do
-      table = Arel::Table.new :users
-      table[:timestamp].extract('date').as('foo').to_sql.must_be_like %{
-        EXTRACT(DATE FROM "users"."timestamp") AS foo
-      }
-    end
-
-    it 'should not mutate the extract' do
-      table = Arel::Table.new :users
-      extract = table[:timestamp].extract('date')
-      before = extract.dup
-      extract.as('foo')
-      assert_equal extract, before
-    end
-  end
-
-  describe 'equality' do
-    it 'is equal with equal ivars' do
-      table = Arel::Table.new :users
-      array = [table[:attr].extract('foo'), table[:attr].extract('foo')]
-      assert_equal 1, array.uniq.size
-    end
-
-    it 'is not equal with different ivars' do
-      table = Arel::Table.new :users
-      array = [table[:attr].extract('foo'), table[:attr].extract('bar')]
-      assert_equal 2, array.uniq.size
-    end
-  end
-end

data/test/nodes/test_false.rb

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

data/test/nodes/test_grouping.rb

@@ -1,25 +0,0 @@
-require 'helper'
-
-module Arel
-  module Nodes
-    describe 'Grouping' do
-      it 'should create Equality nodes' do
-        grouping = Grouping.new(Nodes.build_quoted('foo'))
-        grouping.eq('foo').to_sql.must_be_like %q{('foo') = 'foo'}
-      end
-
-      describe 'equality' do
-        it 'is equal with equal ivars' do
-          array = [Grouping.new('foo'), Grouping.new('foo')]
-          assert_equal 1, array.uniq.size
-        end
-
-        it 'is not equal with different ivars' do
-          array = [Grouping.new('foo'), Grouping.new('bar')]
-          assert_equal 2, array.uniq.size
-        end
-      end
-    end
-  end
-end
-

data/test/nodes/test_infix_operation.rb

@@ -1,40 +0,0 @@
-require 'helper'
-
-module Arel
-  module Nodes
-    class TestInfixOperation < Minitest::Test
-      def test_construct
-        operation = InfixOperation.new :+, 1, 2
-        assert_equal :+, operation.operator
-        assert_equal 1, operation.left
-        assert_equal 2, operation.right
-      end
-
-      def test_operation_alias
-        operation = InfixOperation.new :+, 1, 2
-        aliaz = operation.as('zomg')
-        assert_kind_of As, aliaz
-        assert_equal operation, aliaz.left
-        assert_equal 'zomg', aliaz.right
-      end
-
-      def test_operation_ordering
-        operation = InfixOperation.new :+, 1, 2
-        ordering = operation.desc
-        assert_kind_of Descending, ordering
-        assert_equal operation, ordering.expr
-        assert ordering.descending?
-      end
-
-      def test_equality_with_same_ivars
-        array = [InfixOperation.new(:+, 1, 2), InfixOperation.new(:+, 1, 2)]
-        assert_equal 1, array.uniq.size
-      end
-
-      def test_inequality_with_different_ivars
-        array = [InfixOperation.new(:+, 1, 2), InfixOperation.new(:+, 1, 3)]
-        assert_equal 2, array.uniq.size
-      end
-    end
-  end
-end

data/test/nodes/test_insert_statement.rb

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

data/test/nodes/test_named_function.rb

@@ -1,46 +0,0 @@
-require 'helper'
-
-module Arel
-  module Nodes
-    class TestNamedFunction < Minitest::Test
-      def test_construct
-        function = NamedFunction.new 'omg', 'zomg'
-        assert_equal 'omg', function.name
-        assert_equal 'zomg', function.expressions
-      end
-
-      def test_function_alias
-        function = NamedFunction.new 'omg', 'zomg'
-        function = function.as('wth')
-        assert_equal 'omg', function.name
-        assert_equal 'zomg', function.expressions
-        assert_kind_of SqlLiteral, function.alias
-        assert_equal 'wth', function.alias
-      end
-
-      def test_construct_with_alias
-        function = NamedFunction.new 'omg', 'zomg', 'wth'
-        assert_equal 'omg', function.name
-        assert_equal 'zomg', function.expressions
-        assert_kind_of SqlLiteral, function.alias
-        assert_equal 'wth', function.alias
-      end
-
-      def test_equality_with_same_ivars
-        array = [
-          NamedFunction.new('omg', 'zomg', 'wth'),
-          NamedFunction.new('omg', 'zomg', 'wth')
-        ]
-        assert_equal 1, array.uniq.size
-      end
-
-      def test_inequality_with_different_ivars
-        array = [
-          NamedFunction.new('omg', 'zomg', 'wth'),
-          NamedFunction.new('zomg', 'zomg', 'wth')
-        ]
-        assert_equal 2, array.uniq.size
-      end
-    end
-  end
-end

data/test/nodes/test_node.rb

@@ -1,39 +0,0 @@
-require 'helper'
-
-module Arel
-  class TestNode < Minitest::Test
-    def test_includes_factory_methods
-      assert Node.new.respond_to?(:create_join)
-    end
-
-    def test_all_nodes_are_nodes
-      Nodes.constants.map { |k|
-        Nodes.const_get(k)
-      }.grep(Class).each do |klass|
-        next if Nodes::SqlLiteral == klass
-        next if Nodes::BindParam == klass
-        next if klass.name =~ /^Arel::Nodes::Test/
-        assert klass.ancestors.include?(Nodes::Node), klass.name
-      end
-    end
-
-    def test_each
-      list = []
-      node = Nodes::Node.new
-      node.each { |n| list << n }
-      assert_equal [node], list
-    end
-
-    def test_generator
-      list = []
-      node = Nodes::Node.new
-      node.each.each { |n| list << n }
-      assert_equal [node], list
-    end
-
-    def test_enumerable
-      node = Nodes::Node.new
-      assert_kind_of Enumerable, node
-    end
-  end
-end

data/test/nodes/test_not.rb

@@ -1,29 +0,0 @@
-require 'helper'
-
-module Arel
-  module Nodes
-    describe 'not' do
-      describe '#not' do
-        it 'makes a NOT node' do
-          attr = Table.new(:users)[:id]
-          expr  = attr.eq(10)
-          node  = expr.not
-          node.must_be_kind_of Not
-          node.expr.must_equal expr
-        end
-      end
-
-      describe 'equality' do
-        it 'is equal with equal ivars' do
-          array = [Not.new('foo'), Not.new('foo')]
-          assert_equal 1, array.uniq.size
-        end
-
-        it 'is not equal with different ivars' do
-          array = [Not.new('foo'), Not.new('baz')]
-          assert_equal 2, array.uniq.size
-        end
-      end
-    end
-  end
-end

data/test/nodes/test_or.rb

@@ -1,34 +0,0 @@
-require 'helper'
-
-module Arel
-  module Nodes
-    describe 'or' do
-      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
-
-          oror = node.or(right)
-          oror.expr.left.must_equal node
-          oror.expr.right.must_equal right
-        end
-      end
-
-      describe 'equality' do
-        it 'is equal with equal ivars' do
-          array = [Or.new('foo', 'bar'), Or.new('foo', 'bar')]
-          assert_equal 1, array.uniq.size
-        end
-
-        it 'is not equal with different ivars' do
-          array = [Or.new('foo', 'bar'), Or.new('foo', 'baz')]
-          assert_equal 2, array.uniq.size
-        end
-      end
-    end
-  end
-end

data/test/nodes/test_over.rb

@@ -1,67 +0,0 @@
-require 'helper'
-
-describe Arel::Nodes::Over do
-  describe 'as' do
-    it 'should alias the expression' do
-      table = Arel::Table.new :users
-      table[:id].count.over.as('foo').to_sql.must_be_like %{
-        COUNT("users"."id") OVER () AS foo
-      }
-    end
-  end
-
-  describe 'with literal' do
-    it 'should reference the window definition by name' do
-      table = Arel::Table.new :users
-      table[:id].count.over('foo').to_sql.must_be_like %{
-        COUNT("users"."id") OVER "foo"
-      }
-    end
-  end
-
-  describe 'with SQL literal' do
-    it 'should reference the window definition by name' do
-      table = Arel::Table.new :users
-      table[:id].count.over(Arel.sql('foo')).to_sql.must_be_like %{
-        COUNT("users"."id") OVER foo
-      }
-    end
-  end
-
-  describe 'with no expression' do
-    it 'should use empty definition' do
-      table = Arel::Table.new :users
-      table[:id].count.over.to_sql.must_be_like %{
-        COUNT("users"."id") OVER ()
-      }
-    end
-  end
-
-  describe 'with expression' do
-    it 'should use definition in sub-expression' do
-      table = Arel::Table.new :users
-      window = Arel::Nodes::Window.new.order(table['foo'])
-      table[:id].count.over(window).to_sql.must_be_like %{
-        COUNT("users"."id") OVER (ORDER BY \"users\".\"foo\")
-      }
-    end
-  end
-
-  describe 'equality' do
-    it 'is equal with equal ivars' do
-      array = [
-        Arel::Nodes::Over.new('foo', 'bar'),
-        Arel::Nodes::Over.new('foo', 'bar')
-      ]
-      assert_equal 1, array.uniq.size
-    end
-
-    it 'is not equal with different ivars' do
-      array = [
-        Arel::Nodes::Over.new('foo', 'bar'),
-        Arel::Nodes::Over.new('foo', 'baz')
-      ]
-      assert_equal 2, array.uniq.size
-    end
-  end
-end

data/test/nodes/test_select_core.rb

@@ -1,69 +0,0 @@
-require 'helper'
-
-module Arel
-  module Nodes
-    class TestSelectCore < Minitest::Test
-      def test_clone
-        core = Arel::Nodes::SelectCore.new
-        core.froms       = %w[a b c]
-        core.projections = %w[d e f]
-        core.wheres      = %w[g h i]
-
-        dolly = core.clone
-
-        assert_equal core.froms, dolly.froms
-        assert_equal core.projections, dolly.projections
-        assert_equal core.wheres, dolly.wheres
-
-        refute_same core.froms, dolly.froms
-        refute_same core.projections, dolly.projections
-        refute_same core.wheres, dolly.wheres
-      end
-
-      def test_set_quantifier
-        core = Arel::Nodes::SelectCore.new
-        core.set_quantifier = Arel::Nodes::Distinct.new
-        viz = Arel::Visitors::ToSql.new Table.engine.connection_pool
-        assert_match 'DISTINCT', viz.accept(core, Collectors::SQLString.new).value
-      end
-
-      def test_equality_with_same_ivars
-        core1 = SelectCore.new
-        core1.froms       = %w[a b c]
-        core1.projections = %w[d e f]
-        core1.wheres      = %w[g h i]
-        core1.groups      = %w[j k l]
-        core1.windows     = %w[m n o]
-        core1.having      = %w[p q r]
-        core2 = SelectCore.new
-        core2.froms       = %w[a b c]
-        core2.projections = %w[d e f]
-        core2.wheres      = %w[g h i]
-        core2.groups      = %w[j k l]
-        core2.windows     = %w[m n o]
-        core2.having      = %w[p q r]
-        array = [core1, core2]
-        assert_equal 1, array.uniq.size
-      end
-
-      def test_inequality_with_different_ivars
-        core1 = SelectCore.new
-        core1.froms       = %w[a b c]
-        core1.projections = %w[d e f]
-        core1.wheres      = %w[g h i]
-        core1.groups      = %w[j k l]
-        core1.windows     = %w[m n o]
-        core1.having      = %w[p q r]
-        core2 = SelectCore.new
-        core2.froms       = %w[a b c]
-        core2.projections = %w[d e f]
-        core2.wheres      = %w[g h i]
-        core2.groups      = %w[j k l]
-        core2.windows     = %w[m n o]
-        core2.having      = %w[l o l]
-        array = [core1, core2]
-        assert_equal 2, array.uniq.size
-      end
-    end
-  end
-end