axiom-optimizer 0.1.0 → 0.1.1

data/spec/unit/axiom/optimizer/algebra/intersection/empty_left/optimize_spec.rb

@@ -5,15 +5,15 @@ require 'spec_helper'
 describe Optimizer::Algebra::Intersection::EmptyLeft, '#optimize' do
   subject { object.optimize }
 
-  let(:header)   { Relation::Header.coerce([ [ :id, Integer ] ])       }
-  let(:left)     { Relation::Empty.new(header)                         }
-  let(:right)    { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
-  let(:relation) { left.intersect(right)                               }
-  let(:object)   { described_class.new(relation)                       }
+  let(:header)   { Relation::Header.coerce([[:id, Integer]])       }
+  let(:left)     { Relation::Empty.new(header)                     }
+  let(:right)    { Relation.new(header, LazyEnumerable.new([[1]])) }
+  let(:relation) { left.intersect(right)                           }
+  let(:object)   { described_class.new(relation)                   }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
-  it { should equal(left) }
+  it { should be(left) }
 end

data/spec/unit/axiom/optimizer/algebra/intersection/empty_right/optimize_spec.rb

@@ -5,15 +5,15 @@ require 'spec_helper'
 describe Optimizer::Algebra::Intersection::EmptyRight, '#optimize' do
   subject { object.optimize }
 
-  let(:header)   { Relation::Header.coerce([ [ :id, Integer ] ])       }
-  let(:left)     { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
-  let(:right)    { Relation::Empty.new(header)                         }
-  let(:relation) { left.intersect(right)                               }
-  let(:object)   { described_class.new(relation)                       }
+  let(:header)   { Relation::Header.coerce([[:id, Integer]])       }
+  let(:left)     { Relation.new(header, LazyEnumerable.new([[1]])) }
+  let(:right)    { Relation::Empty.new(header)                     }
+  let(:relation) { left.intersect(right)                           }
+  let(:object)   { described_class.new(relation)                   }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
-  it { should equal(right) }
+  it { should be(right) }
 end

data/spec/unit/axiom/optimizer/algebra/intersection/equal_operands/optimize_spec.rb

@@ -5,15 +5,15 @@ require 'spec_helper'
 describe Optimizer::Algebra::Intersection::EqualOperands, '#optimize' do
   subject { object.optimize }
 
-  let(:header)   { Relation::Header.coerce([ [ :id, Integer ] ])       }
-  let(:left)     { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
-  let(:right)    { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
-  let(:relation) { left.intersect(right)                               }
-  let(:object)   { described_class.new(relation)                       }
+  let(:header)   { Relation::Header.coerce([[:id, Integer]])       }
+  let(:left)     { Relation.new(header, LazyEnumerable.new([[1]])) }
+  let(:right)    { Relation.new(header, LazyEnumerable.new([[1]])) }
+  let(:relation) { left.intersect(right)                           }
+  let(:object)   { described_class.new(relation)                   }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
-  it { should equal(left) }
+  it { should be(left) }
 end

data/spec/unit/axiom/optimizer/algebra/join/disjoint_headers/optimizable_predicate_spec.rb

@@ -9,20 +9,20 @@ describe Optimizer::Algebra::Join::DisjointHeaders, '#optimizable?' do
   let(:object)   { described_class.new(relation) }
 
   before do
-    object.operation.should be_kind_of(Algebra::Join)
+    expect(object.operation).to be_kind_of(Algebra::Join)
   end
 
   context 'when left and right headers are disjoint' do
-    let(:left)  { Relation.new([ [ :id,       Integer ] ], LazyEnumerable.new([ [ 1 ] ])) }
-    let(:right) { Relation.new([ [ :other_id, Integer ] ], LazyEnumerable.new([ [ 1 ] ])) }
+    let(:left)  { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]]))       }
+    let(:right) { Relation.new([[:other_id, Integer]], LazyEnumerable.new([[1]])) }
 
     it { should be(true) }
   end
 
   context 'when left and right headers are not disjoint' do
-    let(:header) { [ [ :id, Integer ] ]                                }
-    let(:left)   { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
-    let(:right)  { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
+    let(:header) { [[:id, Integer]]                                }
+    let(:left)   { Relation.new(header, LazyEnumerable.new([[1]])) }
+    let(:right)  { Relation.new(header, LazyEnumerable.new([[1]])) }
 
     it { should be(false) }
   end

data/spec/unit/axiom/optimizer/algebra/join/disjoint_headers/optimize_spec.rb

@@ -5,18 +5,18 @@ require 'spec_helper'
 describe Optimizer::Algebra::Join::DisjointHeaders, '#optimize' do
   subject { object.optimize }
 
-  let(:left)     { Relation.new([ [ :id,       Integer ] ], LazyEnumerable.new([ [ 1 ] ])) }
-  let(:right)    { Relation.new([ [ :other_id, Integer ] ], LazyEnumerable.new([ [ 2 ] ])) }
-  let(:relation) { left.join(right)                                                        }
-  let(:object)   { described_class.new(relation)                                           }
+  let(:left)     { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]]))       }
+  let(:right)    { Relation.new([[:other_id, Integer]], LazyEnumerable.new([[2]])) }
+  let(:relation) { left.join(right)                                                }
+  let(:object)   { described_class.new(relation)                                   }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   it { should be_kind_of(Algebra::Product) }
 
-  its(:left) { should equal(left) }
+  its(:left) { should be(left) }
 
-  its(:right) { should equal(right) }
+  its(:right) { should be(right) }
 end

data/spec/unit/axiom/optimizer/algebra/join/equal_headers/optimizable_predicate_spec.rb

@@ -9,20 +9,20 @@ describe Optimizer::Algebra::Join::EqualHeaders, '#optimizable?' do
   let(:object)   { described_class.new(relation) }
 
   before do
-    object.operation.should be_kind_of(Algebra::Join)
+    expect(object.operation).to be_kind_of(Algebra::Join)
   end
 
   context 'when left and right headers are equal' do
-    let(:header) { Relation::Header.coerce([ [ :id, Integer ] ])       }
-    let(:left)   { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
-    let(:right)  { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
+    let(:header) { Relation::Header.coerce([[:id, Integer]])       }
+    let(:left)   { Relation.new(header, LazyEnumerable.new([[1]])) }
+    let(:right)  { Relation.new(header, LazyEnumerable.new([[1]])) }
 
     it { should be(true) }
   end
 
   context 'when left and right headers are not equal' do
-    let(:left)  { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new([ [ 1 ] ]))                                 }
-    let(:right) { Relation.new([ [ :id, Integer ], [ :name, String  ] ], LazyEnumerable.new([ [ 1, 'Dan Kubb' ] ])) }
+    let(:left)  { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]]))                              }
+    let(:right) { Relation.new([[:id, Integer], [:name, String]], LazyEnumerable.new([[1, 'Dan Kubb']])) }
 
     it { should be(false) }
   end

data/spec/unit/axiom/optimizer/algebra/join/equal_headers/optimize_spec.rb

@@ -5,19 +5,19 @@ require 'spec_helper'
 describe Optimizer::Algebra::Join::EqualHeaders, '#optimize' do
   subject { object.optimize }
 
-  let(:header)   { Relation::Header.coerce([ [ :id, Integer ] ])       }
-  let(:left)     { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
-  let(:right)    { Relation.new(header, LazyEnumerable.new([ [ 2 ] ])) }
-  let(:relation) { left.join(right)                                    }
-  let(:object)   { described_class.new(relation)                       }
+  let(:header)   { Relation::Header.coerce([[:id, Integer]])       }
+  let(:left)     { Relation.new(header, LazyEnumerable.new([[1]])) }
+  let(:right)    { Relation.new(header, LazyEnumerable.new([[2]])) }
+  let(:relation) { left.join(right)                                }
+  let(:object)   { described_class.new(relation)                   }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   it { should be_kind_of(Algebra::Intersection) }
 
-  its(:left) { should equal(left) }
+  its(:left) { should be(left) }
 
-  its(:right) { should equal(right) }
+  its(:right) { should be(right) }
 end

data/spec/unit/axiom/optimizer/algebra/join/materialized_left/optimizable_predicate_spec.rb

@@ -9,33 +9,33 @@ describe Optimizer::Algebra::Join::MaterializedLeft, '#optimizable?' do
   let(:object)   { described_class.new(relation) }
 
   before do
-    object.operation.should be_kind_of(Algebra::Join)
+    expect(object.operation).to be_kind_of(Algebra::Join)
   end
 
   context 'when the left is materialized and right is not a restriction' do
-    let(:left)  { Relation.new([ [ :id, Integer ], [ :name, String  ] ], [ [ 1, 'Dan Kubb' ] ])             }
-    let(:right) { Relation.new([ [ :id, Integer ], [ :age,  Integer ] ], LazyEnumerable.new([ [ 1, 35 ] ])) }
+    let(:left)  { Relation.new([[:id, Integer], [:name, String]], [[1, 'Dan Kubb']])             }
+    let(:right) { Relation.new([[:id, Integer], [:age, Integer]], LazyEnumerable.new([[1, 35]])) }
 
     it { should be(true) }
   end
 
   context 'when the left is materialized and right is a restriction not matching the left' do
-    let(:left)  { Relation.new([ [ :id, Integer ], [ :name, String  ] ], [ [ 1, 'Dan Kubb' ] ])                                           }
-    let(:right) { Relation.new([ [ :id, Integer ], [ :age,  Integer ] ], LazyEnumerable.new([ [ 1, 35 ] ])).restrict { |r| r.age.eq(35) } }
+    let(:left)  { Relation.new([[:id, Integer], [:name, String]], [[1, 'Dan Kubb']])                                           }
+    let(:right) { Relation.new([[:id, Integer], [:age, Integer]], LazyEnumerable.new([[1, 35]])).restrict { |r| r.age.eq(35) } }
 
     it { should be(true) }
   end
 
   context 'when the left is materialized and right is a restriction matching the left' do
-    let(:left)  { Relation.new([ [ :id, Integer ], [ :name, String  ] ], [ [ 1, 'Dan Kubb' ] ])                                         }
-    let(:right) { Relation.new([ [ :id, Integer ], [ :age,  Integer ] ], LazyEnumerable.new([ [ 1, 35 ] ])).restrict { |r| r.id.eq(1) } }
+    let(:left)  { Relation.new([[:id, Integer], [:name, String]], [[1, 'Dan Kubb']])                                         }
+    let(:right) { Relation.new([[:id, Integer], [:age, Integer]], LazyEnumerable.new([[1, 35]])).restrict { |r| r.id.eq(1) } }
 
     it { should be(false) }
   end
 
   context 'when the left is not materialized' do
-    let(:left)  { Relation.new([ [ :id, Integer ], [ :name, String  ] ], LazyEnumerable.new([ [ 1, 'Dan Kubb' ] ])) }
-    let(:right) { Relation.new([ [ :id, Integer ], [ :age,  Integer ] ], LazyEnumerable.new([ [ 1, 35         ] ])) }
+    let(:left)  { Relation.new([[:id, Integer], [:name, String]], LazyEnumerable.new([[1, 'Dan Kubb']])) }
+    let(:right) { Relation.new([[:id, Integer], [:age, Integer]], LazyEnumerable.new([[1, 35]]))         }
 
     it { should be(false) }
   end

data/spec/unit/axiom/optimizer/algebra/join/materialized_left/optimize_spec.rb

@@ -9,12 +9,12 @@ describe Optimizer::Algebra::Join::MaterializedLeft, '#optimize' do
   let(:object)   { described_class.new(relation) }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   context 'with no joined tuples' do
-    let(:left)  { Relation.new([ [ :id, Integer ],                    ], [])                 }
-    let(:right) { Relation.new([ [ :id, Integer ], [ :age,  Integer ] ], LazyEnumerable.new) }
+    let(:left)  { Relation.new([[:id, Integer]], [])                                  }
+    let(:right) { Relation.new([[:id, Integer], [:age, Integer]], LazyEnumerable.new) }
 
     it { should be_kind_of(Algebra::Join) }
 
@@ -24,32 +24,32 @@ describe Optimizer::Algebra::Join::MaterializedLeft, '#optimize' do
   end
 
   context 'with one joined tuple' do
-    let(:left)  { Relation.new([ [ :id, Integer ],                    ], [ [ 1 ] ])                         }
-    let(:right) { Relation.new([ [ :id, Integer ], [ :age,  Integer ] ], LazyEnumerable.new([ [ 1, 35 ] ])) }
+    let(:left)  { Relation.new([[:id, Integer]], [[1]])                                          }
+    let(:right) { Relation.new([[:id, Integer], [:age, Integer]], LazyEnumerable.new([[1, 35]])) }
 
     it { should be_kind_of(Algebra::Join) }
 
-    its(:left) { should equal(left) }
+    its(:left) { should be(left) }
 
     its(:right) { should eql(right.restrict { |r| r.id.eq(1) }) }
 
     it 'is not further optimizable' do
-      described_class.new(subject).should_not be_optimizable
+      expect(described_class.new(subject)).to_not be_optimizable
     end
   end
 
   context 'with two or more joined tuples' do
-    let(:left)  { Relation.new([ [ :id, Integer ],                    ], [ [ 1 ], [ 2 ] ])                             }
-    let(:right) { Relation.new([ [ :id, Integer ], [ :age,  Integer ] ], LazyEnumerable.new([ [ 1, 35 ], [ 2, 25 ] ])) }
+    let(:left)  { Relation.new([[:id, Integer]], [[1], [2]])                                              }
+    let(:right) { Relation.new([[:id, Integer], [:age, Integer]], LazyEnumerable.new([[1, 35], [2, 25]])) }
 
     it { should be_kind_of(Algebra::Join) }
 
-    its(:left) { should equal(left) }
+    its(:left) { should be(left) }
 
-    its(:right) { should eql(right.restrict { |r| r.id.include([ 1, 2 ]) }) }
+    its(:right) { should eql(right.restrict { |r| r.id.include([1, 2]) }) }
 
     it 'is not further optimizable' do
-      described_class.new(subject).should_not be_optimizable
+      expect(described_class.new(subject)).to_not be_optimizable
     end
   end
 end

data/spec/unit/axiom/optimizer/algebra/join/materialized_right/optimizable_predicate_spec.rb

@@ -9,33 +9,33 @@ describe Optimizer::Algebra::Join::MaterializedRight, '#optimizable?' do
   let(:object)   { described_class.new(relation) }
 
   before do
-    object.operation.should be_kind_of(Algebra::Join)
+    expect(object.operation).to be_kind_of(Algebra::Join)
   end
 
   context 'when the right is materialized and left is not a restriction' do
-    let(:left)  { Relation.new([ [ :id, Integer ], [ :name, String  ] ], LazyEnumerable.new([ [ 1, 'Dan Kubb' ] ])) }
-    let(:right) { Relation.new([ [ :id, Integer ], [ :age,  Integer ] ], [ [ 1, 35 ] ])                             }
+    let(:left)  { Relation.new([[:id, Integer], [:name, String]], LazyEnumerable.new([[1, 'Dan Kubb']])) }
+    let(:right) { Relation.new([[:id, Integer], [:age, Integer]], [[1, 35]])                             }
 
     it { should be(true) }
   end
 
   context 'when the right is materialized and left is a restriction not matching the right' do
-    let(:left)  { Relation.new([ [ :id, Integer ], [ :name, String  ] ], LazyEnumerable.new([ [ 1, 'Dan Kubb' ] ])).restrict { |r| r.name.eq('Dan Kubb') } }
-    let(:right) { Relation.new([ [ :id, Integer ], [ :age,  Integer ] ], [ [ 1, 35 ] ])                                                                    }
+    let(:left)  { Relation.new([[:id, Integer], [:name, String]], LazyEnumerable.new([[1, 'Dan Kubb']])).restrict { |r| r.name.eq('Dan Kubb') } }
+    let(:right) { Relation.new([[:id, Integer], [:age, Integer]], [[1, 35]])                                                                    }
 
     it { should be(true) }
   end
 
   context 'when the right is materialized and left is a restriction matching the right' do
-    let(:left)  { Relation.new([ [ :id, Integer ], [ :name, String  ] ], LazyEnumerable.new([ [ 1, 'Dan Kubb' ] ])).restrict { |r| r.id.eq(1) } }
-    let(:right) { Relation.new([ [ :id, Integer ], [ :age,  Integer ] ], [ [ 1, 35 ] ])                                                         }
+    let(:left)  { Relation.new([[:id, Integer], [:name, String]], LazyEnumerable.new([[1, 'Dan Kubb']])).restrict { |r| r.id.eq(1) } }
+    let(:right) { Relation.new([[:id, Integer], [:age, Integer]], [[1, 35]])                                                         }
 
     it { should be(false) }
   end
 
   context 'when the left is not materialized' do
-    let(:left)  { Relation.new([ [ :id, Integer ], [ :name, String  ] ], LazyEnumerable.new([ [ 1, 'Dan Kubb' ] ])) }
-    let(:right) { Relation.new([ [ :id, Integer ], [ :age,  Integer ] ], LazyEnumerable.new([ [ 1, 35         ] ])) }
+    let(:left)  { Relation.new([[:id, Integer], [:name, String]], LazyEnumerable.new([[1, 'Dan Kubb']])) }
+    let(:right) { Relation.new([[:id, Integer], [:age, Integer]], LazyEnumerable.new([[1, 35]]))         }
 
     it { should be(false) }
   end

data/spec/unit/axiom/optimizer/algebra/join/materialized_right/optimize_spec.rb

@@ -9,12 +9,12 @@ describe Optimizer::Algebra::Join::MaterializedRight, '#optimize' do
   let(:object)   { described_class.new(relation) }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   context 'with no joined tuples' do
-    let(:left)  { Relation.new([ [ :id, Integer ],                    ], LazyEnumerable.new) }
-    let(:right) { Relation.new([ [ :id, Integer ], [ :age,  Integer ] ], [])                 }
+    let(:left)  { Relation.new([[:id, Integer]], LazyEnumerable.new)  }
+    let(:right) { Relation.new([[:id, Integer], [:age, Integer]], []) }
 
     it { should be_kind_of(Algebra::Join) }
 
@@ -24,32 +24,32 @@ describe Optimizer::Algebra::Join::MaterializedRight, '#optimize' do
   end
 
   context 'with one joined tuple' do
-    let(:left)  { Relation.new([ [ :id, Integer ],                    ], LazyEnumerable.new([ [ 1 ] ])) }
-    let(:right) { Relation.new([ [ :id, Integer ], [ :age,  Integer ] ], [ [ 1, 35 ] ])                 }
+    let(:left)  { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]]))  }
+    let(:right) { Relation.new([[:id, Integer], [:age, Integer]], [[1, 35]]) }
 
     it { should be_kind_of(Algebra::Join) }
 
     its(:left) { should eql(left.restrict { |r| r.id.eq(1) }) }
 
-    its(:right) { should equal(right) }
+    its(:right) { should be(right) }
 
     it 'is not further optimizable' do
-      described_class.new(subject).should_not be_optimizable
+      expect(described_class.new(subject)).to_not be_optimizable
     end
   end
 
   context 'with two or more joined tuples' do
-    let(:left)  { Relation.new([ [ :id, Integer ],                    ], LazyEnumerable.new([ [ 1 ], [ 2 ] ])) }
-    let(:right) { Relation.new([ [ :id, Integer ], [ :age,  Integer ] ], [ [ 1, 35 ], [ 2, 25 ] ])             }
+    let(:left)  { Relation.new([[:id, Integer]], LazyEnumerable.new([[1], [2]]))      }
+    let(:right) { Relation.new([[:id, Integer], [:age, Integer]], [[1, 35], [2, 25]]) }
 
     it { should be_kind_of(Algebra::Join) }
 
-    its(:left) { should eql(left.restrict { |r| r.id.include([ 1, 2 ]) }) }
+    its(:left) { should eql(left.restrict { |r| r.id.include([1, 2]) }) }
 
-    its(:right) { should equal(right) }
+    its(:right) { should be(right) }
 
     it 'is not further optimizable' do
-      described_class.new(subject).should_not be_optimizable
+      expect(described_class.new(subject)).to_not be_optimizable
     end
   end
 end

data/spec/unit/axiom/optimizer/algebra/product/table_dee_left/optimizable_predicate_spec.rb

@@ -5,12 +5,12 @@ require 'spec_helper'
 describe Optimizer::Algebra::Product::TableDeeLeft, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:right)    { Relation.new([ [ :id, Integer  ] ], LazyEnumerable.new([ [ 1 ] ])) }
-  let(:relation) { left.product(right)                                                }
-  let(:object)   { described_class.new(relation)                                      }
+  let(:right)    { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]])) }
+  let(:relation) { left.product(right)                                       }
+  let(:object)   { described_class.new(relation)                             }
 
   before do
-    object.operation.should be_kind_of(Algebra::Product)
+    expect(object.operation).to be_kind_of(Algebra::Product)
   end
 
   context 'when the left operand is a table dee' do

data/spec/unit/axiom/optimizer/algebra/product/table_dee_left/optimize_spec.rb

@@ -5,14 +5,14 @@ require 'spec_helper'
 describe Optimizer::Algebra::Product::TableDeeLeft, '#optimize' do
   subject { object.optimize }
 
-  let(:left)     { TABLE_DEE                                                          }
-  let(:right)    { Relation.new([ [ :id, Integer  ] ], LazyEnumerable.new([ [ 1 ] ])) }
-  let(:relation) { left.product(right)                                                }
-  let(:object)   { described_class.new(relation)                                      }
+  let(:left)     { TABLE_DEE                                                 }
+  let(:right)    { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]])) }
+  let(:relation) { left.product(right)                                       }
+  let(:object)   { described_class.new(relation)                             }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
-  it { should equal(right) }
+  it { should be(right) }
 end

data/spec/unit/axiom/optimizer/algebra/product/table_dee_right/optimizable_predicate_spec.rb

@@ -5,12 +5,12 @@ require 'spec_helper'
 describe Optimizer::Algebra::Product::TableDeeRight, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:left)     { Relation.new([ [ :id, Integer  ] ], LazyEnumerable.new([ [ 1 ] ])) }
-  let(:relation) { left.product(right)                                                }
-  let(:object)   { described_class.new(relation)                                      }
+  let(:left)     { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]])) }
+  let(:relation) { left.product(right)                                       }
+  let(:object)   { described_class.new(relation)                             }
 
   before do
-    object.operation.should be_kind_of(Algebra::Product)
+    expect(object.operation).to be_kind_of(Algebra::Product)
   end
 
   context 'when the right operand is a table dee' do

data/spec/unit/axiom/optimizer/algebra/product/table_dee_right/optimize_spec.rb

@@ -5,14 +5,14 @@ require 'spec_helper'
 describe Optimizer::Algebra::Product::TableDeeRight, '#optimize' do
   subject { object.optimize }
 
-  let(:left)     { Relation.new([ [ :id, Integer  ] ], LazyEnumerable.new([ [ 1 ] ])) }
-  let(:right)    { TABLE_DEE                                                          }
-  let(:relation) { left.product(right)                                                }
-  let(:object)   { described_class.new(relation)                                      }
+  let(:left)     { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]])) }
+  let(:right)    { TABLE_DEE                                                 }
+  let(:relation) { left.product(right)                                       }
+  let(:object)   { described_class.new(relation)                             }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
-  it { should equal(left) }
+  it { should be(left) }
 end