arel 1.0.1 → 2.0.0

data/spec/spec.opts

@@ -0,0 +1,3 @@
+--backtrace
+--diff
+--color

data/spec/spec_helper.rb

@@ -1,33 +1,18 @@
 require 'rubygems'
 require 'spec'
-require 'pp'
 require 'fileutils'
 require 'arel'
 
-if adapter = ENV['ADAPTER']
-  require "support/connections/#{adapter}_connection.rb"
-end
-
-Dir["spec/{support,shared}/*.rb"].each do |file|
-  require file
-end
+require 'support/matchers/be_like'
+require 'support/check'
+require 'support/fake_record'
+require 'support/shared/tree_manager_shared'
 
 Spec::Runner.configure do |config|
   config.include Matchers
-  config.include AdapterGuards
   config.include Check
 
-  if defined?(ActiveRecord::Base)
-    tmp = File.expand_path('../../tmp', __FILE__)
-
-    FileUtils.mkdir_p(tmp)
-    ActiveRecord::Base.logger = Logger.new("#{tmp}/debug.log")
-    ActiveRecord::Base.establish_connection("unit")
-
-    require "support/schemas/#{ENV['ADAPTER']}_schema.rb"
-
-    config.before do
-      Arel::Table.engine = Arel::Sql::Engine.new(ActiveRecord::Base)
-    end
+  config.before do
+    Arel::Table.engine = Arel::Sql::Engine.new(FakeRecord::Base.new)
   end
 end

data/spec/support/fake_record.rb

@@ -0,0 +1,89 @@
+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)
+        ]
+      }
+      @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 => 'sqlite3')
+      @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

data/spec/support/shared/tree_manager_shared.rb

@@ -0,0 +1,9 @@
+shared_examples_for "TreeManager" do
+  describe "clone" do
+    it "clones the insert statement" do
+      subject.instance_variable_get("@head").should_receive(:clone).and_return(:foo) # TODO: ick.
+      dolly = subject.clone
+      dolly.instance_variable_get("@head").should == :foo
+    end
+  end
+end

data/spec/table_spec.rb

@@ -0,0 +1,176 @@
+require 'spec_helper'
+
+module Arel
+  describe Table do
+    before do
+      @relation = Table.new(:users)
+    end
+
+    describe 'primary_key' do
+      it 'should return an attribute' do
+        check @relation.primary_key.name.should == :id
+      end
+    end
+
+    describe 'select_manager' do
+      it 'should return an empty select manager' do
+        sm = @relation.select_manager
+        sm.to_sql.should be_like 'SELECT'
+      end
+    end
+
+    describe 'having' do
+      it 'adds a having clause' do
+        mgr = @relation.having @relation[:id].eq(10)
+        mgr.to_sql.should be_like %{
+         SELECT FROM "users" HAVING "users"."id" = 10
+        }
+      end
+    end
+
+    describe 'backwards compat' do
+      describe 'joins' do
+        it 'returns nil' do
+          check @relation.joins(nil).should == nil
+        end
+      end
+
+      describe 'join' do
+        it 'noops on nil' do
+          mgr = @relation.join nil
+
+          mgr.to_sql.should 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.should 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.should 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
+        check @relation.aliases.should == []
+
+        node = @relation.alias
+        check @relation.aliases.should == [node]
+        check node.name.should == 'users_2'
+        check node[:id].relation.should == node
+        check node[:id].relation.should != node
+      end
+    end
+
+    describe 'new' do
+      it 'takes :columns' do
+        columns = Table.engine.connection.columns("users")
+        @relation = Table.new(:users, :columns => columns)
+        check @relation.columns.first.name.should == :id
+        check @relation.engine.should == Table.engine
+      end
+
+      it 'should accept an engine' do
+        rel = Table.new :users, 'foo'
+        check rel.engine.should == 'foo'
+      end
+
+      it 'should accept a hash' do
+        rel = Table.new :users, :engine => 'foo'
+        check rel.engine.should == 'foo'
+      end
+
+      it 'ignores as if it equals name' do
+        rel = Table.new :users, :as => 'users'
+        rel.table_alias.should be_nil
+      end
+    end
+
+    describe 'order' do
+      it "should take an order" do
+        manager = @relation.order "foo"
+        manager.to_sql.should 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.should be_like %{ SELECT * FROM "users" LIMIT 1 }
+      end
+    end
+
+    describe 'project' do
+      it 'can project' do
+        manager = @relation.project SqlLiteral.new '*'
+        manager.to_sql.should be_like %{ SELECT * FROM "users" }
+      end
+
+      it 'takes multiple parameters' do
+        manager = @relation.project SqlLiteral.new('*'), SqlLiteral.new('*')
+        manager.to_sql.should 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.should be_kind_of TreeManager
+        manager.to_sql.should 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
+        check columns.length.should == 2
+        columns.map { |x| x.name.to_s }.sort.should == %w{ name id }.sort
+      end
+    end
+
+    it "should have a name" do
+      @relation.name.should == :users
+    end
+
+    it "should have an engine" do
+      @relation.engine.should == 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]
+          check column.name.should == :id
+          column.should be_kind_of Attributes::Integer
+        end
+      end
+
+      describe 'when table does not exist' do
+        it 'returns nil' do
+          @relation[:foooo].should be_nil
+        end
+      end
+    end
+  end
+end

data/spec/update_manager_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+module Arel
+  describe 'update manager' do
+    describe 'new' do
+      it 'takes an engine' do
+        Arel::UpdateManager.new Table.engine
+      end
+    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.should 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.should 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.should 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']]).should == 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.should be_like %{ UPDATE "users" }
+      end
+
+      it 'chains' do
+        um = Arel::UpdateManager.new Table.engine
+        um.table(Table.new(:users)).should == 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.should 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)).should == um
+      end
+    end
+
+    describe "TreeManager" do
+      subject do
+        table = Table.new :users
+        Arel::UpdateManager.new(Table.engine).tap do |manager|
+          manager.table table
+          manager.where table[:id].eq(1)
+        end
+      end
+
+      it_should_behave_like "TreeManager"
+    end
+  end
+end

data/spec/visitors/join_sql_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+module Arel
+  module Visitors
+    describe 'the join_sql visitor' do
+      before do
+        @visitor = JoinSql.new Table.engine
+      end
+
+      describe 'inner join' do
+        it 'should visit left if left is a join' do
+          t    = Table.new :users
+          join = Nodes::InnerJoin.new t, t, Nodes::On.new(t[:id])
+          j2   = Nodes::InnerJoin.new join, t, Nodes::On.new(t[:id])
+          @visitor.accept(j2).should be_like %{
+            INNER JOIN "users" ON "users"."id"
+            INNER JOIN "users" ON "users"."id"
+          }
+        end
+      end
+
+      describe 'outer join' do
+        it 'should visit left if left is a join' do
+          t    = Table.new :users
+          join = Nodes::OuterJoin.new t, t, Nodes::On.new(t[:id])
+          j2   = Nodes::OuterJoin.new join, t, Nodes::On.new(t[:id])
+          @visitor.accept(j2).should be_like %{
+            LEFT OUTER JOIN "users" ON "users"."id"
+            LEFT OUTER JOIN "users" ON "users"."id"
+          }
+        end
+      end
+    end
+  end
+end