Adding spec:mysql and spec:sqlite3 tasks

4 files changed, 154 insertions, 64 deletions

diff --git a/spec/arel/unit/predicates/binary_spec.rb b/spec/arel/unit/predicates/binary_spec.rb
index 56fcf2d8ad..2d0c67e006 100644
--- a/spec/arel/unit/predicates/binary_spec.rb
+++ b/spec/arel/unit/predicates/binary_spec.rb
@@ -18,13 +18,19 @@ module Arel
         @operand1 = ConcreteBinary.new(@attribute1, 1)
         @operand2 = ConcreteBinary.new(@attribute2, "name")
       end
-      
+
       describe Or do
         describe "#to_sql" do
           it "manufactures sql with an OR operation" do
-            Or.new(@operand1, @operand2).to_sql.should be_like("
-              (`users`.`id` <=> 1 OR `users`.`name` <=> 'name')
-            ")
+            sql = Or.new(@operand1, @operand2).to_sql
+
+            adapter_is :mysql do
+              sql.should be_like(%Q{(`users`.`id` <=> 1 OR `users`.`name` <=> 'name')})
+            end
+
+            adapter_is_not :mysql do
+              sql.should be_like(%Q{("users"."id" <=> 1 OR "users"."name" <=> 'name')})
+            end
           end
         end
       end
@@ -32,58 +38,82 @@ module Arel
       describe And do
         describe "#to_sql" do
           it "manufactures sql with an AND operation" do
-            And.new(@operand1, @operand2).to_sql.should be_like("
-              (`users`.`id` <=> 1 AND `users`.`name` <=> 'name')
-            ")
+            sql = And.new(@operand1, @operand2).to_sql
+
+            adapter_is :mysql do
+              sql.should be_like(%Q{(`users`.`id` <=> 1 AND `users`.`name` <=> 'name')})
+            end
+
+            adapter_is_not :mysql do
+              sql.should be_like(%Q{("users"."id" <=> 1 AND "users"."name" <=> 'name')})
+            end
           end
         end
       end
     end
-    
+
     describe '#to_sql' do
       describe 'when relating two attributes' do
         it 'manufactures sql with a binary operation' do
-          ConcreteBinary.new(@attribute1, @attribute2).to_sql.should be_like("
-            `users`.`id` <=> `users`.`name`
-          ")
+          sql = ConcreteBinary.new(@attribute1, @attribute2).to_sql
+
+          adapter_is :mysql do
+            sql.should be_like(%Q{`users`.`id` <=> `users`.`name`})
+          end
+
+          adapter_is_not :mysql do
+            sql.should be_like(%Q{"users"."id" <=> "users"."name"})
+          end
         end
       end
-      
+
       describe 'when relating an attribute and a value' do
         before do
           @value = "1-asdf"
         end
-        
+
         describe 'when relating to an integer attribute' do
           it 'formats values as integers' do
-            ConcreteBinary.new(@attribute1, @value).to_sql.should be_like("
-              `users`.`id` <=> 1
-            ")
+            sql = ConcreteBinary.new(@attribute1, @value).to_sql
+
+            adapter_is :mysql do
+              sql.should be_like(%Q{`users`.`id` <=> 1})
+            end
+
+            adapter_is_not :mysql do
+              sql.should be_like(%Q{"users"."id" <=> 1})
+            end
           end
         end
-        
+
         describe 'when relating to a string attribute' do
           it 'formats values as strings' do
-            ConcreteBinary.new(@attribute2, @value).to_sql.should be_like("
-              `users`.`name` <=> '1-asdf'
-            ")
+            sql = ConcreteBinary.new(@attribute2, @value).to_sql
+
+            adapter_is :mysql do
+              sql.should be_like(%Q{`users`.`name` <=> '1-asdf'})
+            end
+
+            adapter_is_not :mysql do
+              sql.should be_like(%Q{"users"."name" <=> '1-asdf'})
+            end
           end
         end
       end
     end
-  
+
     describe '#bind' do
       before do
         @another_relation = @relation.alias
       end
-      
+
       describe 'when both operands are attributes' do
         it "manufactures an expression with the attributes bound to the relation" do
           ConcreteBinary.new(@attribute1, @attribute2).bind(@another_relation). \
             should == ConcreteBinary.new(@another_relation[@attribute1], @another_relation[@attribute2])
         end
       end
-      
+
       describe 'when an operand is a value' do
         it "manufactures an expression with unmodified values" do
           ConcreteBinary.new(@attribute1, "asdf").bind(@another_relation). \
diff --git a/spec/arel/unit/predicates/equality_spec.rb b/spec/arel/unit/predicates/equality_spec.rb
index 8a58ba3096..b595cdd247 100644
--- a/spec/arel/unit/predicates/equality_spec.rb
+++ b/spec/arel/unit/predicates/equality_spec.rb
@@ -8,40 +8,52 @@ module Arel
       @attribute1 = @relation1[:id]
       @attribute2 = @relation2[:user_id]
     end
-  
-    describe '==' do 
+
+    describe '==' do
       it "obtains if attribute1 and attribute2 are identical" do
         Equality.new(@attribute1, @attribute2).should == Equality.new(@attribute1, @attribute2)
         Equality.new(@attribute1, @attribute2).should_not == Equality.new(@attribute1, @attribute1)
       end
-    
+
       it "obtains if the concrete type of the predicates are identical" do
         Equality.new(@attribute1, @attribute2).should_not == Binary.new(@attribute1, @attribute2)
       end
-    
+
       it "is commutative on the attributes" do
         Equality.new(@attribute1, @attribute2).should == Equality.new(@attribute2, @attribute1)
       end
     end
-    
+
     describe '#to_sql' do
       describe 'when relating to a non-nil value' do
         it "manufactures an equality predicate" do
-          Equality.new(@attribute1, @attribute2).to_sql.should be_like("
-            `users`.`id` = `photos`.`user_id`
-          ")
+          sql = Equality.new(@attribute1, @attribute2).to_sql
+
+          adapter_is :mysql do
+            sql.should be_like(%Q{`users`.`id` = `photos`.`user_id`})
+          end
+
+          adapter_is_not :mysql do
+            sql.should be_like(%Q{"users"."id" = "photos"."user_id"})
+          end
         end
       end
-      
+
       describe 'when relation to a nil value' do
         before do
           @nil = nil
         end
-        
+
         it "manufactures an is null predicate" do
-          Equality.new(@attribute1, @nil).to_sql.should be_like("
-            `users`.`id` IS NULL
-          ")
+          sql = Equality.new(@attribute1, @nil).to_sql
+
+          adapter_is :mysql do
+            sql.should be_like(%Q{`users`.`id` IS NULL})
+          end
+
+          adapter_is_not :mysql do
+            sql.should be_like(%Q{"users"."id" IS NULL})
+          end
         end
       end
     end
diff --git a/spec/arel/unit/predicates/in_spec.rb b/spec/arel/unit/predicates/in_spec.rb
index 797798a77f..9107da9d4b 100644
--- a/spec/arel/unit/predicates/in_spec.rb
+++ b/spec/arel/unit/predicates/in_spec.rb
@@ -6,51 +6,79 @@ module Arel
       @relation = Table.new(:users)
       @attribute = @relation[:id]
     end
-  
-    describe '#to_sql' do 
+
+    describe '#to_sql' do
       describe 'when relating to an array' do
         describe 'when the array\'s elements are the same type as the attribute' do
           before do
             @array = [1, 2, 3]
           end
-          
+
           it 'manufactures sql with a comma separated list' do
-            In.new(@attribute, @array).to_sql.should be_like("
-              `users`.`id` IN (1, 2, 3)
-            ")        
+            sql = In.new(@attribute, @array).to_sql
+
+            adapter_is :mysql do
+              sql.should be_like(%Q{`users`.`id` IN (1, 2, 3)})
+            end
+
+            adapter_is_not :mysql do
+              sql.should be_like(%Q{"users"."id" IN (1, 2, 3)})
+            end
           end
         end
-        
+
         describe 'when the array\'s elements are not same type as the attribute' do
           before do
             @array = ['1-asdf', 2, 3]
           end
-          
+
           it 'formats values in the array as the type of the attribute' do
-            In.new(@attribute, @array).to_sql.should be_like("
-              `users`.`id` IN (1, 2, 3)
-            ")
+            sql = In.new(@attribute, @array).to_sql
+
+            adapter_is :mysql do
+              sql.should be_like(%Q{`users`.`id` IN (1, 2, 3)})
+            end
+
+            adapter_is_not :mysql do
+              sql.should be_like(%Q{"users"."id" IN (1, 2, 3)})
+            end
           end
         end
       end
-      
+
       describe 'when relating to a range' do
         before do
           @range = 1..2
         end
-        
+
         it 'manufactures sql with a between' do
-          In.new(@attribute, @range).to_sql.should be_like("
-            `users`.`id` BETWEEN 1 AND 2
-          ")                  
+          sql = In.new(@attribute, @range).to_sql
+
+          adapter_is :mysql do
+            sql.should be_like(%Q{`users`.`id` BETWEEN 1 AND 2})
+          end
+
+          adapter_is_not :mysql do
+            sql.should be_like(%Q{"users"."id" BETWEEN 1 AND 2})
+          end
         end
       end
-      
+
       describe 'when relating to a relation' do
         it 'manufactures sql with a subselect' do
-          In.new(@attribute, @relation).to_sql.should be_like("
-            `users`.`id` IN (SELECT `users`.`id`, `users`.`name` FROM `users`)
-          ")        
+          sql = In.new(@attribute, @relation).to_sql
+
+          adapter_is :mysql do
+            sql.should be_like(%Q{
+              `users`.`id` IN (SELECT `users`.`id`, `users`.`name` FROM `users`)
+            })
+          end
+
+          adapter_is_not :mysql do
+            sql.should be_like(%Q{
+              "users"."id" IN (SELECT "users"."id", "users"."name" FROM "users")
+            })
+          end
         end
       end
     end
diff --git a/spec/arel/unit/predicates/predicates_spec.rb b/spec/arel/unit/predicates/predicates_spec.rb
index d11637cabe..8f9cec5376 100644
--- a/spec/arel/unit/predicates/predicates_spec.rb
+++ b/spec/arel/unit/predicates/predicates_spec.rb
@@ -9,23 +9,43 @@ module Arel
       @operand1 = Equality.new(@attribute1, 1)
       @operand2 = Equality.new(@attribute2, "name")
     end
-    
+
     describe "when being combined with another predicate with AND logic" do
       describe "#to_sql" do
         it "manufactures sql with an AND operation" do
-          @operand1.and(@operand2).to_sql.should be_like("
-            (`users`.`id` = 1 AND `users`.`name` = 'name')
-          ")
+          sql = @operand1.and(@operand2).to_sql
+
+          adapter_is :mysql do
+            sql.should be_like(%Q{
+              (`users`.`id` = 1 AND `users`.`name` = 'name')
+            })
+          end
+
+          adapter_is_not :mysql do
+            sql.should be_like(%Q{
+              ("users"."id" = 1 AND "users"."name" = 'name')
+            })
+          end
         end
       end
     end
-    
+
     describe "when being combined with another predicate with OR logic" do
       describe "#to_sql" do
         it "manufactures sql with an OR operation" do
-          @operand1.or(@operand2).to_sql.should be_like("
-            (`users`.`id` = 1 OR `users`.`name` = 'name')
-          ")
+          sql = @operand1.or(@operand2).to_sql
+
+          adapter_is :mysql do
+            sql.should be_like(%Q{
+              (`users`.`id` = 1 OR `users`.`name` = 'name')
+            })
+          end
+
+          adapter_is_not :mysql do
+            sql.should be_like(%Q{
+              ("users"."id" = 1 OR "users"."name" = 'name')
+            })
+          end
         end
       end
     end