aboutsummaryrefslogtreecommitdiffstats
path: root/spec
diff options
context:
space:
mode:
Diffstat (limited to 'spec')
-rw-r--r--spec/active_relation/predicates/binary_spec.rb7
-rw-r--r--spec/active_relation/primitives/attribute_spec.rb71
-rw-r--r--spec/active_relation/primitives/expression_spec.rb56
-rw-r--r--spec/active_relation/relations/join_spec.rb10
-rw-r--r--spec/active_relation/relations/table_spec.rb38
5 files changed, 127 insertions, 55 deletions
diff --git a/spec/active_relation/predicates/binary_spec.rb b/spec/active_relation/predicates/binary_spec.rb
index a6878e4898..5d1e7d1223 100644
--- a/spec/active_relation/predicates/binary_spec.rb
+++ b/spec/active_relation/predicates/binary_spec.rb
@@ -32,6 +32,13 @@ module ActiveRelation
should == ConcreteBinary.new(@attribute1.qualify, @attribute2.qualify)
end
end
+
+ describe '#substitute' do
+ it "distributes over the predicates and attributes" do
+ ConcreteBinary.new(@attribute1, @attribute2).substitute(@relation2). \
+ should == ConcreteBinary.new(@attribute1.substitute(@relation2), @attribute2.substitute(@relation2))
+ end
+ end
describe '#to_sql' do
it 'manufactures correct sql' do
diff --git a/spec/active_relation/primitives/attribute_spec.rb b/spec/active_relation/primitives/attribute_spec.rb
index 0c6c44f1f4..e79f0c994d 100644
--- a/spec/active_relation/primitives/attribute_spec.rb
+++ b/spec/active_relation/primitives/attribute_spec.rb
@@ -3,24 +3,28 @@ require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
module ActiveRelation
describe Attribute do
before do
- @relation1 = Table.new(:foo)
- @relation2 = Table.new(:bar)
+ @relation = Table.new(:users)
end
describe Attribute::Transformations do
before do
- @attribute = Attribute.new(@relation1, :id)
+ @attribute = Attribute.new(@relation, :id)
end
describe '#as' do
it "manufactures an aliased attributed" do
- @attribute.as(:alias).should == Attribute.new(@relation1, @attribute.name, :alias, @attribute)
+ @attribute.as(:alias).should == Attribute.new(@relation, @attribute.name, :alias, @attribute)
end
end
describe '#substitute' do
- it "manufactures an attribute with the relation substituted" do
- @attribute.substitute(@relation2).should == Attribute.new(@relation2, @attribute.name, nil, @attribute)
+ it "manufactures an attribute with the relation substituted and self as an ancestor" do
+ derived_relation = @relation.select(@relation[:id].equals(1))
+ @attribute.substitute(derived_relation).should == Attribute.new(derived_relation, @attribute.name, nil, @attribute)
+ end
+
+ it "returns self if the substituting to the same relation" do
+ @attribute.substitute(@relation).should == @attribute
end
end
@@ -39,110 +43,107 @@ module ActiveRelation
describe '#qualified_name' do
it "manufactures an attribute name prefixed with the relation's name" do
- Attribute.new(@relation1, :id).qualified_name.should == 'foo.id'
+ Attribute.new(@relation, :id).qualified_name.should == 'users.id'
end
end
-
- describe '==' do
- it "obtains if the relation and attribute name are identical" do
- Attribute.new(@relation1, :name).should == Attribute.new(@relation1, :name)
- Attribute.new(@relation1, :name).should_not == Attribute.new(@relation1, :another_name)
- Attribute.new(@relation1, :name).should_not == Attribute.new(@relation2, :name)
- Attribute.new(@relation1, :name).should_not == Expression.new(Attribute.new(@relation1, :name), "SUM")
+
+ describe '=~' do
+ it "obtains if the attributes are identical" do
+ Attribute.new(@relation, :name).should =~ Attribute.new(@relation, :name)
+ end
+
+ it "obtains if the attributes have an overlapping history" do
+ Attribute.new(@relation, :name, nil, Attribute.new(@relation, :name)).should =~ Attribute.new(@relation, :name)
+ Attribute.new(@relation, :name).should =~ Attribute.new(@relation, :name, nil, Attribute.new(@relation, :name))
end
end
describe '#to_sql' do
- it "needs to test prefix_for" do
- pending
- end
-
describe Sql::Strategy do
it "manufactures sql without an alias if the strategy is Predicate" do
- Attribute.new(@relation1, :name, :alias).to_sql(Sql::Predicate.new).should be_like("`foo`.`name`")
+ Attribute.new(@relation, :name, :alias).to_sql(Sql::Predicate.new).should be_like("`users`.`name`")
end
it "manufactures sql with an alias if the strategy is Projection" do
- Attribute.new(@relation1, :name, :alias).to_sql(Sql::Projection.new).should be_like("`foo`.`name` AS 'alias'")
+ Attribute.new(@relation, :name, :alias).to_sql(Sql::Projection.new).should be_like("`users`.`name` AS 'alias'")
end
end
end
describe Attribute::Predications do
before do
- @attribute1 = Attribute.new(@relation1, :name)
- @attribute2 = Attribute.new(@relation2, :name)
+ @attribute = Attribute.new(@relation, :name)
end
describe '#equals' do
it "manufactures an equality predicate" do
- @attribute1.equals(@attribute2).should == Equality.new(@attribute1, @attribute2)
+ @attribute.equals('name').should == Equality.new(@attribute, 'name')
end
end
describe '#less_than' do
it "manufactures a less-than predicate" do
- @attribute1.less_than(@attribute2).should == LessThan.new(@attribute1, @attribute2)
+ @attribute.less_than(10).should == LessThan.new(@attribute, 10)
end
end
describe '#less_than_or_equal_to' do
it "manufactures a less-than or equal-to predicate" do
- @attribute1.less_than_or_equal_to(@attribute2).should == LessThanOrEqualTo.new(@attribute1, @attribute2)
+ @attribute.less_than_or_equal_to(10).should == LessThanOrEqualTo.new(@attribute, 10)
end
end
describe '#greater_than' do
it "manufactures a greater-than predicate" do
- @attribute1.greater_than(@attribute2).should == GreaterThan.new(@attribute1, @attribute2)
+ @attribute.greater_than(10).should == GreaterThan.new(@attribute, 10)
end
end
describe '#greater_than_or_equal_to' do
- it "manufactures a greater-than or equal to predicate" do
- @attribute1.greater_than_or_equal_to(@attribute2).should == GreaterThanOrEqualTo.new(@attribute1, @attribute2)
+ it "manufactures a greater-than or equal-to predicate" do
+ @attribute.greater_than_or_equal_to(10).should == GreaterThanOrEqualTo.new(@attribute, 10)
end
end
describe '#matches' do
it "manufactures a match predicate" do
- @attribute1.matches(/.*/).should == Match.new(@attribute1, @attribute2)
+ @attribute.matches(/.*/).should == Match.new(@attribute, /.*/)
end
end
end
describe Attribute::Expressions do
before do
- @attribute1 = Attribute.new(@relation1, :name)
+ @attribute = Attribute.new(@relation, :name)
end
describe '#count' do
it "manufactures a count Expression" do
- @attribute1.count.should == Expression.new(@attribute1, "COUNT")
+ @attribute.count.should == Expression.new(@attribute, "COUNT")
end
end
describe '#sum' do
it "manufactures a sum Expression" do
- @attribute1.sum.should == Expression.new(@attribute1, "SUM")
+ @attribute.sum.should == Expression.new(@attribute, "SUM")
end
end
describe '#maximum' do
it "manufactures a maximum Expression" do
- @attribute1.maximum.should == Expression.new(@attribute1, "MAX")
+ @attribute.maximum.should == Expression.new(@attribute, "MAX")
end
end
describe '#minimum' do
it "manufactures a minimum Expression" do
- @attribute1.minimum.should == Expression.new(@attribute1, "MIN")
+ @attribute.minimum.should == Expression.new(@attribute, "MIN")
end
end
describe '#average' do
it "manufactures an average Expression" do
- @attribute1.average.should == Expression.new(@attribute1, "AVG")
+ @attribute.average.should == Expression.new(@attribute, "AVG")
end
end
end
diff --git a/spec/active_relation/primitives/expression_spec.rb b/spec/active_relation/primitives/expression_spec.rb
new file mode 100644
index 0000000000..d699dfded0
--- /dev/null
+++ b/spec/active_relation/primitives/expression_spec.rb
@@ -0,0 +1,56 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+module ActiveRelation
+ describe Expression do
+ before do
+ @relation = Table.new(:users)
+ @attribute = @relation[:id]
+ end
+
+ describe Expression::Transformations do
+ before do
+ @expression = Expression.new(@attribute, "COUNT")
+ end
+
+ describe '#substitute' do
+ it "manufactures an attribute with a substituted relation and self as the ancestor" do
+ derived_relation = @relation.select(@relation[:id] == 1)
+ @expression.substitute(derived_relation).should == Expression.new(@attribute.substitute(derived_relation), "COUNT", nil, @expression)
+ end
+
+ it "returns self if the substituting to the same relation" do
+ @expression.substitute(@relation).should == @expression
+ end
+ end
+
+ describe '#as' do
+ it "manufactures an aliased expression" do
+ @expression.as(:foo).should == Expression.new(@attribute, "COUNT", :foo, @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, nil, @expression)
+ end
+ end
+ end
+
+ describe '=~' do
+ it "obtains if the expressions are identical" do
+ Expression.new(@attribute, "COUNT").should =~ Expression.new(@attribute, "COUNT")
+ end
+
+ it "obtains if the expressions have an overlapping history" do
+ Expression.new(@attribute, "COUNT", nil, Expression.new(@attribute, "COUNT")).should =~ Expression.new(@attribute, "COUNT")
+ Expression.new(@attribute, "COUNT").should =~ Expression.new(@attribute, "COUNT", nil, Expression.new(@attribute, "COUNT"))
+ end
+ end
+
+ describe '#to_sql' do
+ it "manufactures sql with the expression and alias" do
+ Expression.new(@attribute, "COUNT", :alias).to_sql.should == "COUNT(`users`.`id`) AS `alias`"
+ end
+ end
+ end
+end \ No newline at end of file
diff --git a/spec/active_relation/relations/join_spec.rb b/spec/active_relation/relations/join_spec.rb
index 52915b62c7..2df349dcd3 100644
--- a/spec/active_relation/relations/join_spec.rb
+++ b/spec/active_relation/relations/join_spec.rb
@@ -77,12 +77,11 @@ module ActiveRelation
before do
@relation = Table.new(:users)
photos = Table.new(:photos)
- aggregate_relation = photos.aggregate(photos[:user_id], photos[:id].count).group(photos[:user_id])
- @aggregate_relation = aggregate_relation.rename(photos[:id].count, :cnt).as(:photo_count)
+ @aggregate_relation = photos.aggregate(photos[:user_id], photos[:id].count).group(photos[:user_id]).rename(photos[:id].count, :cnt).as(:photo_count)
@predicate = Equality.new(@aggregate_relation[:user_id], @relation[:id])
end
- describe 'with the expression on the right' do
+ describe 'with the aggregation on the right' do
it 'manufactures sql joining the left table to a derived table' do
Join.new("INNER JOIN", @relation, @aggregate_relation, @predicate).to_sql.should be_like("""
SELECT `users`.`name`, `users`.`id`, `photo_count`.`user_id`, `photo_count`.`cnt`
@@ -93,7 +92,7 @@ module ActiveRelation
end
end
- describe 'with the expression on the left' do
+ describe 'with the aggregation on the left' do
it 'manufactures sql joining the right table to a derived table' do
Join.new("INNER JOIN", @aggregate_relation, @relation, @predicate).to_sql.should be_like("""
SELECT `photo_count`.`user_id`, `photo_count`.`cnt`, `users`.`name`, `users`.`id`
@@ -104,8 +103,7 @@ module ActiveRelation
end
end
- it "keeps selects on the expression within the derived table" do
- pending
+ it "keeps selects on the aggregation within the derived table" do
Join.new("INNER JOIN", @relation, @aggregate_relation.select(@aggregate_relation[:user_id].equals(1)), @predicate).to_sql.should be_like("""
SELECT `users`.`name`, `users`.`id`, `photo_count`.`user_id`, `photo_count`.`cnt`
FROM `users`
diff --git a/spec/active_relation/relations/table_spec.rb b/spec/active_relation/relations/table_spec.rb
index 02e669a08b..e48d259fb8 100644
--- a/spec/active_relation/relations/table_spec.rb
+++ b/spec/active_relation/relations/table_spec.rb
@@ -3,39 +3,43 @@ require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
module ActiveRelation
describe Table do
before do
- @relation1 = Table.new(:users)
+ @table = Table.new(:users)
@relation2 = Table.new(:photos)
end
describe '[]' do
describe 'when given a', Symbol do
it "manufactures an attribute if the symbol names an attribute within the relation" do
- @relation1[:id].should == Attribute.new(@relation1, :id)
- @relation1[:does_not_exist].should be_nil
+ @table[:id].should == Attribute.new(@table, :id)
+ @table[: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
- @relation1[@relation1[:id]].should == @relation1[:id]
- @relation1[@relation2[:id]].should be_nil
+ @table[@table[:id]].should == @table[:id]
+ end
+
+ it "returns nil if the attribtue is not within the relation" do
+ another_relation = Table.new(:photos)
+ @table[another_relation[:id]].should be_nil
end
end
describe 'when given an', Expression do
before do
- @expression = Expression.new(Attribute.new(@relation1, :id), "COUNT")
+ @expression = Expression.new(Attribute.new(@table, :id), "COUNT")
end
it "returns the Expression if the Expression is within the relation" do
- @relation1[@expression].should be_nil
+ @table[@expression].should be_nil
end
end
end
describe '#to_sql' do
it "manufactures a simple select query" do
- @relation1.to_sql.should be_like("""
+ @table.to_sql.should be_like("""
SELECT `users`.`name`, `users`.`id`
FROM `users`
""")
@@ -43,23 +47,29 @@ module ActiveRelation
end
describe '#prefix_for' do
- it "always returns the table name" do
- @relation1.prefix_for(Attribute.new(@relation1, :id)).should == :users
+ it "returns the table name" do
+ @table.prefix_for(Attribute.new(@table, :id)).should == :users
+ end
+ end
+
+ describe '#aliased_prefix_for' do
+ it "returns the table name" do
+ @table.aliased_prefix_for(Attribute.new(@table, :id)).should == :users
end
end
describe '#attributes' do
it 'manufactures attributes corresponding to columns in the table' do
- @relation1.attributes.should == [
- Attribute.new(@relation1, :name),
- Attribute.new(@relation1, :id)
+ @table.attributes.should == [
+ Attribute.new(@table, :name),
+ Attribute.new(@table, :id)
]
end
end
describe '#qualify' do
it 'manufactures a rename relation with all attribute names qualified' do
- @relation1.qualify.should == Rename.new(@relation1, @relation1[:id] => 'users.id', @relation1[:name] => 'users.name')
+ @table.qualify.should == Rename.new(@table, @table[:name] => 'users.name', @table[:id] => 'users.id')
end
end
end
generated by cgit v1.2.3 (git 2.25.1) at 2025-03-15 21:09:17 +0000