removed duplicates from sql tests

Conflicts:

	spec/arel/engines/sql/unit/predicates/binary_spec.rb
	spec/arel/engines/sql/unit/predicates/equality_spec.rb
	spec/arel/engines/sql/unit/primitives/attribute_spec.rb
	spec/arel/engines/sql/unit/primitives/expression_spec.rb
	spec/arel/engines/sql/unit/relations/alias_spec.rb
	spec/arel/engines/sql/unit/relations/join_spec.rb
	spec/arel/engines/sql/unit/relations/project_spec.rb
	spec/arel/engines/sql/unit/relations/relation_spec.rb
	spec/arel/engines/sql/unit/relations/table_spec.rb
	spec/arel/engines/sql/unit/relations/where_spec.rb
	spec/arel/engines/sql/unit/session/session_spec.rb

13 files changed, 1 insertions, 553 deletions

diff --git a/spec/arel/engines/sql/unit/relations/array_spec.rb b/spec/arel/engines/memory/unit/relations/array_spec.rb
index 8d40858c5f..8d40858c5f 100644
--- a/spec/arel/engines/sql/unit/relations/array_spec.rb
+++ b/spec/arel/engines/memory/unit/relations/array_spec.rb
diff --git a/spec/arel/engines/sql/unit/predicates/binary_spec.rb b/spec/arel/engines/sql/unit/predicates/binary_spec.rb
index 03574225c2..679147067e 100644
--- a/spec/arel/engines/sql/unit/predicates/binary_spec.rb
+++ b/spec/arel/engines/sql/unit/predicates/binary_spec.rb
@@ -101,25 +101,5 @@ module Arel
         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). \
-            should == ConcreteBinary.new(@attribute1.find_correlate_in(@another_relation), "asdf".find_correlate_in(@another_relation))
-        end
-      end
-    end
   end
 end
\ No newline at end of file
diff --git a/spec/arel/engines/sql/unit/predicates/equality_spec.rb b/spec/arel/engines/sql/unit/predicates/equality_spec.rb
index 2ab79d7028..e8c8c42675 100644
--- a/spec/arel/engines/sql/unit/predicates/equality_spec.rb
+++ b/spec/arel/engines/sql/unit/predicates/equality_spec.rb
@@ -9,21 +9,6 @@ module Arel
       @attribute2 = @relation2[:user_id]
     end
 
-    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
diff --git a/spec/arel/engines/sql/unit/primitives/attribute_spec.rb b/spec/arel/engines/sql/unit/primitives/attribute_spec.rb
index f37cd14370..e71ab949f1 100644
--- a/spec/arel/engines/sql/unit/primitives/attribute_spec.rb
+++ b/spec/arel/engines/sql/unit/primitives/attribute_spec.rb
@@ -7,67 +7,12 @@ module Arel
       @attribute = @relation[:id]
     end
 
-    describe Attribute::Transformations do
-      describe '#as' do
-        it "manufactures an aliased attributed" do
-          @attribute.as(:alias).should == Attribute.new(@relation, @attribute.name, :alias => :alias, :ancestor => @attribute)
-        end
-      end
-
-      describe '#bind' do
-        it "manufactures an attribute with the relation bound and self as an ancestor" do
-          derived_relation = @relation.where(@relation[:id].eq(1))
-          @attribute.bind(derived_relation).should == Attribute.new(derived_relation, @attribute.name, :ancestor => @attribute)
-        end
-
-        it "returns self if the substituting to the same relation" do
-          @attribute.bind(@relation).should == @attribute
-        end
-      end
-
-      describe '#to_attribute' do
-        it "returns self" do
-          @attribute.to_attribute.should == @attribute
-        end
-      end
-    end
-
     describe '#column' do
       it "returns the corresponding column in the relation" do
         @attribute.column.should == @relation.column_for(@attribute)
       end
     end
-
-    describe '#engine' do
-      it "delegates to its relation" do
-        Attribute.new(@relation, :id).engine.should == @relation.engine
-      end
-    end
-
-    describe Attribute::Congruence do
-      describe '/' do
-        before do
-          @aliased_relation = @relation.alias
-          @doubly_aliased_relation = @aliased_relation.alias
-        end
-
-        describe 'when dividing two unrelated attributes' do
-          it "returns 0.0" do
-            (@relation[:id] / @relation[:name]).should == 0.0
-          end
-        end
-
-        describe 'when dividing two matching attributes' do
-          it 'returns a the highest score for the most similar attributes' do
-            (@aliased_relation[:id] / @relation[:id]) \
-              .should == (@aliased_relation[:id] / @relation[:id])
-            (@aliased_relation[:id] / @relation[:id]) \
-              .should < (@aliased_relation[:id] / @aliased_relation[:id])
-          end
-        end
-      end
-    end
-
+    
     describe '#to_sql' do
       describe 'for a simple attribute' do
         it "manufactures sql with an alias" do
@@ -83,89 +28,5 @@ module Arel
         end
       end
     end
-
-    describe Attribute::Predications do
-      before do
-        @attribute = Attribute.new(@relation, :name)
-      end
-
-      describe '#eq' do
-        it "manufactures an equality predicate" do
-          @attribute.eq('name').should == Equality.new(@attribute, 'name')
-        end
-      end
-
-      describe '#lt' do
-        it "manufactures a less-than predicate" do
-          @attribute.lt(10).should == LessThan.new(@attribute, 10)
-        end
-      end
-
-      describe '#lteq' do
-        it "manufactures a less-than or equal-to predicate" do
-          @attribute.lteq(10).should == LessThanOrEqualTo.new(@attribute, 10)
-        end
-      end
-
-      describe '#gt' do
-        it "manufactures a greater-than predicate" do
-          @attribute.gt(10).should == GreaterThan.new(@attribute, 10)
-        end
-      end
-
-      describe '#gteq' do
-        it "manufactures a greater-than or equal-to predicate" do
-          @attribute.gteq(10).should == GreaterThanOrEqualTo.new(@attribute, 10)
-        end
-      end
-
-      describe '#matches' do
-        it "manufactures a match predicate" do
-          @attribute.matches(/.*/).should == Match.new(@attribute, /.*/)
-        end
-      end
-
-      describe '#in' do
-        it "manufactures an in predicate" do
-          @attribute.in(1..30).should == In.new(@attribute, (1..30))
-        end
-      end
-    end
-
-    describe Attribute::Expressions do
-      before do
-        @attribute = Attribute.new(@relation, :name)
-      end
-
-      describe '#count' do
-        it "manufactures a count Expression" do
-          @attribute.count.should == Count.new(@attribute)
-        end
-      end
-
-      describe '#sum' do
-        it "manufactures a sum Expression" do
-          @attribute.sum.should == Sum.new(@attribute)
-        end
-      end
-
-      describe '#maximum' do
-        it "manufactures a maximum Expression" do
-          @attribute.maximum.should == Maximum.new(@attribute)
-        end
-      end
-
-      describe '#minimum' do
-        it "manufactures a minimum Expression" do
-          @attribute.minimum.should == Minimum.new(@attribute)
-        end
-      end
-
-      describe '#average' do
-        it "manufactures an average Expression" do
-          @attribute.average.should == Average.new(@attribute)
-        end
-      end
-    end
   end
 end
\ No newline at end of file
diff --git a/spec/arel/engines/sql/unit/primitives/expression_spec.rb b/spec/arel/engines/sql/unit/primitives/expression_spec.rb
index 0869d9e403..ee7f2c1461 100644
--- a/spec/arel/engines/sql/unit/primitives/expression_spec.rb
+++ b/spec/arel/engines/sql/unit/primitives/expression_spec.rb
@@ -7,35 +7,6 @@ module Arel
       @attribute = @relation[:id]
     end
 
-    describe Expression::Transformations do
-      before do
-        @expression = Count.new(@attribute)
-      end
-
-      describe '#bind' do
-        it "manufactures an attribute with a rebound relation and self as the ancestor" do
-          derived_relation = @relation.where(@relation[:id].eq(1))
-          @expression.bind(derived_relation).should == Count.new(@attribute.bind(derived_relation), nil, @expression)
-        end
-
-        it "returns self if the substituting to the same relation" do
-          @expression.bind(@relation).should == @expression
-        end
-      end
-
-      describe '#as' do
-        it "manufactures an aliased expression" do
-          @expression.as(:alias).should == Expression.new(@attribute, :alias, @expression)
-        end
-      end
-
-      describe '#to_attribute' do
-        it "manufactures an attribute with the expression as an ancestor" do
-          @expression.to_attribute.should == Attribute.new(@expression.relation, @expression.alias, :ancestor => @expression)
-        end
-      end
-    end
-
     describe '#to_sql' do
       it "manufactures sql with the expression and alias" do
         sql = Count.new(@attribute, :alias).to_sql
diff --git a/spec/arel/engines/sql/unit/primitives/value_spec.rb b/spec/arel/engines/sql/unit/primitives/value_spec.rb
index f76323f32b..da5a163d3b 100644
--- a/spec/arel/engines/sql/unit/primitives/value_spec.rb
+++ b/spec/arel/engines/sql/unit/primitives/value_spec.rb
@@ -18,11 +18,5 @@ module Arel
         Value.new(1, @relation).format(@relation[:id]).should == @relation[:id].to_sql
       end
     end
-
-    describe '#bind' do
-      it "manufactures a new value whose relation is the provided relation" do
-        Value.new(1, @relation).bind(another_relation = Table.new(:photos)).should == Value.new(1, another_relation)
-      end
-    end
   end
 end
diff --git a/spec/arel/engines/sql/unit/relations/alias_spec.rb b/spec/arel/engines/sql/unit/relations/alias_spec.rb
index 83b9113f6d..b67a0bbc89 100644
--- a/spec/arel/engines/sql/unit/relations/alias_spec.rb
+++ b/spec/arel/engines/sql/unit/relations/alias_spec.rb
@@ -6,13 +6,6 @@ module Arel
       @relation = Table.new(:users)
     end
 
-    describe '==' do
-      it "obtains if the objects are the same" do
-        Alias.new(@relation).should_not == Alias.new(@relation)
-        (aliaz = Alias.new(@relation)).should == aliaz
-      end
-    end
-
     describe '#to_sql' do
       describe 'when there is no ambiguity' do
         it 'does not alias table names anywhere a table name can appear' do
diff --git a/spec/arel/engines/sql/unit/relations/join_spec.rb b/spec/arel/engines/sql/unit/relations/join_spec.rb
index ea17f8106f..1f43101133 100644
--- a/spec/arel/engines/sql/unit/relations/join_spec.rb
+++ b/spec/arel/engines/sql/unit/relations/join_spec.rb
@@ -8,27 +8,6 @@ module Arel
       @predicate = @relation1[:id].eq(@relation2[:user_id])
     end
 
-    describe 'hashing' do
-      it 'implements hash equality' do
-        InnerJoin.new(@relation1, @relation2, @predicate) \
-          .should hash_the_same_as(InnerJoin.new(@relation1, @relation2, @predicate))
-      end
-    end
-
-    describe '#engine' do
-      it "delegates to a relation's engine" do
-        InnerJoin.new(@relation1, @relation2, @predicate).engine.should == @relation1.engine
-      end
-    end
-
-    describe '#attributes' do
-      it 'combines the attributes of the two relations' do
-        join = InnerJoin.new(@relation1, @relation2, @predicate)
-        join.attributes.should ==
-          (@relation1.attributes + @relation2.attributes).collect { |a| a.bind(join) }
-      end
-    end
-
     describe '#to_sql' do
       describe 'when joining with another relation' do
         it 'manufactures sql joining the two tables on the predicate' do
diff --git a/spec/arel/engines/sql/unit/relations/project_spec.rb b/spec/arel/engines/sql/unit/relations/project_spec.rb
index 9d6b9fab06..5e29124cfa 100644
--- a/spec/arel/engines/sql/unit/relations/project_spec.rb
+++ b/spec/arel/engines/sql/unit/relations/project_spec.rb
@@ -7,16 +7,6 @@ module Arel
       @attribute = @relation[:id]
     end
 
-    describe '#attributes' do
-      before do
-        @projection = Project.new(@relation, @attribute)
-      end
-
-      it "manufactures attributes associated with the projection relation" do
-        @projection.attributes.should == [@attribute].collect { |a| a.bind(@projection) }
-      end
-    end
-
     describe '#to_sql' do
       describe 'when given an attribute' do
         it "manufactures sql with a limited select clause" do
@@ -116,19 +106,5 @@ module Arel
         end
       end
     end
-
-    describe '#externalizable?' do
-      describe 'when the projections are attributes' do
-        it 'returns false' do
-          Project.new(@relation, @attribute).should_not be_externalizable
-        end
-      end
-
-      describe 'when the projections include an aggregation' do
-        it "obtains" do
-          Project.new(@relation, @attribute.sum).should be_externalizable
-        end
-      end
-    end
   end
 end
diff --git a/spec/arel/engines/sql/unit/relations/relation_spec.rb b/spec/arel/engines/sql/unit/relations/relation_spec.rb
deleted file mode 100644
index 9a5cfbff41..0000000000
--- a/spec/arel/engines/sql/unit/relations/relation_spec.rb
+++ /dev/null
@@ -1,169 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', '..', '..', '..', 'spec_helper')
-
-module Arel
-  describe Relation do
-    before do
-      @relation = Table.new(:users)
-      @attribute1 = @relation[:id]
-      @attribute2 = @relation[:name]
-    end
-
-    describe '[]' do
-      describe 'when given an', Attribute do
-        it "return the attribute congruent to the provided attribute" do
-          @relation[@attribute1].should == @attribute1
-        end
-      end
-
-      describe 'when given a', Symbol, String do
-        it "returns the attribute with the same name, if it exists" do
-          @relation[:id].should == @attribute1
-          @relation['id'].should == @attribute1
-          @relation[:does_not_exist].should be_nil
-        end
-      end
-    end
-
-    describe Relation::Operable do
-      describe 'joins' do
-        before do
-          @predicate = @relation[:id].eq(@relation[:id])
-        end
-
-        describe '#join' do
-          describe 'when given a relation' do
-            it "manufactures an inner join operation between those two relations" do
-              @relation.join(@relation).on(@predicate). \
-                should == InnerJoin.new(@relation, @relation, @predicate)
-            end
-          end
-
-          describe "when given a string" do
-            it "manufactures a join operation with the string passed through" do
-              @relation.join(arbitrary_string = "ASDF").should == Join.new(arbitrary_string, @relation)
-            end
-          end
-
-          describe "when given something blank" do
-            it "returns self" do
-              @relation.join.should == @relation
-            end
-          end
-        end
-
-        describe '#outer_join' do
-          it "manufactures a left outer join operation between those two relations" do
-            @relation.outer_join(@relation).on(@predicate). \
-              should == OuterJoin.new(@relation, @relation, @predicate)
-          end
-        end
-      end
-
-      describe '#project' do
-        it "manufactures a projection relation" do
-          @relation.project(@attribute1, @attribute2). \
-            should == Project.new(@relation, @attribute1, @attribute2)
-        end
-
-        describe "when given blank attributes" do
-          it "returns self" do
-            @relation.project.should == @relation
-          end
-        end
-      end
-
-      describe '#alias' do
-        it "manufactures an alias relation" do
-          @relation.alias.relation.should == Alias.new(@relation).relation
-        end
-      end
-
-      describe '#where' do
-        before do
-          @predicate = Equality.new(@attribute1, @attribute2)
-        end
-
-        it "manufactures a where relation" do
-          @relation.where(@predicate).should == Where.new(@relation, @predicate)
-        end
-
-        it "accepts arbitrary strings" do
-          @relation.where("arbitrary").should == Where.new(@relation, "arbitrary")
-        end
-
-        describe 'when given a blank predicate' do
-          it 'returns self' do
-            @relation.where.should == @relation
-          end
-        end
-      end
-
-      describe '#order' do
-        it "manufactures an order relation" do
-          @relation.order(@attribute1, @attribute2).should == Order.new(@relation, @attribute1, @attribute2)
-        end
-
-        describe 'when given a blank ordering' do
-          it 'returns self' do
-            @relation.order.should == @relation
-          end
-        end
-      end
-
-      describe '#take' do
-        it "manufactures a take relation" do
-          @relation.take(5).should == Take.new(@relation, 5)
-        end
-
-        describe 'when given a blank number of items' do
-          it 'returns self' do
-            @relation.take.should == @relation
-          end
-        end
-      end
-
-      describe '#skip' do
-        it "manufactures a skip relation" do
-          @relation.skip(4).should == Skip.new(@relation, 4)
-        end
-
-        describe 'when given a blank number of items' do
-          it 'returns self' do
-            @relation.skip.should == @relation
-          end
-        end
-      end
-
-      describe '#group' do
-        it 'manufactures a group relation' do
-          @relation.group(@attribute1, @attribute2).should == Group.new(@relation, @attribute1, @attribute2)
-        end
-
-        describe 'when given blank groupings' do
-          it 'returns self' do
-            @relation.group.should == @relation
-          end
-        end
-      end
-
-      describe Relation::Operable::Writable do
-        describe '#insert' do
-          it 'manufactures an insertion relation' do
-            Session.start do
-              record = {@relation[:name] => 'carl'}
-              mock(Session.new).create(Insert.new(@relation, record))
-              @relation.insert(record).should == @relation
-            end
-          end
-        end
-      end
-    end
-
-    describe Relation::Enumerable do
-      it "implements enumerable" do
-        @relation.collect.should == @relation.session.read(@relation)
-        @relation.first.should == @relation.session.read(@relation).first
-      end
-    end
-  end
-end
diff --git a/spec/arel/engines/sql/unit/relations/table_spec.rb b/spec/arel/engines/sql/unit/relations/table_spec.rb
index 6de49a9157..3f5a5ac248 100644
--- a/spec/arel/engines/sql/unit/relations/table_spec.rb
+++ b/spec/arel/engines/sql/unit/relations/table_spec.rb
@@ -6,36 +6,6 @@ module Arel
       @relation = Table.new(:users)
     end
 
-    describe '[]' do
-      describe 'when given a', Symbol do
-        it "manufactures an attribute if the symbol names an attribute within the relation" do
-          @relation[:id].should == Attribute.new(@relation, :id)
-          @relation[:does_not_exist].should be_nil
-        end
-      end
-
-      describe 'when given an', Attribute do
-        it "returns the attribute if the attribute is within the relation" do
-          @relation[@relation[:id]].should == @relation[:id]
-        end
-
-        it "returns nil if the attribtue is not within the relation" do
-          another_relation = Table.new(:photos)
-          @relation[another_relation[:id]].should be_nil
-        end
-      end
-
-      describe 'when given an', Expression do
-        before do
-          @expression = @relation[:id].count
-        end
-
-        it "returns the Expression if the Expression is within the relation" do
-          @relation[@expression].should be_nil
-        end
-      end
-    end
-
     describe '#to_sql' do
       it "manufactures a simple select query" do
         sql = @relation.to_sql
diff --git a/spec/arel/engines/sql/unit/relations/where_spec.rb b/spec/arel/engines/sql/unit/relations/where_spec.rb
index 5870b6b793..4f0cce1e01 100644
--- a/spec/arel/engines/sql/unit/relations/where_spec.rb
+++ b/spec/arel/engines/sql/unit/relations/where_spec.rb
@@ -7,14 +7,6 @@ module Arel
       @predicate = @relation[:id].eq(1)
     end
 
-    describe '#initialize' do
-      it "manufactures nested where relations if multiple predicates are provided" do
-        another_predicate = @relation[:name].lt(2)
-        Where.new(@relation, @predicate, another_predicate). \
-          should == Where.new(Where.new(@relation, another_predicate), @predicate)
-      end
-    end
-
     describe '#to_sql' do
       describe 'when given a predicate' do
         it "manufactures sql with where clause conditions" do
diff --git a/spec/arel/engines/sql/unit/session/session_spec.rb b/spec/arel/engines/sql/unit/session/session_spec.rb
deleted file mode 100644
index c489984a61..0000000000
--- a/spec/arel/engines/sql/unit/session/session_spec.rb
+++ /dev/null
@@ -1,84 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', '..', '..', '..', 'spec_helper')
-
-module Arel
-  describe Session do
-    before do
-      @relation = Table.new(:users)
-      @session = Session.new
-    end
-
-    describe '::start' do
-      describe '::instance' do
-        it "it is a singleton within the started session" do
-          Session.start do
-            Session.new.should == Session.new
-          end
-        end
-
-        it "is a singleton across nested sessions" do
-          Session.start do
-            outside = Session.new
-            Session.start do
-              Session.new.should == outside
-            end
-          end
-        end
-
-        it "manufactures new sessions outside of the started session" do
-          Session.new.should_not == Session.new
-        end
-      end
-    end
-
-    describe Session::CRUD do
-      before do
-        @insert = Insert.new(@relation, @relation[:name] => 'nick')
-        @update = Update.new(@relation, @relation[:name] => 'nick')
-        @delete = Deletion.new(@relation)
-        @read = @relation
-      end
-
-      describe '#create' do
-        it "executes an insertion on the connection" do
-          mock(@insert).call
-          @session.create(@insert)
-        end
-      end
-
-      describe '#read' do
-        it "executes an selection on the connection" do
-          mock(@read).call
-          @session.read(@read)
-        end
-
-        it "is memoized" do
-          mock(@read).call.once
-          @session.read(@read)
-          @session.read(@read)
-        end
-      end
-
-      describe '#update' do
-        it "executes an update on the connection" do
-          mock(@update).call
-          @session.update(@update)
-        end
-      end
-
-      describe '#delete' do
-        it "executes a delete on the connection" do
-          mock(@delete).call
-          @session.delete(@delete)
-        end
-      end
-    end
-
-    describe 'Transactions' do
-      describe '#begin' do
-      end
-
-      describe '#end' do
-      end
-    end
-  end
-end