arel 6.0.0.beta2 → 6.0.0

data/test/test_table.rb

@@ -1,253 +0,0 @@
-require 'helper'
-
-module Arel
-  describe Table do
-    before do
-      @relation = Table.new(:users)
-    end
-
-    it 'should create join nodes' do
-      join = @relation.create_string_join 'foo'
-      assert_kind_of Arel::Nodes::StringJoin, join
-      assert_equal 'foo', join.left
-    end
-
-    it 'should create join nodes' do
-      join = @relation.create_join 'foo', 'bar'
-      assert_kind_of Arel::Nodes::InnerJoin, join
-      assert_equal 'foo', join.left
-      assert_equal 'bar', join.right
-    end
-
-    it 'should create join nodes with a klass' do
-      join = @relation.create_join 'foo', 'bar', Arel::Nodes::FullOuterJoin
-      assert_kind_of Arel::Nodes::FullOuterJoin, join
-      assert_equal 'foo', join.left
-      assert_equal 'bar', join.right
-    end
-
-    it 'should create join nodes with a klass' do
-      join = @relation.create_join 'foo', 'bar', Arel::Nodes::OuterJoin
-      assert_kind_of Arel::Nodes::OuterJoin, join
-      assert_equal 'foo', join.left
-      assert_equal 'bar', join.right
-    end
-
-    it 'should create join nodes with a klass' do
-      join = @relation.create_join 'foo', 'bar', Arel::Nodes::RightOuterJoin
-      assert_kind_of Arel::Nodes::RightOuterJoin, join
-      assert_equal 'foo', join.left
-      assert_equal 'bar', join.right
-    end
-
-    it 'should return an insert manager' do
-      im = @relation.compile_insert 'VALUES(NULL)'
-      assert_kind_of Arel::InsertManager, im
-      im.into Table.new(:users)
-      assert_equal "INSERT INTO \"users\" VALUES(NULL)", im.to_sql
-    end
-
-    it 'should return IM from insert_manager' do
-      im = @relation.insert_manager
-      assert_kind_of Arel::InsertManager, im
-      assert_equal im.engine, @relation.engine
-    end
-
-    describe 'skip' do
-      it 'should add an offset' do
-        sm = @relation.skip 2
-        sm.to_sql.must_be_like "SELECT FROM \"users\" OFFSET 2"
-      end
-    end
-
-    describe 'select_manager' do
-      it 'should return an empty select manager' do
-        sm = @relation.select_manager
-        sm.to_sql.must_be_like 'SELECT'
-      end
-    end
-
-    describe 'update_manager' do
-      it 'should return an update manager' do
-        um = @relation.update_manager
-        assert_kind_of Arel::UpdateManager, um
-        assert_equal um.engine, @relation.engine
-      end
-    end
-
-    describe 'delete_manager' do
-      it 'should return a delete manager' do
-        dm = @relation.delete_manager
-        assert_kind_of Arel::DeleteManager, dm
-        assert_equal dm.engine, @relation.engine
-      end
-    end
-
-    describe 'having' do
-      it 'adds a having clause' do
-        mgr = @relation.having @relation[:id].eq(10)
-        mgr.to_sql.must_be_like %{
-         SELECT FROM "users" HAVING "users"."id" = 10
-        }
-      end
-    end
-
-    describe 'backwards compat' do
-      describe 'join' do
-        it 'noops on nil' do
-          mgr = @relation.join nil
-
-          mgr.to_sql.must_be_like %{ SELECT FROM "users" }
-        end
-
-        it 'takes a second argument for join type' do
-          right     = @relation.alias
-          predicate = @relation[:id].eq(right[:id])
-          mgr = @relation.join(right, Nodes::OuterJoin).on(predicate)
-
-          mgr.to_sql.must_be_like %{
-           SELECT FROM "users"
-             LEFT OUTER JOIN "users" "users_2"
-               ON "users"."id" = "users_2"."id"
-          }
-        end
-      end
-
-      describe 'join' do
-        it 'creates an outer join' do
-          right     = @relation.alias
-          predicate = @relation[:id].eq(right[:id])
-          mgr = @relation.outer_join(right).on(predicate)
-
-          mgr.to_sql.must_be_like %{
-            SELECT FROM "users"
-              LEFT OUTER JOIN "users" "users_2"
-                ON "users"."id" = "users_2"."id"
-          }
-        end
-      end
-    end
-
-    describe 'group' do
-      it 'should create a group' do
-        manager = @relation.group @relation[:id]
-        manager.to_sql.must_be_like %{
-          SELECT FROM "users" GROUP BY "users"."id"
-        }
-      end
-    end
-
-    describe 'alias' do
-      it 'should create a node that proxies to a table' do
-        @relation.aliases.must_equal []
-
-        node = @relation.alias
-        @relation.aliases.must_equal [node]
-        node.name.must_equal 'users_2'
-        node[:id].relation.must_equal node
-      end
-    end
-
-    describe 'new' do
-      it 'should accept an engine' do
-        rel = Table.new :users, 'foo'
-        rel.engine.must_equal 'foo'
-      end
-
-      it 'should accept a hash' do
-        rel = Table.new :users, :engine => 'foo'
-        rel.engine.must_equal 'foo'
-      end
-
-      it 'ignores as if it equals name' do
-        rel = Table.new :users, :as => 'users'
-        rel.table_alias.must_be_nil
-      end
-    end
-
-    describe 'order' do
-      it "should take an order" do
-        manager = @relation.order "foo"
-        manager.to_sql.must_be_like %{ SELECT FROM "users" ORDER BY foo }
-      end
-    end
-
-    describe 'take' do
-      it "should add a limit" do
-        manager = @relation.take 1
-        manager.project Nodes::SqlLiteral.new '*'
-        manager.to_sql.must_be_like %{ SELECT * FROM "users" LIMIT 1 }
-      end
-    end
-
-    describe 'project' do
-      it 'can project' do
-        manager = @relation.project Nodes::SqlLiteral.new '*'
-        manager.to_sql.must_be_like %{ SELECT * FROM "users" }
-      end
-
-      it 'takes multiple parameters' do
-        manager = @relation.project Nodes::SqlLiteral.new('*'), Nodes::SqlLiteral.new('*')
-        manager.to_sql.must_be_like %{ SELECT *, * FROM "users" }
-      end
-    end
-
-    describe 'where' do
-      it "returns a tree manager" do
-        manager = @relation.where @relation[:id].eq 1
-        manager.project @relation[:id]
-        manager.must_be_kind_of TreeManager
-        manager.to_sql.must_be_like %{
-          SELECT "users"."id"
-          FROM "users"
-          WHERE "users"."id" = 1
-        }
-      end
-    end
-
-    it "should have a name" do
-      @relation.name.must_equal 'users'
-    end
-
-    it "should have a table name" do
-      @relation.table_name.must_equal 'users'
-    end
-
-    it "should have an engine" do
-      @relation.engine.must_equal Table.engine
-    end
-
-    describe '[]' do
-      describe 'when given a Symbol' do
-        it "manufactures an attribute if the symbol names an attribute within the relation" do
-          column = @relation[:id]
-          column.name.must_equal :id
-        end
-      end
-    end
-
-    describe 'equality' do
-      it 'is equal with equal ivars' do
-        relation1 = Table.new(:users, 'vroom')
-        relation1.aliases     = %w[a b c]
-        relation1.table_alias = 'zomg'
-        relation2 = Table.new(:users, 'vroom')
-        relation2.aliases     = %w[a b c]
-        relation2.table_alias = 'zomg'
-        array = [relation1, relation2]
-        assert_equal 1, array.uniq.size
-      end
-
-      it 'is not equal with different ivars' do
-        relation1 = Table.new(:users, 'vroom')
-        relation1.aliases     = %w[a b c]
-        relation1.table_alias = 'zomg'
-        relation2 = Table.new(:users, 'vroom')
-        relation2.aliases     = %w[x y z]
-        relation2.table_alias = 'zomg'
-        array = [relation1, relation2]
-        assert_equal 2, array.uniq.size
-      end
-    end
-  end
-end

data/test/test_update_manager.rb

@@ -1,124 +0,0 @@
-require 'helper'
-
-module Arel
-  describe 'update manager' do
-    describe 'new' do
-      it 'takes an engine' do
-        Arel::UpdateManager.new Table.engine
-      end
-    end
-
-    it "should not quote sql literals" do
-      table = Table.new(:users)
-      um = Arel::UpdateManager.new Table.engine
-      um.table table
-      um.set [[table[:name], (Arel::Nodes::BindParam.new '?')]]
-      um.to_sql.must_be_like %{ UPDATE "users" SET "name" =  ? }
-    end
-
-    it 'handles limit properly' do
-      table = Table.new(:users)
-      um = Arel::UpdateManager.new Table.engine
-      um.key = 'id'
-      um.take 10
-      um.table table
-      um.set [[table[:name], nil]]
-      assert_match(/LIMIT 10/, um.to_sql)
-    end
-
-    describe 'set' do
-      it "updates with null" do
-        table = Table.new(:users)
-        um = Arel::UpdateManager.new Table.engine
-        um.table table
-        um.set [[table[:name], nil]]
-        um.to_sql.must_be_like %{ UPDATE "users" SET "name" =  NULL }
-      end
-
-      it 'takes a string' do
-        table = Table.new(:users)
-        um = Arel::UpdateManager.new Table.engine
-        um.table table
-        um.set Nodes::SqlLiteral.new "foo = bar"
-        um.to_sql.must_be_like %{ UPDATE "users" SET foo = bar }
-      end
-
-      it 'takes a list of lists' do
-        table = Table.new(:users)
-        um = Arel::UpdateManager.new Table.engine
-        um.table table
-        um.set [[table[:id], 1], [table[:name], 'hello']]
-        um.to_sql.must_be_like %{
-          UPDATE "users" SET "id" = 1, "name" =  'hello'
-        }
-      end
-
-      it 'chains' do
-        table = Table.new(:users)
-        um = Arel::UpdateManager.new Table.engine
-        um.set([[table[:id], 1], [table[:name], 'hello']]).must_equal um
-      end
-    end
-
-    describe 'table' do
-      it 'generates an update statement' do
-        um = Arel::UpdateManager.new Table.engine
-        um.table Table.new(:users)
-        um.to_sql.must_be_like %{ UPDATE "users" }
-      end
-
-      it 'chains' do
-        um = Arel::UpdateManager.new Table.engine
-        um.table(Table.new(:users)).must_equal um
-      end
-
-      it 'generates an update statement with joins' do
-        um = Arel::UpdateManager.new Table.engine
-
-        table = Table.new(:users)
-        join_source = Arel::Nodes::JoinSource.new(
-          table,
-          [table.create_join(Table.new(:posts))]
-        )
-
-        um.table join_source
-        um.to_sql.must_be_like %{ UPDATE "users" INNER JOIN "posts" }
-      end
-    end
-
-    describe 'where' do
-      it 'generates a where clause' do
-        table = Table.new :users
-        um = Arel::UpdateManager.new Table.engine
-        um.table table
-        um.where table[:id].eq(1)
-        um.to_sql.must_be_like %{
-          UPDATE "users" WHERE "users"."id" = 1
-        }
-      end
-
-      it 'chains' do
-        table = Table.new :users
-        um = Arel::UpdateManager.new Table.engine
-        um.table table
-        um.where(table[:id].eq(1)).must_equal um
-      end
-    end
-
-    describe 'key' do
-      before do
-        @table = Table.new :users
-        @um = Arel::UpdateManager.new Table.engine
-        @um.key = @table[:foo]
-      end
-
-      it 'can be set' do
-        @um.ast.key.must_equal @table[:foo]
-      end
-
-      it 'can be accessed' do
-        @um.key.must_equal @table[:foo]
-      end
-    end
-  end
-end

data/test/visitors/test_bind_visitor.rb

@@ -1,60 +0,0 @@
-require 'helper'
-require 'arel/visitors/bind_visitor'
-require 'support/fake_record'
-
-module Arel
-  module Visitors
-    class TestBindVisitor < Arel::Test
-      attr_reader :collector
-
-      def setup
-        @collector = Collectors::SQLString.new
-        super
-      end
-
-      ##
-      # Tests visit_Arel_Nodes_Assignment correctly
-      # substitutes binds with values from block
-      def test_assignment_binds_are_substituted
-        table = Table.new(:users)
-        um = Arel::UpdateManager.new Table.engine
-        bp = Nodes::BindParam.new '?'
-        um.set [[table[:name], bp]]
-        visitor = Class.new(Arel::Visitors::ToSql) {
-          include Arel::Visitors::BindVisitor
-        }.new Table.engine.connection
-
-        assignment = um.ast.values[0]
-        actual = visitor.accept(assignment, collector) {
-          "replace"
-        }
-        assert actual
-        value = actual.value
-        assert_like "\"name\" = replace", value
-      end
-
-      def test_visitor_yields_on_binds
-        visitor = Class.new(Arel::Visitors::ToSql) {
-          include Arel::Visitors::BindVisitor
-        }.new nil
-
-        bp = Nodes::BindParam.new 'omg'
-        called = false
-        visitor.accept(bp, collector) { called = true }
-        assert called
-      end
-
-      def test_visitor_only_yields_on_binds
-        visitor = Class.new(Arel::Visitors::ToSql) {
-          include Arel::Visitors::BindVisitor
-        }.new(nil)
-
-        bp = Arel.sql 'omg'
-        called = false
-
-        visitor.accept(bp, collector) { called = true }
-        refute called
-      end
-    end
-  end
-end

data/test/visitors/test_depth_first.rb

@@ -1,258 +0,0 @@
-require 'helper'
-require 'set'
-
-module Arel
-  module Visitors
-    class TestDepthFirst < Minitest::Test
-      Collector = Struct.new(:calls) do
-        def call object
-          calls << object
-        end
-      end
-
-      def setup
-        @collector = Collector.new []
-        @visitor = Visitors::DepthFirst.new @collector
-      end
-
-      def test_raises_with_object
-        assert_raises(TypeError) do
-          @visitor.accept(Object.new)
-        end
-      end
-
-
-      # unary ops
-      [
-        Arel::Nodes::Not,
-        Arel::Nodes::Group,
-        Arel::Nodes::On,
-        Arel::Nodes::Grouping,
-        Arel::Nodes::Offset,
-        Arel::Nodes::Ordering,
-        Arel::Nodes::Having,
-        Arel::Nodes::StringJoin,
-        Arel::Nodes::UnqualifiedColumn,
-        Arel::Nodes::Top,
-        Arel::Nodes::Limit,
-      ].each do |klass|
-        define_method("test_#{klass.name.gsub('::', '_')}") do
-          op = klass.new(:a)
-          @visitor.accept op
-          assert_equal [:a, op], @collector.calls
-        end
-      end
-
-      # functions
-      [
-        Arel::Nodes::Exists,
-        Arel::Nodes::Avg,
-        Arel::Nodes::Min,
-        Arel::Nodes::Max,
-        Arel::Nodes::Sum,
-      ].each do |klass|
-        define_method("test_#{klass.name.gsub('::', '_')}") do
-          func = klass.new(:a, "b")
-          @visitor.accept func
-          assert_equal [:a, "b", false, func], @collector.calls
-        end
-      end
-
-      def test_named_function
-        func = Arel::Nodes::NamedFunction.new(:a, :b, "c")
-        @visitor.accept func
-        assert_equal [:a, :b, false, "c", func], @collector.calls
-      end
-
-      def test_lock
-        lock = Nodes::Lock.new true
-        @visitor.accept lock
-        assert_equal [lock], @collector.calls
-      end
-
-      def test_count
-        count = Nodes::Count.new :a, :b, "c"
-        @visitor.accept count
-        assert_equal [:a, "c", :b, count], @collector.calls
-      end
-
-      def test_inner_join
-        join = Nodes::InnerJoin.new :a, :b
-        @visitor.accept join
-        assert_equal [:a, :b, join], @collector.calls
-      end
-
-      def test_full_outer_join
-        join = Nodes::FullOuterJoin.new :a, :b
-        @visitor.accept join
-        assert_equal [:a, :b, join], @collector.calls
-      end
-
-      def test_outer_join
-        join = Nodes::OuterJoin.new :a, :b
-        @visitor.accept join
-        assert_equal [:a, :b, join], @collector.calls
-      end
-
-      def test_right_outer_join
-        join = Nodes::RightOuterJoin.new :a, :b
-        @visitor.accept join
-        assert_equal [:a, :b, join], @collector.calls
-      end
-
-      [
-        Arel::Nodes::Assignment,
-        Arel::Nodes::Between,
-        Arel::Nodes::DoesNotMatch,
-        Arel::Nodes::Equality,
-        Arel::Nodes::GreaterThan,
-        Arel::Nodes::GreaterThanOrEqual,
-        Arel::Nodes::In,
-        Arel::Nodes::LessThan,
-        Arel::Nodes::LessThanOrEqual,
-        Arel::Nodes::Matches,
-        Arel::Nodes::NotEqual,
-        Arel::Nodes::NotIn,
-        Arel::Nodes::Or,
-        Arel::Nodes::TableAlias,
-        Arel::Nodes::Values,
-        Arel::Nodes::As,
-        Arel::Nodes::DeleteStatement,
-        Arel::Nodes::JoinSource,
-      ].each do |klass|
-        define_method("test_#{klass.name.gsub('::', '_')}") do
-          binary = klass.new(:a, :b)
-          @visitor.accept binary
-          assert_equal [:a, :b, binary], @collector.calls
-        end
-      end
-
-      def test_Arel_Nodes_InfixOperation
-        binary = Arel::Nodes::InfixOperation.new(:o, :a, :b)
-        @visitor.accept binary
-        assert_equal [:a, :b, binary], @collector.calls
-      end
-
-      # N-ary
-      [
-        Arel::Nodes::And,
-      ].each do |klass|
-        define_method("test_#{klass.name.gsub('::', '_')}") do
-          binary = klass.new([:a, :b, :c])
-          @visitor.accept binary
-          assert_equal [:a, :b, :c, binary], @collector.calls
-        end
-      end
-
-      [
-        Arel::Attributes::Integer,
-        Arel::Attributes::Float,
-        Arel::Attributes::String,
-        Arel::Attributes::Time,
-        Arel::Attributes::Boolean,
-        Arel::Attributes::Attribute
-      ].each do |klass|
-        define_method("test_#{klass.name.gsub('::', '_')}") do
-          binary = klass.new(:a, :b)
-          @visitor.accept binary
-          assert_equal [:a, :b, binary], @collector.calls
-        end
-      end
-
-      def test_table
-        relation = Arel::Table.new(:users)
-        @visitor.accept relation
-        assert_equal ['users', relation], @collector.calls
-      end
-
-      def test_array
-        node = Nodes::Or.new(:a, :b)
-        list = [node]
-        @visitor.accept list
-        assert_equal [:a, :b, node, list], @collector.calls
-      end
-
-      def test_set
-        node = Nodes::Or.new(:a, :b)
-        set  = Set.new([node])
-        @visitor.accept set
-        assert_equal [:a, :b, node, set], @collector.calls
-      end
-
-      def test_hash
-        node = Nodes::Or.new(:a, :b)
-        hash = { node => node }
-        @visitor.accept hash
-        assert_equal [:a, :b, node, :a, :b, node, hash], @collector.calls
-      end
-
-      def test_update_statement
-        stmt = Nodes::UpdateStatement.new
-        stmt.relation = :a
-        stmt.values << :b
-        stmt.wheres << :c
-        stmt.orders << :d
-        stmt.limit = :e
-
-        @visitor.accept stmt
-        assert_equal [:a, :b, stmt.values, :c, stmt.wheres, :d, stmt.orders,
-          :e, stmt], @collector.calls
-      end
-
-      def test_select_core
-        core = Nodes::SelectCore.new
-        core.projections << :a
-        core.froms = :b
-        core.wheres << :c
-        core.groups << :d
-        core.windows << :e
-        core.having = :f
-
-        @visitor.accept core
-        assert_equal [
-          :a, core.projections,
-          :b, [],
-          core.source,
-          :c, core.wheres,
-          :d, core.groups,
-          :e, core.windows,
-          :f,
-          core], @collector.calls
-      end
-
-      def test_select_statement
-        ss = Nodes::SelectStatement.new
-        ss.cores.replace [:a]
-        ss.orders << :b
-        ss.limit = :c
-        ss.lock = :d
-        ss.offset = :e
-
-        @visitor.accept ss
-        assert_equal [
-          :a, ss.cores,
-          :b, ss.orders,
-          :c,
-          :d,
-          :e,
-          ss], @collector.calls
-      end
-
-      def test_insert_statement
-        stmt = Nodes::InsertStatement.new
-        stmt.relation = :a
-        stmt.columns << :b
-        stmt.values = :c
-
-        @visitor.accept stmt
-        assert_equal [:a, :b, stmt.columns, :c, stmt], @collector.calls
-      end
-
-      def test_node
-        node = Nodes::Node.new
-        @visitor.accept node
-        assert_equal [node], @collector.calls
-      end
-    end
-  end
-end