veritas-optimizer 0.0.3 → 0.0.4

data/spec/unit/veritas/optimizer/algebra/restriction/tautology/optimizable_spec.rb

@@ -1,10 +1,12 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Optimizer::Algebra::Restriction::Tautology, '#optimizable?' do
   subject { object.optimizable? }
 
   let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each) }
-  let(:relation) { base.restrict(predicate)                           }
+  let(:relation) { base.restrict { predicate }                        }
   let(:object)   { described_class.new(relation)                      }
 
   before do
@@ -12,14 +14,20 @@ describe Optimizer::Algebra::Restriction::Tautology, '#optimizable?' do
   end
 
   context 'when the predicate is a tautology' do
-    let(:predicate) { Logic::Proposition::Tautology.instance }
+    let(:predicate) { Function::Proposition::Tautology.instance }
 
     it { should be(true) }
   end
 
   context 'when the predicate is not a tautology' do
-    let(:predicate) { Logic::Proposition::Contradiction.instance }
+    let(:predicate) { Function::Proposition::Contradiction.instance }
 
     it { should be(false) }
   end
+
+  context 'when the predicate is true' do
+    let(:predicate) { true }
+
+    it { should be(true) }
+  end
 end

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

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Optimizer::Algebra::Restriction::Tautology, '#optimize' do
@@ -5,8 +7,8 @@ describe Optimizer::Algebra::Restriction::Tautology, '#optimize' do
 
   let(:header)    { Relation::Header.new([ [ :id, Integer ] ]) }
   let(:base)      { Relation.new(header, [ [ 1 ] ].each)       }
-  let(:predicate) { Logic::Proposition::Tautology.instance     }
-  let(:relation)  { base.restrict(predicate)                   }
+  let(:predicate) { Function::Proposition::Tautology.instance  }
+  let(:relation)  { base.restrict { predicate }                }
   let(:object)    { described_class.new(relation)              }
 
   before do

data/spec/unit/veritas/optimizer/algebra/restriction/unoptimized_operand/optimizable_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Optimizer::Algebra::Restriction::UnoptimizedOperand, '#optimizable?' do
@@ -5,7 +7,7 @@ describe Optimizer::Algebra::Restriction::UnoptimizedOperand, '#optimizable?' do
 
   let(:header)   { Relation::Header.new([ [ :id, Integer ] ]) }
   let(:base)     { Relation.new(header, [ [ 1 ] ].each)       }
-  let(:relation) { operand.restrict(predicate)                }
+  let(:relation) { operand.restrict { predicate }             }
   let(:object)   { described_class.new(relation)              }
 
   before do
@@ -13,8 +15,8 @@ describe Optimizer::Algebra::Restriction::UnoptimizedOperand, '#optimizable?' do
   end
 
   context 'when the operand and predicate is optimizable' do
-    let(:predicate) { Logic::Connective::Negation.new(header[:id].eq(1)) }
-    let(:operand)   { base.rename({})                                    }
+    let(:predicate) { Function::Connective::Negation.new(header[:id].eq(1)) }
+    let(:operand)   { base.rename({})                                       }
 
     it { should be(true) }
   end
@@ -27,8 +29,8 @@ describe Optimizer::Algebra::Restriction::UnoptimizedOperand, '#optimizable?' do
   end
 
   context 'when the operand is not optimizable, but the predicate is optimizable' do
-    let(:predicate) { Logic::Connective::Negation.new(header[:id].eq(1)) }
-    let(:operand)   { base                                               }
+    let(:predicate) { Function::Connective::Negation.new(header[:id].eq(1)) }
+    let(:operand)   { base                                                  }
 
     it { should be(true) }
   end

data/spec/unit/veritas/optimizer/algebra/restriction/unoptimized_operand/optimize_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Optimizer::Algebra::Restriction::UnoptimizedOperand, '#optimize' do

data/spec/unit/veritas/optimizer/algebra/summarization/empty_operand/class_methods/extension_default_spec.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Summarization::EmptyOperand, '.extension_default' do
+  subject { object.extension_default(function) }
+
+  let(:object) { described_class }
+
+  context 'when the function has a default' do
+    let(:operand)  { mock('Operand')               }
+    let(:function) { Aggregate::Count.new(operand) }
+
+    it { should eql(0) }
+  end
+
+  context 'when the function does not have a default' do
+    let(:function) { proc {} }
+
+    it { should be_nil }
+  end
+end

data/spec/unit/veritas/optimizer/algebra/summarization/empty_operand/optimizable_spec.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Summarization::EmptyOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:header)        { Relation::Header.new([ [ :id, Integer ], [ :name, String ] ]) }
+  let(:base)          { Relation.new(header, [ [ 1, 'Dan Kubb' ] ].each)              }
+  let(:relation)      { operand.summarize(summarize_per) {}                           }
+  let(:summarize_per) { TABLE_DEE                                                     }
+  let(:object)        { described_class.new(relation)                                 }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Summarization)
+  end
+
+  context 'when the operand is empty' do
+    let(:operand) { base.restrict { false } }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is not empty' do
+    let(:operand) { base }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/algebra/summarization/empty_operand/optimize_spec.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Summarization::EmptyOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)        { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:base)          { Relation.new(header, [ [ 1 ] ].each)       }
+  let(:attribute)     { Attribute::Object.new(:test)               }
+  let(:operand)       { base.restrict { false }                    }
+  let(:summarize_per) { TABLE_DEE                                  }
+  let(:object)        { described_class.new(relation)              }
+
+  context 'when the function has a default' do
+    let(:relation) { operand.summarize(summarize_per) { |r| r.add(attribute, r[:id].count) } }
+
+    before do
+      object.should be_optimizable
+    end
+
+    it { should be_kind_of(Algebra::Extension) }
+
+    it { should_not equal(operand) }
+
+    its(:operand) { should equal(summarize_per) }
+
+    its(:extensions) { should == { attribute => 0 } }
+  end
+
+  context 'when the function does not have a default' do
+    let(:function) { lambda { |acc, tuple| 1 }                                           }
+    let(:relation) { operand.summarize(summarize_per) { |r| r.add(attribute, function) } }
+
+    before do
+      object.should be_optimizable
+    end
+
+    it { should be_kind_of(Algebra::Extension) }
+
+    it { should_not equal(operand) }
+
+    its(:operand) { should equal(summarize_per) }
+
+    its(:extensions) { should == { attribute => nil } }
+  end
+end

data/spec/unit/veritas/optimizer/algebra/summarization/empty_summarize_per/optimizable_spec.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Summarization::EmptySummarizePer, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:header)   { Relation::Header.new([ [ :id, Integer ], [ :name, String ] ]) }
+  let(:base)     { Relation.new(header, [ [ 1, 'Dan Kubb' ] ].each)              }
+  let(:operand)  { base                                                          }
+  let(:relation) { operand.summarize(summarize_per) {}                           }
+  let(:object)   { described_class.new(relation)                                 }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Summarization)
+  end
+
+  context 'when the summarize_per is empty' do
+    let(:summarize_per) { base.project([ :id ]).restrict { false } }
+
+    it { should be(true) }
+  end
+
+  context 'when the summarize_per is not empty' do
+    let(:summarize_per) { base.project([ :id ]) }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/algebra/summarization/empty_summarize_per/optimize_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Summarization::EmptySummarizePer, '#optimize' do
+  subject { object.optimize }
+
+  let(:header)        { Relation::Header.new([ [ :id, Integer ], [ :name, String ] ])             }
+  let(:base)          { Relation.new(header, [ [ 1, 'Dan Kubb' ] ].each)                          }
+  let(:attribute)     { Attribute::Object.new(:test)                                              }
+  let(:operand)       { base                                                                      }
+  let(:summarize_per) { base.project([ :id ]).restrict { false }                                  }
+  let(:relation)      { operand.summarize(summarize_per) { |r| r.add(attribute, r[:name].count) } }
+  let(:object)        { described_class.new(relation)                                             }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Relation::Empty) }
+
+  its(:header) { should == [ [ :id, Integer ], [ :test, Object ] ] }
+end

data/spec/unit/veritas/optimizer/algebra/summarization/order_operand/optimizable_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Summarization::OrderOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [].each) }
+  let(:relation) { operand.summarize([]) {}                    }
+  let(:object)   { described_class.new(relation)               }
+
+  context 'when operand is an order' do
+    let(:operand) { base.order }
+
+    it { should be(true) }
+  end
+
+  context 'when operand is not an order' do
+    let(:operand) { base }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/algebra/summarization/order_operand/optimize_spec.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Summarization::OrderOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [].each) }
+  let(:operand)  { base.order                                  }
+  let(:relation) { operand.summarize([]) {}                    }
+  let(:object)   { described_class.new(relation)               }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(Algebra::Summarization) }
+
+  its(:operand) { should equal(base) }
+
+  its(:summarizers) { should eql(relation.summarizers) }
+end

data/spec/unit/veritas/optimizer/algebra/summarization/summarize_per_spec.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Summarization, '#summarize_per' do
+  subject { object.summarize_per }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+  let(:relation) { base.summarize(summarize_per) {}              }
+  let(:object)   { described_class.new(relation)                 }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Summarization)
+  end
+
+  context 'when summarize_per is optimized' do
+    let(:summarize_per) { TABLE_DEE }
+
+    it { should equal(summarize_per) }
+  end
+
+  context 'when summarize_per is not not optimized' do
+   let(:summarize_per) { TABLE_DEE.rename({}) }
+
+    it { should_not equal(summarize_per) }
+
+    it { should equal(TABLE_DEE) }
+  end
+end

data/spec/unit/veritas/optimizer/algebra/summarization/summarizers_spec.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Algebra::Summarization, '#summarizers' do
+  subject { object.summarizers }
+
+  let(:base)          { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ])                    }
+  let(:attribute)     { Attribute::Object.new(:test)                                     }
+  let(:summarize_per) { TABLE_DEE                                                        }
+  let(:relation)      { base.summarize(summarize_per) { |r| r.add(attribute, function) } }
+  let(:object)        { described_class.new(relation)                                    }
+
+  before do
+    object.operation.should be_kind_of(Algebra::Summarization)
+  end
+
+  context 'when summarizers are optimized' do
+    let(:function) { base[:id].sum }
+
+    it { should eql(relation.summarizers) }
+  end
+
+  context 'when summarizers are not optimized' do
+    let(:function) { Aggregate::Sum.new(Function::Numeric::Absolute.new(1)) }
+
+    it { should_not equal(relation.summarizers) }
+
+    it { should eql(attribute => Aggregate::Sum.new(1)) }
+  end
+end

data/spec/unit/veritas/optimizer/algebra/summarization/unoptimized_operand/optimizable_spec.rb

@@ -1,26 +1,48 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Optimizer::Algebra::Summarization::UnoptimizedOperand, '#optimizable?' do
   subject { object.optimizable? }
 
-  let(:header)      { Relation::Header.new([ [ :id, Integer ] ])             }
-  let(:base)        { Relation.new(header, [ [ 1 ] ].each)                   }
-  let(:summarizers) { [ :text, lambda { |acc, tuple| 1 } ]                   }
-  let(:relation)    { operand.summarize(operand) { |r| r.add(*summarizers) } }
-  let(:object)      { described_class.new(relation)                          }
+  let(:header)    { Relation::Header.new([ [ :id, Integer ], [ :name, String ] ])       }
+  let(:base)      { Relation.new(header, [ [ 1, 'Dan Kubb' ] ].each)                    }
+  let(:attribute) { Attribute::Object.new(:test)                                        }
+  let(:relation)  { operand.summarize(summarize_per) { |r| r.add(attribute, function) } }
+  let(:object)    { described_class.new(relation)                                       }
 
   before do
     object.operation.should be_kind_of(Algebra::Summarization)
   end
 
   context 'when the operand is optimizable' do
-    let(:operand) { base.rename({}) }
+    let(:operand)       { base.rename({})       }
+    let(:summarize_per) { TABLE_DEE             }
+    let(:function)      { Aggregate::Sum.new(1) }
+
+    it { should be(true) }
+  end
+
+  context 'when summarize_per is optimizable' do
+    let(:operand)       { base                  }
+    let(:summarize_per) { TABLE_DEE.rename({})  }
+    let(:function)      { Aggregate::Sum.new(1) }
+
+    it { should be(true) }
+  end
+
+  context 'when summarizers are optimizable' do
+    let(:operand)       { base                                                   }
+    let(:summarize_per) { TABLE_DEE.rename({})                                   }
+    let(:function)      { Aggregate::Sum.new(Function::Numeric::Absolute.new(1)) }
 
     it { should be(true) }
   end
 
-  context 'when the operand is not optimizable' do
-    let(:operand) { base }
+  context 'when the operand, summarize_per and summarizers are not optimizable' do
+    let(:operand)       { base                  }
+    let(:summarize_per) { TABLE_DEE             }
+    let(:function)      { Aggregate::Sum.new(1) }
 
     it { should be(false) }
   end

data/spec/unit/veritas/optimizer/algebra/summarization/unoptimized_operand/optimize_spec.rb

@@ -1,15 +1,18 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Optimizer::Algebra::Summarization::UnoptimizedOperand, '#optimize' do
   subject { object.optimize }
 
-  let(:header)    { Relation::Header.new([ [ :id, Integer ] ])                    }
-  let(:base)      { Relation.new(header, [ [ 1 ] ].each)                          }
-  let(:attribute) { Attribute::Object.new(:text)                                  }
-  let(:function)  { lambda { |acc, tuple| 1 }                                     }
-  let(:operand)   { base.rename({})                                               }
-  let(:relation)  { operand.summarize(operand) { |r| r.add(attribute, function) } }
-  let(:object)    { described_class.new(relation)                                 }
+  let(:header)        { Relation::Header.new([ [ :id, Integer ] ])                          }
+  let(:base)          { Relation.new(header, [ [ 1 ] ].each)                                }
+  let(:attribute)     { Attribute::Object.new(:text)                                        }
+  let(:function)      { Aggregate::Sum.new(Function::Numeric::Absolute.new(1))              }
+  let(:operand)       { base.rename({})                                                     }
+  let(:summarize_per) { TABLE_DEE.project([])                                               }
+  let(:relation)      { operand.summarize(summarize_per) { |r| r.add(attribute, function) } }
+  let(:object)        { described_class.new(relation)                                       }
 
   before do
     object.should be_optimizable
@@ -21,7 +24,7 @@ describe Optimizer::Algebra::Summarization::UnoptimizedOperand, '#optimize' do
 
   its(:operand) { should equal(base) }
 
-  its(:summarize_by) { should equal(operand) }
+  its(:summarize_per) { should equal(TABLE_DEE) }
 
-  its(:summarizers) { should == { attribute => function } }
+  its(:summarizers) { pending { should == { attribute => Aggregate::Sum.new(1) } } }
 end

data/spec/unit/veritas/optimizer/algebra/union/empty_left/optimize_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Optimizer::Algebra::Union::EmptyLeft, '#optimize' do

data/spec/unit/veritas/optimizer/algebra/union/empty_right/optimize_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Optimizer::Algebra::Union::EmptyRight, '#optimize' do

data/spec/unit/veritas/optimizer/algebra/union/equal_operands/optimize_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Optimizer::Algebra::Union::EqualOperands, '#optimize' do

data/spec/unit/veritas/optimizer/class_methods/chain_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Optimizer, '.chain' do

data/spec/unit/veritas/optimizer/function/binary/constant_operands/optimizable_spec.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Binary::ConstantOperands, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:described_class) { Class.new(Optimizer) { include Optimizer::Function::Binary }                        }
+  let(:function)        { Class.new(Veritas::Function) { include Veritas::Function::Binary }.new(left, right) }
+  let(:object)          { described_class.new(function)                                                       }
+
+  before do
+    described_class.class_eval { include Optimizer::Function::Binary::ConstantOperands }
+  end
+
+  context 'when left and right are constants' do
+    let(:left)  { 1 }
+    let(:right) { 1 }
+
+    it { should be(true) }
+  end
+
+  context 'when left is a constant, and right is not a constant' do
+    let(:left)  { 1       }
+    let(:right) { proc {} }
+
+    it { should be(false) }
+  end
+
+  context 'when left is not a constant, and right is a constant' do
+    let(:left)  { proc {} }
+    let(:right) { 1       }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/function/binary/constant_operands/optimize_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Binary::ConstantOperands, '#optimize' do
+  subject { object.optimize }
+
+  let(:described_class) { Class.new(Optimizer) { include Optimizer::Function::Binary } }
+  let(:function)        { Function::Numeric::Addition.new(2, 2)                        }
+  let(:object)          { described_class.new(function)                                }
+
+  before do
+    described_class.class_eval { include Optimizer::Function::Binary::ConstantOperands }
+    object.should be_optimizable
+  end
+
+  it { should be(4) }
+end

data/spec/unit/veritas/optimizer/function/binary/left_spec.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Binary, '#left' do
+  subject { object.left }
+
+  let(:described_class) { Class.new(Optimizer) { include Optimizer::Function::Binary }                        }
+  let(:right)           { 'Right'                                                                             }
+  let(:function)        { Class.new(Veritas::Function) { include Veritas::Function::Binary }.new(left, right) }
+  let(:object)          { described_class.new(function)                                                       }
+
+  context 'when left operand is frozen' do
+    let(:left) { 'Left'.freeze }
+
+    it { should equal(left) }
+  end
+
+  context 'when left operand is not frozen' do
+    let(:left) { 'Left' }
+
+    it { should_not equal(left) }
+
+    it { should be_frozen }
+
+    it { should == left }
+  end
+end

data/spec/unit/veritas/optimizer/function/binary/right_spec.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Binary, '#right' do
+  subject { object.right }
+
+  let(:described_class) { Class.new(Optimizer) { include Optimizer::Function::Binary }                        }
+  let(:left)            { 'Left'                                                                              }
+  let(:function)        { Class.new(Veritas::Function) { include Veritas::Function::Binary }.new(left, right) }
+  let(:object)          { described_class.new(function)                                                       }
+
+  context 'when right operand is frozen' do
+    let(:right) { 'Right'.freeze }
+
+    it { should equal(right) }
+  end
+
+  context 'when right operand is not frozen' do
+    let(:right) { 'Right' }
+
+    it { should_not equal(right) }
+
+    it { should be_frozen }
+
+    it { should == right }
+  end
+end

data/spec/unit/veritas/optimizer/function/binary/unoptimized_operands/optimizable_spec.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Binary::UnoptimizedOperands, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:attribute)       { Attribute::Integer.new(:id)                                                         }
+  let(:described_class) { Class.new(Optimizer) { include Optimizer::Function::Binary }                        }
+  let(:function)        { Class.new(Veritas::Function) { include Veritas::Function::Binary }.new(left, right) }
+  let(:object)          { described_class.new(function)                                                       }
+
+  before do
+    described_class.class_eval { include Optimizer::Function::Binary::UnoptimizedOperands }
+  end
+
+  context 'when left is optimizable' do
+    let(:left)  { attribute.include([ 1 ]) }
+    let(:right) { attribute.ne(2)          }
+
+    it { should be(true) }
+  end
+
+  context 'when right is optimizable' do
+    let(:left)  { attribute.eq(1)          }
+    let(:right) { attribute.exclude([ 2 ]) }
+
+    it { should be(true) }
+  end
+
+  context 'when left and right are not optimizable' do
+    let(:left)  { attribute.eq(1) }
+    let(:right) { attribute.ne(2) }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/function/binary/unoptimized_operands/optimize_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Binary::UnoptimizedOperands, '#optimize' do
+  subject { object.optimize }
+
+  let(:described_class) { Class.new(Optimizer) { include Optimizer::Function::Binary }                        }
+  let(:attribute)       { Attribute::Integer.new(:id)                                                         }
+  let(:left)            { attribute.include([ 1 ])                                                            }
+  let(:right)           { attribute.exclude([ 2 ])                                                            }
+  let(:function)        { Class.new(Veritas::Function) { include Veritas::Function::Binary }.new(left, right) }
+  let(:object)          { described_class.new(function)                                                       }
+
+  before do
+    described_class.class_eval { include Optimizer::Function::Binary::UnoptimizedOperands }
+    object.should be_optimizable
+  end
+
+  its(:left) { should eql(attribute.eq(1)) }
+
+  its(:right) { should eql(attribute.ne(2)) }
+end