axiom-optimizer 0.1.0 → 0.1.1

data/spec/unit/axiom/optimizer/algebra/restriction/combination_operand/optimize_spec.rb

@@ -5,14 +5,14 @@ require 'spec_helper'
 describe Optimizer::Algebra::Restriction::CombinationOperand, '#optimize' do
   subject { object.optimize }
 
-  let(:left)     { Relation.new([ [ :id, Integer ], [ :user_name,     String ] ], LazyEnumerable.new([ [ 1, 'Dan Kubb' ] ])) }
-  let(:right)    { Relation.new([ [ :id, Integer ], [ :employee_name, String ] ], LazyEnumerable.new([ [ 2, 'Dan Kubb' ] ])) }
-  let(:operand)  { left.join(right)                                                                                          }
-  let(:relation) { operand.restrict { false }                                                                                }
-  let(:object)   { described_class.new(relation)                                                                             }
+  let(:left)     { Relation.new([[:id, Integer], [:user_name, String]], LazyEnumerable.new([[1, 'Dan Kubb']]))     }
+  let(:right)    { Relation.new([[:id, Integer], [:employee_name, String]], LazyEnumerable.new([[2, 'Dan Kubb']])) }
+  let(:operand)  { left.join(right)                                                                                }
+  let(:relation) { operand.restrict { false }                                                                      }
+  let(:object)   { described_class.new(relation)                                                                   }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   specify { expect { subject }.to raise_error(NotImplementedError, 'Axiom::Optimizer::Algebra::Restriction::CombinationOperand#relation_method must be implemented') }

data/spec/unit/axiom/optimizer/algebra/restriction/contradiction/optimizable_predicate_spec.rb

@@ -5,13 +5,13 @@ require 'spec_helper'
 describe Optimizer::Algebra::Restriction::Contradiction, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:header)   { Relation::Header.coerce([ [ :id, Integer ] ])       }
-  let(:base)     { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
-  let(:relation) { base.restrict { predicate }                         }
-  let(:object)   { described_class.new(relation)                       }
+  let(:header)   { Relation::Header.coerce([[:id, Integer]])       }
+  let(:base)     { Relation.new(header, LazyEnumerable.new([[1]])) }
+  let(:relation) { base.restrict { predicate }                     }
+  let(:object)   { described_class.new(relation)                   }
 
   before do
-    object.operation.should be_kind_of(Algebra::Restriction)
+    expect(object.operation).to be_kind_of(Algebra::Restriction)
   end
 
   context 'when the predicate is a contradiction' do

data/spec/unit/axiom/optimizer/algebra/restriction/contradiction/optimize_spec.rb

@@ -5,19 +5,17 @@ require 'spec_helper'
 describe Optimizer::Algebra::Restriction::Contradiction, '#optimize' do
   subject { object.optimize }
 
-  let(:header)    { Relation::Header.coerce([ [ :id, Integer ] ])       }
-  let(:base)      { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
-  let(:predicate) { Function::Proposition::Contradiction.instance       }
-  let(:relation)  { base.restrict { predicate }                         }
-  let(:object)    { described_class.new(relation)                       }
+  let(:header)    { Relation::Header.coerce([[:id, Integer]])       }
+  let(:base)      { Relation.new(header, LazyEnumerable.new([[1]])) }
+  let(:predicate) { Function::Proposition::Contradiction.instance   }
+  let(:relation)  { base.restrict { predicate }                     }
+  let(:object)    { described_class.new(relation)                   }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   it { should be_kind_of(Relation::Empty) }
 
-  its(:header) { should equal(header) }
-
-  its(:tuples) { should equal(relation) }
+  its(:header) { should be(header) }
 end

data/spec/unit/axiom/optimizer/algebra/restriction/join_operand/optimizable_predicate_spec.rb

@@ -5,13 +5,13 @@ require 'spec_helper'
 describe Optimizer::Algebra::Restriction::JoinOperand, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:left)     { Relation.new([ [ :id, Integer ], [ :user_name,     String ] ], LazyEnumerable.new([ [ 1, 'Dan Kubb' ] ])) }
-  let(:right)    { Relation.new([ [ :id, Integer ], [ :employee_name, String ] ], LazyEnumerable.new([ [ 2, 'Dan Kubb' ] ])) }
-  let(:relation) { operand.restrict { predicate }                                                                            }
-  let(:object)   { described_class.new(relation)                                                                             }
+  let(:left)     { Relation.new([[:id, Integer], [:user_name, String]], LazyEnumerable.new([[1, 'Dan Kubb']]))     }
+  let(:right)    { Relation.new([[:id, Integer], [:employee_name, String]], LazyEnumerable.new([[2, 'Dan Kubb']])) }
+  let(:relation) { operand.restrict { predicate }                                                                  }
+  let(:object)   { described_class.new(relation)                                                                   }
 
   before do
-    object.operation.should be_kind_of(Algebra::Restriction)
+    expect(object.operation).to be_kind_of(Algebra::Restriction)
   end
 
   context 'when the operand is a join operation and the predicate distributes to the left' do

data/spec/unit/axiom/optimizer/algebra/restriction/join_operand/optimize_spec.rb

@@ -5,18 +5,18 @@ require 'spec_helper'
 describe Optimizer::Algebra::Restriction::JoinOperand, '#optimize' do
   subject { object.optimize }
 
-  let(:left)                { Relation.new([ [ :id, Integer ], [ :user_name,     String ] ], LazyEnumerable.new([ [ 1, 'Dan Kubb' ] ])) }
-  let(:right)               { Relation.new([ [ :id, Integer ], [ :employee_name, String ] ], LazyEnumerable.new([ [ 2, 'Dan Kubb' ] ])) }
-  let(:operand)             { left.join(right)                                                                                          }
-  let(:left_predicate)      { left[:user_name].eq('Dan Kubb')                                                                           }
-  let(:right_predicate)     { right[:employee_name].eq('Dan Kubb')                                                                      }
-  let(:remainder_predicate) { left[:user_name].eq(right[:employee_name])                                                                }
-  let(:predicate)           { left_predicate.and(right_predicate).and(remainder_predicate)                                              }
-  let(:relation)            { operand.restrict { predicate }                                                                            }
-  let(:object)              { described_class.new(relation)                                                                             }
+  let(:left)                { Relation.new([[:id, Integer], [:user_name, String]], LazyEnumerable.new([[1, 'Dan Kubb']]))     }
+  let(:right)               { Relation.new([[:id, Integer], [:employee_name, String]], LazyEnumerable.new([[2, 'Dan Kubb']])) }
+  let(:operand)             { left.join(right)                                                                                }
+  let(:left_predicate)      { left[:user_name].eq('Dan Kubb')                                                                 }
+  let(:right_predicate)     { right[:employee_name].eq('Dan Kubb')                                                            }
+  let(:remainder_predicate) { left[:user_name].eq(right[:employee_name])                                                      }
+  let(:predicate)           { left_predicate.and(right_predicate).and(remainder_predicate)                                    }
+  let(:relation)            { operand.restrict { predicate }                                                                  }
+  let(:object)              { described_class.new(relation)                                                                   }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   it { should be_kind_of(Algebra::Restriction) }
@@ -25,24 +25,24 @@ describe Optimizer::Algebra::Restriction::JoinOperand, '#optimize' do
 
   it 'wraps the left operand of the join in a restriction' do
     left_operand = subject.operand.left
-    left_operand.operand.should equal(left)
-    left_operand.should be_kind_of(Algebra::Restriction)
+    expect(left_operand.operand).to be(left)
+    expect(left_operand).to be_kind_of(Algebra::Restriction)
   end
 
   it 'wraps the right operand of the join in a restriction' do
     right_operand = subject.operand.right
-    right_operand.operand.should equal(right)
-    right_operand.should be_kind_of(Algebra::Restriction)
+    expect(right_operand.operand).to be(right)
+    expect(right_operand).to be_kind_of(Algebra::Restriction)
   end
 
   it 'distributes the applicable part of the predicate to the left' do
-    subject.operand.left.predicate.should equal(left_predicate)
+    expect(subject.operand.left.predicate).to be(left_predicate)
   end
 
   it 'distributes the applicable part of the predicate to the right' do
-    subject.operand.right.predicate.should equal(right_predicate)
+    expect(subject.operand.right.predicate).to be(right_predicate)
   end
 
   # keeps the remainder that applies to the left and right
-  its(:predicate) { should equal(remainder_predicate) }
+  its(:predicate) { should be(remainder_predicate) }
 end

data/spec/unit/axiom/optimizer/algebra/restriction/order_operand/optimizable_predicate_spec.rb

@@ -5,13 +5,13 @@ require 'spec_helper'
 describe Optimizer::Algebra::Restriction::OrderOperand, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:base)      { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new([ [ 1 ] ])) }
-  let(:predicate) { base[:id].eq(1)                                                   }
-  let(:relation)  { operand.restrict { predicate }                                    }
-  let(:object)    { described_class.new(relation)                                     }
+  let(:base)      { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]])) }
+  let(:predicate) { base[:id].eq(1)                                           }
+  let(:relation)  { operand.restrict { predicate }                            }
+  let(:object)    { described_class.new(relation)                             }
 
   before do
-    object.operation.should be_kind_of(Algebra::Restriction)
+    expect(object.operation).to be_kind_of(Algebra::Restriction)
   end
 
   context 'when the operand is an order operation' do

data/spec/unit/axiom/optimizer/algebra/restriction/order_operand/optimize_spec.rb

@@ -5,18 +5,18 @@ require 'spec_helper'
 describe Optimizer::Algebra::Restriction::OrderOperand, '#optimize' do
   subject { object.optimize }
 
-  let(:base)      { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new([ [ 1 ] ])) }
-  let(:predicate) { base[:id].eq(1)                                                   }
-  let(:relation)  { base.sort_by { |r| r.id }.restrict { predicate }                  }
-  let(:object)    { described_class.new(relation)                                     }
+  let(:base)      { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]])) }
+  let(:predicate) { base[:id].eq(1)                                           }
+  let(:relation)  { base.sort_by { |r| r.id }.restrict { predicate }          }
+  let(:object)    { described_class.new(relation)                             }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   it { should be_kind_of(Algebra::Restriction) }
 
-  its(:operand) { should equal(base) }
+  its(:operand) { should be(base) }
 
-  its(:predicate) { should equal(predicate) }
+  its(:predicate) { should be(predicate) }
 end

data/spec/unit/axiom/optimizer/algebra/restriction/predicate_spec.rb

@@ -5,14 +5,14 @@ require 'spec_helper'
 describe Optimizer::Algebra::Restriction, '#predicate' do
   subject { object.predicate }
 
-  let(:base)      { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
-  let(:predicate) { base[:id].eq(1)                               }
-  let(:relation)  { base.restrict { predicate }                   }
-  let(:object)    { described_class.new(relation)                 }
+  let(:base)      { Relation.new([[:id, Integer]], [[1]]) }
+  let(:predicate) { base[:id].eq(1)                       }
+  let(:relation)  { base.restrict { predicate }           }
+  let(:object)    { described_class.new(relation)         }
 
   before do
-    object.operation.should be_kind_of(Algebra::Restriction)
+    expect(object.operation).to be_kind_of(Algebra::Restriction)
   end
 
-  it { should equal(predicate) }
+  it { should be(predicate) }
 end

data/spec/unit/axiom/optimizer/algebra/restriction/product_operand/optimizable_predicate_spec.rb

@@ -5,13 +5,13 @@ require 'spec_helper'
 describe Optimizer::Algebra::Restriction::ProductOperand, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:left)     { Relation.new([ [ :user_id,     Integer ], [ :user_name,     String ] ], LazyEnumerable.new([ [ 1, 'Dan Kubb' ] ])) }
-  let(:right)    { Relation.new([ [ :employee_id, Integer ], [ :employee_name, String ] ], LazyEnumerable.new([ [ 2, 'Dan Kubb' ] ])) }
-  let(:relation) { operand.restrict { predicate }                                                                                     }
-  let(:object)   { described_class.new(relation)                                                                                      }
+  let(:left)     { Relation.new([[:user_id, Integer], [:user_name, String]], LazyEnumerable.new([[1, 'Dan Kubb']]))         }
+  let(:right)    { Relation.new([[:employee_id, Integer], [:employee_name, String]], LazyEnumerable.new([[2, 'Dan Kubb']])) }
+  let(:relation) { operand.restrict { predicate }                                                                           }
+  let(:object)   { described_class.new(relation)                                                                            }
 
   before do
-    object.operation.should be_kind_of(Algebra::Restriction)
+    expect(object.operation).to be_kind_of(Algebra::Restriction)
   end
 
   context 'when the operand is a product operation and the predicate distributes to the left' do

data/spec/unit/axiom/optimizer/algebra/restriction/product_operand/optimize_spec.rb

@@ -5,18 +5,18 @@ require 'spec_helper'
 describe Optimizer::Algebra::Restriction::ProductOperand, '#optimize' do
   subject { object.optimize }
 
-  let(:left)                { Relation.new([ [ :user_id,     Integer ], [ :user_name,     String ] ], LazyEnumerable.new([ [ 1, 'Dan Kubb' ] ])) }
-  let(:right)               { Relation.new([ [ :employee_id, Integer ], [ :employee_name, String ] ], LazyEnumerable.new([ [ 2, 'Dan Kubb' ] ])) }
-  let(:operand)             { left.product(right)                                                                                                }
-  let(:left_predicate)      { left[:user_name].eq('Dan Kubb')                                                                                    }
-  let(:right_predicate)     { right[:employee_name].eq('Dan Kubb')                                                                               }
-  let(:remainder_predicate) { left[:user_name].eq(right[:employee_name])                                                                         }
-  let(:predicate)           { left_predicate.and(right_predicate).and(remainder_predicate)                                                       }
-  let(:relation)            { operand.restrict { predicate }                                                                                     }
-  let(:object)              { described_class.new(relation)                                                                                      }
+  let(:left)                { Relation.new([[:user_id, Integer], [:user_name, String]], LazyEnumerable.new([[1, 'Dan Kubb']]))         }
+  let(:right)               { Relation.new([[:employee_id, Integer], [:employee_name, String]], LazyEnumerable.new([[2, 'Dan Kubb']])) }
+  let(:operand)             { left.product(right)                                                                                      }
+  let(:left_predicate)      { left[:user_name].eq('Dan Kubb')                                                                          }
+  let(:right_predicate)     { right[:employee_name].eq('Dan Kubb')                                                                     }
+  let(:remainder_predicate) { left[:user_name].eq(right[:employee_name])                                                               }
+  let(:predicate)           { left_predicate.and(right_predicate).and(remainder_predicate)                                             }
+  let(:relation)            { operand.restrict { predicate }                                                                           }
+  let(:object)              { described_class.new(relation)                                                                            }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   it { should be_kind_of(Algebra::Restriction) }
@@ -25,24 +25,24 @@ describe Optimizer::Algebra::Restriction::ProductOperand, '#optimize' do
 
   it 'wraps the left operand of the product in a restriction' do
     left_operand = subject.operand.left
-    left_operand.operand.should equal(left)
-    left_operand.should be_kind_of(Algebra::Restriction)
+    expect(left_operand.operand).to be(left)
+    expect(left_operand).to be_kind_of(Algebra::Restriction)
   end
 
   it 'wraps the right operand of the product in a restriction' do
     right_operand = subject.operand.right
-    right_operand.operand.should equal(right)
-    right_operand.should be_kind_of(Algebra::Restriction)
+    expect(right_operand.operand).to be(right)
+    expect(right_operand).to be_kind_of(Algebra::Restriction)
   end
 
   it 'distributes the applicable part of the predicate to the left' do
-    subject.operand.left.predicate.should equal(left_predicate)
+    expect(subject.operand.left.predicate).to be(left_predicate)
   end
 
   it 'distributes the applicable part of the predicate to the right' do
-    subject.operand.right.predicate.should equal(right_predicate)
+    expect(subject.operand.right.predicate).to be(right_predicate)
   end
 
   # keeps the remainder that applies to the left and right
-  its(:predicate) { should equal(remainder_predicate) }
+  its(:predicate) { should be(remainder_predicate) }
 end

data/spec/unit/axiom/optimizer/algebra/restriction/restriction_operand/optimizable_predicate_spec.rb

@@ -5,18 +5,18 @@ require 'spec_helper'
 describe Optimizer::Algebra::Restriction::RestrictionOperand, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:header)    { Relation::Header.coerce([ [ :id, Integer ] ])       }
-  let(:base)      { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
-  let(:predicate) { header[:id].eq(1)                                   }
-  let(:relation)  { operand.restrict { predicate }                      }
-  let(:object)    { described_class.new(relation)                       }
+  let(:header)    { Relation::Header.coerce([[:id, Integer]])       }
+  let(:base)      { Relation.new(header, LazyEnumerable.new([[1]])) }
+  let(:predicate) { header[:id].eq(1)                               }
+  let(:relation)  { operand.restrict { predicate }                  }
+  let(:object)    { described_class.new(relation)                   }
 
   before do
-    object.operation.should be_kind_of(Algebra::Restriction)
+    expect(object.operation).to be_kind_of(Algebra::Restriction)
   end
 
   context 'when the operand is an restriction operation' do
-    let(:other_predicate) { header[:id].include([ 1 ])        }
+    let(:other_predicate) { header[:id].include([1])          }
     let(:operand)         { base.restrict { other_predicate } }
 
     it { should be(true) }

data/spec/unit/axiom/optimizer/algebra/restriction/restriction_operand/optimize_spec.rb

@@ -5,20 +5,20 @@ require 'spec_helper'
 describe Optimizer::Algebra::Restriction::RestrictionOperand, '#optimize' do
   subject { object.optimize }
 
-  let(:header)          { Relation::Header.coerce([ [ :id, Integer ] ])            }
-  let(:base)            { Relation.new(header, LazyEnumerable.new([ [ 1 ] ]))      }
+  let(:header)          { Relation::Header.coerce([[:id, Integer]])                }
+  let(:base)            { Relation.new(header, LazyEnumerable.new([[1]]))          }
   let(:predicate)       { header[:id].eq(1)                                        }
-  let(:other_predicate) { header[:id].include([ 1 ])                               }
+  let(:other_predicate) { header[:id].include([1])                                 }
   let(:relation)        { base.restrict { predicate }.restrict { other_predicate } }
   let(:object)          { described_class.new(relation)                            }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   it { should be_kind_of(Algebra::Restriction) }
 
-  its(:operand) { should equal(base) }
+  its(:operand) { should be(base) }
 
-  its(:predicate) { should equal(predicate) }
+  its(:predicate) { should be(predicate) }
 end

data/spec/unit/axiom/optimizer/algebra/restriction/set_operand/optimizable_predicate_spec.rb

@@ -5,15 +5,15 @@ require 'spec_helper'
 describe Optimizer::Algebra::Restriction::SetOperand, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:header)    { Relation::Header.coerce([ [ :id, Integer ] ])       }
-  let(:left)      { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
-  let(:right)     { Relation.new(header, LazyEnumerable.new([ [ 2 ] ])) }
-  let(:predicate) { header[:id].eq(1)                                   }
-  let(:relation)  { operand.restrict { predicate }                      }
-  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(:predicate) { header[:id].eq(1)                               }
+  let(:relation)  { operand.restrict { predicate }                  }
+  let(:object)    { described_class.new(relation)                   }
 
   before do
-    object.operation.should be_kind_of(Algebra::Restriction)
+    expect(object.operation).to be_kind_of(Algebra::Restriction)
   end
 
   context 'when the operand is a set operation' do

data/spec/unit/axiom/optimizer/algebra/restriction/set_operand/optimize_spec.rb

@@ -5,15 +5,15 @@ require 'spec_helper'
 describe Optimizer::Algebra::Restriction::SetOperand, '#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(:predicate) { header[:id].eq(1)                                   }
-  let(:relation)  { left.union(right).restrict { predicate }            }
-  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(:predicate) { header[:id].eq(1)                               }
+  let(:relation)  { left.union(right).restrict { predicate }        }
+  let(:object)    { described_class.new(relation)                   }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
   it { should be_kind_of(Relation::Operation::Set) }

data/spec/unit/axiom/optimizer/algebra/restriction/tautology/optimizable_predicate_spec.rb

@@ -5,12 +5,12 @@ require 'spec_helper'
 describe Optimizer::Algebra::Restriction::Tautology, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:base)     { Relation.new([ [ :id, Integer ] ], LazyEnumerable.new([ [ 1 ] ])) }
-  let(:relation) { base.restrict { predicate }                                       }
-  let(:object)   { described_class.new(relation)                                     }
+  let(:base)     { Relation.new([[:id, Integer]], LazyEnumerable.new([[1]])) }
+  let(:relation) { base.restrict { predicate }                               }
+  let(:object)   { described_class.new(relation)                             }
 
   before do
-    object.operation.should be_kind_of(Algebra::Restriction)
+    expect(object.operation).to be_kind_of(Algebra::Restriction)
   end
 
   context 'when the predicate is a tautology' do

data/spec/unit/axiom/optimizer/algebra/restriction/tautology/optimize_spec.rb

@@ -5,15 +5,15 @@ require 'spec_helper'
 describe Optimizer::Algebra::Restriction::Tautology, '#optimize' do
   subject { object.optimize }
 
-  let(:header)    { Relation::Header.coerce([ [ :id, Integer ] ])       }
-  let(:base)      { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
-  let(:predicate) { Function::Proposition::Tautology.instance           }
-  let(:relation)  { base.restrict { predicate }                         }
-  let(:object)    { described_class.new(relation)                       }
+  let(:header)    { Relation::Header.coerce([[:id, Integer]])       }
+  let(:base)      { Relation.new(header, LazyEnumerable.new([[1]])) }
+  let(:predicate) { Function::Proposition::Tautology.instance       }
+  let(:relation)  { base.restrict { predicate }                     }
+  let(:object)    { described_class.new(relation)                   }
 
   before do
-    object.should be_optimizable
+    expect(object).to be_optimizable
   end
 
-  it { should equal(base) }
+  it { should be(base) }
 end

data/spec/unit/axiom/optimizer/algebra/restriction/unoptimized_operand/optimizable_predicate_spec.rb

@@ -5,13 +5,13 @@ require 'spec_helper'
 describe Optimizer::Algebra::Restriction::UnoptimizedOperand, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:header)   { Relation::Header.coerce([ [ :id, Integer ] ])       }
-  let(:base)     { Relation.new(header, LazyEnumerable.new([ [ 1 ] ])) }
-  let(:relation) { operand.restrict { predicate }                      }
-  let(:object)   { described_class.new(relation)                       }
+  let(:header)   { Relation::Header.coerce([[:id, Integer]])       }
+  let(:base)     { Relation.new(header, LazyEnumerable.new([[1]])) }
+  let(:relation) { operand.restrict { predicate }                  }
+  let(:object)   { described_class.new(relation)                   }
 
   before do
-    object.operation.should be_kind_of(Algebra::Restriction)
+    expect(object.operation).to be_kind_of(Algebra::Restriction)
   end
 
   context 'when the operand and predicate is optimizable' do