arel 1.0.1 → 2.0.0

data/spec/attributes_spec.rb

@@ -1,12 +1,39 @@
 require 'spec_helper'
 
 module Arel
-  module Sql
-    describe 'Attributes' do
-      describe 'for' do
-        it 'should return undefined for undefined columns' do
-          thing = Struct.new(:type).new(:HELLO)
-          check Attributes.for(thing).should == Attributes::Undefined
+  describe 'Attributes' do
+    describe 'for' do
+      it 'returns the correct constant for strings' do
+        [:string, :text, :binary].each do |type|
+          column = Struct.new(:type).new type
+          Attributes.for(column).should == Attributes::String
+        end
+      end
+
+      it 'returns the correct constant for ints' do
+        column = Struct.new(:type).new :integer
+        Attributes.for(column).should == Attributes::Integer
+      end
+
+      it 'returns the correct constant for floats' do
+        column = Struct.new(:type).new :float
+        Attributes.for(column).should == Attributes::Float
+      end
+
+      it 'returns the correct constant for decimals' do
+        column = Struct.new(:type).new :decimal
+        Attributes.for(column).should == Attributes::Decimal
+      end
+
+      it 'returns the correct constant for boolean' do
+        column = Struct.new(:type).new :boolean
+        Attributes.for(column).should == Attributes::Boolean
+      end
+
+      it 'returns the correct constant for time' do
+        [:date, :datetime, :timestamp, :time].each do |type|
+          column = Struct.new(:type).new type
+          Attributes.for(column).should == Attributes::Time
         end
       end
     end

data/spec/crud_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+module Arel
+  class FakeCrudder < SelectManager
+    class FakeEngine
+      attr_reader :calls, :connection_pool, :spec, :config
+
+      def initialize
+        @calls = []
+        @connection_pool = self
+        @spec = self
+        @config =  { :adapter => 'sqlite3' }
+      end
+
+      def connection; self end
+
+      def method_missing name, *args
+        @calls << [name, args]
+      end
+    end
+
+    include Crud
+
+    attr_reader :engine
+    attr_accessor :ctx
+
+    def initialize engine = FakeEngine.new
+      super
+    end
+  end
+
+  describe 'crud' do
+    describe 'insert' do
+      it 'should call insert on the connection' do
+        table = Table.new :users
+        fc = FakeCrudder.new
+        fc.from table
+        fc.insert [[table[:id], 'foo']]
+        fc.engine.calls.find { |method, _|
+          method == :insert
+        }.should_not be_nil
+      end
+    end
+
+    describe 'update' do
+      it 'should call update on the connection' do
+        table = Table.new :users
+        fc = FakeCrudder.new
+        fc.from table
+        fc.update [[table[:id], 'foo']]
+        fc.engine.calls.find { |method, _|
+          method == :update
+        }.should_not be_nil
+      end
+    end
+
+    describe 'delete' do
+      it 'should call delete on the connection' do
+        table = Table.new :users
+        fc = FakeCrudder.new
+        fc.from table
+        fc.delete
+        fc.engine.calls.find { |method, _|
+          method == :delete
+        }.should_not be_nil
+      end
+    end
+  end
+end

data/spec/delete_manager_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+module Arel
+  describe 'delete manager' do
+    describe 'new' do
+      it 'takes an engine' do
+        Arel::DeleteManager.new Table.engine
+      end
+    end
+
+    describe 'from' do
+      it 'uses from' do
+        table = Table.new(:users)
+        dm = Arel::DeleteManager.new Table.engine
+        dm.from table
+        dm.to_sql.should be_like %{ DELETE FROM "users" }
+      end
+
+      it 'chains' do
+        table = Table.new(:users)
+        dm = Arel::DeleteManager.new Table.engine
+        check dm.from(table).should == dm
+      end
+    end
+
+    describe 'where' do
+      it 'uses where values' do
+        table = Table.new(:users)
+        dm = Arel::DeleteManager.new Table.engine
+        dm.from table
+        dm.where table[:id].eq(10)
+        dm.to_sql.should be_like %{ DELETE FROM "users" WHERE "users"."id" = 10}
+      end
+
+      it 'chains' do
+        table = Table.new(:users)
+        dm = Arel::DeleteManager.new Table.engine
+        check dm.where(table[:id].eq(10)).should == dm
+      end
+    end
+
+    describe "TreeManager" do
+      subject do
+        table = Table.new :users
+        Arel::DeleteManager.new(Table.engine).tap do |manager|
+          manager.where(table[:id].eq(10))
+        end
+      end
+
+      it_should_behave_like "TreeManager"
+    end
+  end
+end

data/spec/insert_manager_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+
+module Arel
+  describe 'insert manager' do
+    describe 'new' do
+      it 'takes an engine' do
+        Arel::InsertManager.new Table.engine
+      end
+    end
+
+    describe 'insert' do
+      it "inserts false" do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new Table.engine
+
+        table[:id].column.extend(Module.new {
+          def type; :boolean; end
+        })
+
+        manager.insert [[table[:id], false]]
+        manager.to_sql.should be_like %{
+          INSERT INTO "users" ("id") VALUES ('f')
+        }
+      end
+
+      it "inserts null" do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new Table.engine
+        manager.insert [[table[:id], nil]]
+        manager.to_sql.should be_like %{
+          INSERT INTO "users" ("id") VALUES (NULL)
+        }
+      end
+
+      it "inserts time" do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new Table.engine
+
+        time = Time.now
+        attribute = table[:id]
+        attribute.column.type = :date
+
+        manager.insert [[attribute, time]]
+        manager.to_sql.should be_like %{
+          INSERT INTO "users" ("id") VALUES (#{Table.engine.connection.quote time})
+        }
+      end
+
+      it 'takes a list of lists' do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new Table.engine
+        manager.into table
+        manager.insert [[table[:id], 1], [table[:name], 'aaron']]
+        manager.to_sql.should be_like %{
+          INSERT INTO "users" ("id", "name") VALUES (1, 'aaron')
+        }
+      end
+
+      it 'defaults the table' do
+        table = Table.new(:users)
+        manager = Arel::InsertManager.new Table.engine
+        manager.insert [[table[:id], 1], [table[:name], 'aaron']]
+        manager.to_sql.should be_like %{
+          INSERT INTO "users" ("id", "name") VALUES (1, 'aaron')
+        }
+      end
+
+      it 'takes an empty list' do
+        manager = Arel::InsertManager.new Table.engine
+        manager.insert []
+      end
+    end
+
+    describe 'into' do
+      it 'takes an engine' do
+        manager = Arel::InsertManager.new Table.engine
+        manager.into(Table.new(:users)).should == manager
+      end
+
+      it 'converts to sql' do
+        table   = Table.new :users
+        manager = Arel::InsertManager.new Table.engine
+        manager.into table
+        manager.to_sql.should be_like %{
+          INSERT INTO "users"
+        }
+      end
+    end
+
+    describe 'columns' do
+      it "converts to sql" do
+        table   = Table.new :users
+        manager = Arel::InsertManager.new Table.engine
+        manager.into table
+        manager.columns << table[:id]
+        manager.to_sql.should be_like %{
+          INSERT INTO "users" ("id")
+        }
+      end
+    end
+
+    describe "values" do
+      it "converts to sql" do
+        table   = Table.new :users
+        manager = Arel::InsertManager.new Table.engine
+        manager.into table
+
+        manager.values = Nodes::Values.new [1]
+        manager.to_sql.should be_like %{
+          INSERT INTO "users" VALUES (1)
+        }
+      end
+    end
+
+    describe "combo" do
+      it "puts shit together" do
+        table   = Table.new :users
+        manager = Arel::InsertManager.new Table.engine
+        manager.into table
+
+        manager.values = Nodes::Values.new [1, 'aaron']
+        manager.columns << table[:id]
+        manager.columns << table[:name]
+        manager.to_sql.should be_like %{
+          INSERT INTO "users" ("id", "name") VALUES (1, 'aaron')
+        }
+      end
+    end
+
+    describe "TreeManager" do
+      subject do
+        table = Table.new(:users)
+        Arel::InsertManager.new(Table.engine).tap do |manager|
+          manager.insert [[table[:id], nil]]
+        end
+      end
+
+      it_should_behave_like "TreeManager"
+    end
+  end
+end

data/spec/nodes/count_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Arel::Nodes::Count do
+  describe 'backwards compatibility' do
+    it 'must be an expression' do
+      Arel::Nodes::Count.new('foo').should 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.should be_like %{
+        COUNT("users"."id") AS foo
+      }
+    end
+  end
+end

data/spec/nodes/delete_statement_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Arel::Nodes::DeleteStatement do
+  describe "#clone" do
+    it "clones wheres" do
+      statement = Arel::Nodes::DeleteStatement.new
+      statement.wheres = %w[a b c]
+
+      statement.wheres.should_receive(:clone).and_return([:wheres])
+
+      dolly = statement.clone
+      dolly.wheres.should == [:wheres]
+    end
+  end
+end

data/spec/nodes/equality_spec.rb

@@ -0,0 +1,72 @@
+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)
+            check left.operator.should == :==
+          end
+        end
+
+        describe 'operand1' do
+          it "should equal left" do
+            attr = Table.new(:users)[:id]
+            left  = attr.eq(10)
+            check left.left.should == left.operand1
+          end
+        end
+
+        describe 'operand2' do
+          it "should equal right" do
+            attr = Table.new(:users)[:id]
+            left  = attr.eq(10)
+            check left.right.should == 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
+            check engine.connection.quote_count.should == 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
+          check node.expr.left.should == left
+          check node.expr.right.should == 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
+          check node.left.should == left
+          check node.right.should == right
+        end
+      end
+    end
+  end
+end

data/spec/nodes/insert_statement_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_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]
+
+      statement.columns.should_receive(:clone).and_return([:columns])
+      statement.values.should_receive(:clone).and_return([:values])
+
+      dolly = statement.clone
+      check dolly.columns.should == [:columns]
+      check dolly.values.should  == [:values]
+    end
+  end
+end

data/spec/nodes/or_spec.rb

@@ -0,0 +1,20 @@
+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
+          check node.expr.left.should == left
+          check node.expr.right.should == right
+
+          oror = node.or(right)
+          check oror.expr.left == node
+          check oror.expr.right == right
+        end
+      end
+    end
+  end
+end