square-arel 2.0.9.20110222133018

data/test/helper.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'minitest/autorun'
+require 'fileutils'
+require 'arel'
+
+require 'support/fake_record'
+Arel::Table.engine = Arel::Sql::Engine.new(FakeRecord::Base.new)
+
+class Object
+  def must_be_like other
+    self.gsub(/\s+/, ' ').strip.must_equal other.gsub(/\s+/, ' ').strip
+  end
+end

data/test/nodes/test_as.rb

@@ -0,0 +1,16 @@
+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
+      end
+    end
+  end
+end

data/test/nodes/test_count.rb

@@ -0,0 +1,18 @@
+require 'helper'
+
+describe Arel::Nodes::Count do
+  describe 'backwards compatibility' do
+    it 'must be an expression' do
+      Arel::Nodes::Count.new('foo').must_be_kind_of Arel::Expression
+    end
+  end
+
+  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
+end

data/test/nodes/test_delete_statement.rb

@@ -0,0 +1,14 @@
+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
+end

data/test/nodes/test_equality.rb

@@ -0,0 +1,74 @@
+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 2
+          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
+    end
+  end
+end

data/test/nodes/test_insert_statement.rb

@@ -0,0 +1,18 @@
+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
+end

data/test/nodes/test_node.rb

@@ -0,0 +1,33 @@
+require 'helper'
+
+module Arel
+  class TestNode < MiniTest::Unit::TestCase
+    def test_all_nodes_are_nodes
+      Nodes.constants.map { |k|
+        Nodes.const_get(k)
+      }.grep(Class).each do |klass|
+        next if Nodes::SqlLiteral == klass
+        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

@@ -0,0 +1,20 @@
+require 'helper'
+
+module Arel
+  module Nodes
+    describe 'not' do
+      describe '#not' do
+        it 'makes a NOT 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
+
+          node.or(right).not
+        end
+      end
+    end
+  end
+end

data/test/nodes/test_or.rb

@@ -0,0 +1,22 @@
+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
+    end
+  end
+end

data/test/nodes/test_select_core.rb

@@ -0,0 +1,22 @@
+require 'helper'
+
+describe Arel::Nodes::SelectCore do
+  describe "#clone" do
+    it "clones froms, projections and wheres" do
+      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
+
+      dolly.froms.must_equal core.froms
+      dolly.projections.must_equal core.projections
+      dolly.wheres.must_equal core.wheres
+
+      dolly.froms.wont_be_same_as core.froms
+      dolly.projections.wont_be_same_as core.projections
+      dolly.wheres.wont_be_same_as core.wheres
+    end
+  end
+end

data/test/nodes/test_select_statement.rb

@@ -0,0 +1,13 @@
+require 'helper'
+
+describe Arel::Nodes::SelectStatement do
+  describe "#clone" do
+    it "clones cores" do
+      statement = Arel::Nodes::SelectStatement.new %w[a b c]
+
+      dolly = statement.clone
+      dolly.cores.must_equal      statement.cores
+      dolly.cores.wont_be_same_as statement.cores
+    end
+  end
+end

data/test/nodes/test_sql_literal.rb

@@ -0,0 +1,52 @@
+require 'helper'
+
+module Arel
+  module Nodes
+    describe 'sql literal' do
+      describe 'sql' do
+        it 'makes a sql literal node' do
+          sql = Arel.sql 'foo'
+          sql.must_be_kind_of Arel::Nodes::SqlLiteral
+        end
+      end
+
+      describe 'count' do
+        it 'makes a count node' do
+          node = SqlLiteral.new('*').count
+          viz = Visitors::ToSql.new Table.engine
+          viz.accept(node).must_be_like %{ COUNT(*) }
+        end
+
+        it 'makes a distinct node' do
+          node = SqlLiteral.new('*').count true
+          viz = Visitors::ToSql.new Table.engine
+          viz.accept(node).must_be_like %{ COUNT(DISTINCT *) }
+        end
+      end
+
+      describe 'equality' do
+        it 'makes an equality node' do
+          node = SqlLiteral.new('foo').eq(1)
+          viz = Visitors::ToSql.new Table.engine
+          viz.accept(node).must_be_like %{ foo = 1 }
+        end
+      end
+
+      describe 'grouped "or" equality' do
+        it 'makes a grouping node with an or node' do
+          node = SqlLiteral.new('foo').eq_any([1,2])
+          viz = Visitors::ToSql.new Table.engine
+          viz.accept(node).must_be_like %{ (foo = 1 OR foo = 2) }
+        end
+      end
+
+      describe 'grouped "and" equality' do
+        it 'makes a grouping node with an or node' do
+          node = SqlLiteral.new('foo').eq_all([1,2])
+          viz = Visitors::ToSql.new Table.engine
+          viz.accept(node).must_be_like %{ (foo = 1 AND foo = 2) }
+        end
+      end
+    end
+  end
+end

data/test/nodes/test_sum.rb

@@ -0,0 +1,12 @@
+require 'helper'
+
+describe Arel::Nodes::Sum do
+  describe "as" do
+    it 'should alias the sum' do
+      table = Arel::Table.new :users
+      table[:id].sum.as('foo').to_sql.must_be_like %{
+        SUM("users"."id") AS foo
+      }
+    end
+  end
+end

data/test/nodes/test_update_statement.rb

@@ -0,0 +1,18 @@
+require 'helper'
+
+describe Arel::Nodes::UpdateStatement do
+  describe "#clone" do
+    it "clones wheres and values" do
+      statement = Arel::Nodes::UpdateStatement.new
+      statement.wheres = %w[a b c]
+      statement.values = %w[x y z]
+
+      dolly = statement.clone
+      dolly.wheres.must_equal statement.wheres
+      dolly.wheres.wont_be_same_as statement.wheres
+
+      dolly.values.must_equal statement.values
+      dolly.values.wont_be_same_as statement.values
+    end
+  end
+end

data/test/support/fake_record.rb

@@ -0,0 +1,91 @@
+module FakeRecord
+  class Column < Struct.new(:name, :type)
+  end
+
+  class Connection
+    attr_reader :tables
+
+    def initialize
+      @tables = %w{ users photos developers }
+      @columns = {
+        'users' => [
+          Column.new('id', :integer),
+          Column.new('name', :string),
+          Column.new('bool', :boolean),
+          Column.new('created_at', :date),
+        ]
+      }
+      @primary_keys = {
+        'users' => 'id'
+      }
+    end
+
+    def primary_key name
+      @primary_keys[name.to_s]
+    end
+
+    def table_exists? name
+      @tables.include? name.to_s
+    end
+
+    def columns name, message = nil
+      @columns[name.to_s]
+    end
+
+    def quote_table_name name
+      "\"#{name.to_s}\""
+    end
+
+    def quote_column_name name
+      "\"#{name.to_s}\""
+    end
+
+    def quote thing, column = nil
+      if column && column.type == :integer
+        return 'NULL' if thing.nil?
+        return thing.to_i
+      end
+
+      case thing
+      when true
+        "'t'"
+      when false
+        "'f'"
+      when nil
+        'NULL'
+      when Numeric
+        thing
+      else
+        "'#{thing}'"
+      end
+    end
+  end
+
+  class ConnectionPool
+    class Spec < Struct.new(:config)
+    end
+
+    attr_reader :spec, :connection
+
+    def initialize
+      @spec = Spec.new(:adapter => 'america')
+      @connection = Connection.new
+    end
+
+    def with_connection
+      yield connection
+    end
+  end
+
+  class Base
+    attr_accessor :connection_pool
+
+    def initialize
+      @connection_pool = ConnectionPool.new
+    end
+
+    def connection
+      connection_pool.connection
+    end
+  end
+end