square-arel 2.0.9.20110222133018

data/test/test_table.rb

@@ -0,0 +1,193 @@
+require 'helper'
+
+module Arel
+  describe Table do
+    before do
+      @relation = Table.new(:users)
+    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 'primary_key' do
+      it 'should return an attribute' do
+        @relation.primary_key.name.must_equal :id
+      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 '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 'joins' do
+        it 'returns nil' do
+          @relation.joins(nil).must_equal nil
+        end
+      end
+
+      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
+    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 'takes :columns' do
+        columns = Table.engine.connection.columns("users")
+        @relation = Table.new(:users, :columns => columns)
+        @relation.columns.first.name.must_equal :id
+        @relation.engine.must_equal Table.engine
+      end
+
+      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 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 SqlLiteral.new '*'
+        manager.to_sql.must_be_like %{ SELECT * FROM "users" }
+      end
+
+      it 'takes multiple parameters' do
+        manager = @relation.project SqlLiteral.new('*'), 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
+
+    describe 'columns' do
+      it 'returns a list of columns' do
+        columns = @relation.columns
+        columns.length.must_equal 4
+        columns.map { |x| x.name.to_s }.sort.must_equal %w{ created_at bool name id }.sort
+      end
+    end
+
+    it "should have a name" do
+      @relation.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
+          column.must_be_kind_of Attributes::Integer
+        end
+      end
+
+      describe 'when table does not exist' do
+        it 'returns nil' do
+          @relation[:foooo].must_be_nil
+        end
+      end
+    end
+  end
+
+  describe Table do
+    describe 'when checking the existence of a table' do
+      it 'should be present in the table cache despite the class of its name' do
+        [ 'users', :users ].each do |name|
+          relation = Table.new name
+          Table.table_cache(relation.engine).key?(relation.name).must_equal true
+        end
+      end
+    end
+  end
+end

data/test/test_update_manager.rb

@@ -0,0 +1,86 @@
+require 'helper'
+
+module Arel
+  describe 'update manager' do
+    describe 'new' do
+      it 'takes an engine' do
+        Arel::UpdateManager.new Table.engine
+      end
+    end
+
+    it 'handles limit properly' do
+      table = Table.new(:users)
+      um = Arel::UpdateManager.new Table.engine
+      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
+    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
+  end
+end

data/test/visitors/test_depth_first.rb

@@ -0,0 +1,212 @@
+require 'helper'
+
+module Arel
+  module Visitors
+    class TestDepthFirst < MiniTest::Unit::TestCase
+      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::Having,
+        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, func], @collector.calls
+        end
+      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, :c
+        @visitor.accept join
+        assert_equal [:a, :b, :c, join], @collector.calls
+      end
+
+      def test_outer_join
+        join = Nodes::OuterJoin.new :a, :b, :c
+        @visitor.accept join
+        assert_equal [:a, :b, :c, join], @collector.calls
+      end
+
+      [
+        Arel::Nodes::And,
+        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::StringJoin,
+        Arel::Nodes::TableAlias,
+        Arel::Nodes::Values,
+        Arel::Nodes::As,
+        Arel::Nodes::DeleteStatement,
+        Arel::Nodes::Ordering,
+      ].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
+
+      [
+        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_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.having = :e
+
+        @visitor.accept core
+        assert_equal [
+          :a, core.projections,
+          :b,
+          :c, core.wheres,
+          :d, core.groups,
+          :e,
+          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