veritas-optimizer 0.0.3 → 0.0.4

data/spec/unit/veritas/optimizer/{logic → function}/predicate/inclusion/empty_right_operand/optimize_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Predicate::Inclusion::EmptyRightOperand, '#optimize' do
+describe Optimizer::Function::Predicate::Inclusion::EmptyRightOperand, '#optimize' do
   subject { object.optimize }
 
   let(:attribute) { Attribute::Integer.new(:id)    }
@@ -14,30 +16,30 @@ describe Optimizer::Logic::Predicate::Inclusion::EmptyRightOperand, '#optimize'
   context 'when the operand contains a nil' do
     let(:operand) { nil }
 
-    it { should equal(Logic::Proposition::Contradiction.instance) }
+    it { should equal(Function::Proposition::Contradiction.instance) }
   end
 
   context 'when the operand contains an empty Enumerable' do
     let(:operand) { [] }
 
-    it { should equal(Logic::Proposition::Contradiction.instance) }
+    it { should equal(Function::Proposition::Contradiction.instance) }
   end
 
   context 'when the operand contains an empty inclusive Range' do
     let(:operand) { 1..0 }
 
-    it { should equal(Logic::Proposition::Contradiction.instance) }
+    it { should equal(Function::Proposition::Contradiction.instance) }
   end
 
   context 'when the operand contains an empty exclusive Range' do
     let(:operand) { 1...1 }
 
-    it { should equal(Logic::Proposition::Contradiction.instance) }
+    it { should equal(Function::Proposition::Contradiction.instance) }
   end
 
   context 'when the operand is empty after filtering invalid entries' do
     let(:operand) { [ 'a' ] }
 
-    it { should equal(Logic::Proposition::Contradiction.instance) }
+    it { should equal(Function::Proposition::Contradiction.instance) }
   end
 end

data/spec/unit/veritas/optimizer/{logic → function}/predicate/inclusion/one_right_operand/optimize_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Predicate::Inclusion::OneRightOperand, '#optimize' do
+describe Optimizer::Function::Predicate::Inclusion::OneRightOperand, '#optimize' do
   subject { object.optimize }
 
   let(:attribute) { Attribute::Integer.new(:id)    }
@@ -14,7 +16,7 @@ describe Optimizer::Logic::Predicate::Inclusion::OneRightOperand, '#optimize' do
   context 'when the operand contains a one entry Enumerable' do
     let(:operand) { [ 1 ] }
 
-    it { should be_kind_of(Logic::Predicate::Equality) }
+    it { should be_kind_of(Function::Predicate::Equality) }
 
     its(:left) { should equal(attribute) }
 
@@ -25,7 +27,7 @@ describe Optimizer::Logic::Predicate::Inclusion::OneRightOperand, '#optimize' do
   context 'when the operand contains a one entry inclusive Range' do
     let(:operand) { 1..1 }
 
-    it { should be_kind_of(Logic::Predicate::Equality) }
+    it { should be_kind_of(Function::Predicate::Equality) }
 
     its(:left) { should equal(attribute) }
 
@@ -35,7 +37,7 @@ describe Optimizer::Logic::Predicate::Inclusion::OneRightOperand, '#optimize' do
   context 'when the operand contains a one entry exclusive Range' do
     let(:operand) { 1...2 }
 
-    it { should be_kind_of(Logic::Predicate::Equality) }
+    it { should be_kind_of(Function::Predicate::Equality) }
 
     its(:left) { should equal(attribute) }
 
@@ -45,7 +47,7 @@ describe Optimizer::Logic::Predicate::Inclusion::OneRightOperand, '#optimize' do
   context 'when the operand contains one entry after filtering invalid entries' do
     let(:operand) { [ 'a', 1 ] }
 
-    it { should be_kind_of(Logic::Predicate::Equality) }
+    it { should be_kind_of(Function::Predicate::Equality) }
 
     its(:left) { should equal(attribute) }
 
@@ -55,7 +57,7 @@ describe Optimizer::Logic::Predicate::Inclusion::OneRightOperand, '#optimize' do
   context 'when the operand contains one entry after filtering duplicate entries' do
     let(:operand) { [ 1, 1 ] }
 
-    it { should be_kind_of(Logic::Predicate::Equality) }
+    it { should be_kind_of(Function::Predicate::Equality) }
 
     its(:left) { should equal(attribute) }
 

data/spec/unit/veritas/optimizer/{logic → function}/predicate/inequality/contradiction/optimizable_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Predicate::Inequality::Contradiction, '#optimizable?' do
+describe Optimizer::Function::Predicate::Inequality::Contradiction, '#optimizable?' do
   subject { object.optimizable? }
 
   let(:attribute) { Attribute::Integer.new(:id)    }
@@ -8,7 +10,7 @@ describe Optimizer::Logic::Predicate::Inequality::Contradiction, '#optimizable?'
   let(:object)    { described_class.new(predicate) }
 
   before do
-    predicate.should be_kind_of(Logic::Predicate::Inequality)
+    predicate.should be_kind_of(Function::Predicate::Inequality)
   end
 
   context 'when left and right are equal' do

data/spec/unit/veritas/optimizer/{logic → function}/predicate/less_than/contradiction/optimizable_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Predicate::LessThan::Contradiction, '#optimizable?' do
+describe Optimizer::Function::Predicate::LessThan::Contradiction, '#optimizable?' do
   subject { object.optimizable? }
 
   let(:attribute) { Attribute::Integer.new(:id)    }
@@ -8,7 +10,7 @@ describe Optimizer::Logic::Predicate::LessThan::Contradiction, '#optimizable?' d
   let(:object)    { described_class.new(predicate) }
 
   before do
-    predicate.should be_kind_of(Logic::Predicate::LessThan)
+    predicate.should be_kind_of(Function::Predicate::LessThan)
   end
 
   context 'when left and right are equal' do

data/spec/unit/veritas/optimizer/{logic → function}/predicate/less_than/tautology/optimizable_spec.rb

@@ -1,13 +1,15 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Predicate::LessThan::Tautology, '#optimizable?' do
+describe Optimizer::Function::Predicate::LessThan::Tautology, '#optimizable?' do
   subject { object.optimizable? }
 
   let(:predicate) { left.lt(right)                 }
   let(:object)    { described_class.new(predicate) }
 
   before do
-    predicate.should be_kind_of(Logic::Predicate::LessThan)
+    predicate.should be_kind_of(Function::Predicate::LessThan)
   end
 
   context 'when left is always less than right' do

data/spec/unit/veritas/optimizer/{logic → function}/predicate/less_than_or_equal_to/contradiction/optimizable_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Predicate::LessThanOrEqualTo::Contradiction, '#optimizable?' do
+describe Optimizer::Function::Predicate::LessThanOrEqualTo::Contradiction, '#optimizable?' do
   subject { object.optimizable? }
 
   let(:attribute) { Attribute::Integer.new(:id)    }
@@ -8,7 +10,7 @@ describe Optimizer::Logic::Predicate::LessThanOrEqualTo::Contradiction, '#optimi
   let(:object)    { described_class.new(predicate) }
 
   before do
-    predicate.should be_kind_of(Logic::Predicate::LessThanOrEqualTo)
+    predicate.should be_kind_of(Function::Predicate::LessThanOrEqualTo)
   end
 
   context 'when left and right are equal' do

data/spec/unit/veritas/optimizer/{logic → function}/predicate/less_than_or_equal_to/tautology/optimizable_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Predicate::LessThanOrEqualTo::Tautology, '#optimizable?' do
+describe Optimizer::Function::Predicate::LessThanOrEqualTo::Tautology, '#optimizable?' do
   subject { object.optimizable? }
 
   let(:attribute) { Attribute::Integer.new(:id)    }
@@ -8,7 +10,7 @@ describe Optimizer::Logic::Predicate::LessThanOrEqualTo::Tautology, '#optimizabl
   let(:object)    { described_class.new(predicate) }
 
   before do
-    predicate.should be_kind_of(Logic::Predicate::LessThanOrEqualTo)
+    predicate.should be_kind_of(Function::Predicate::LessThanOrEqualTo)
   end
 
   context 'when left and right are equal' do

data/spec/unit/veritas/optimizer/function/predicate/tautology/optimize_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Predicate::Tautology, '#optimize' do
+  subject { object.optimize }
+
+  let(:described_class) { Class.new(Optimizer) { include Optimizer::Function::Binary } }
+  let(:attribute)       { Attribute::Integer.new(:id)                                  }
+  let(:predicate)       { Function::Predicate::Equality.new(attribute, attribute)      }
+  let(:object)          { described_class.new(predicate)                               }
+
+  before do
+    described_class.class_eval { include Optimizer::Function::Predicate::Tautology }
+  end
+
+  it { should equal(Function::Proposition::Tautology.instance) }
+end

data/spec/unit/veritas/optimizer/function/unary/constant_operand/optimizable_spec.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Unary::ConstantOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:described_class) { Class.new(Optimizer) { include Optimizer::Function::Unary }                    }
+  let(:function)        { Class.new(Veritas::Function) { include Veritas::Function::Unary }.new(operand) }
+  let(:object)          { described_class.new(function)                                                  }
+
+  before do
+    described_class.class_eval { include Optimizer::Function::Unary::ConstantOperand }
+  end
+
+  context 'when the operand is a constant' do
+    let(:operand) { 1 }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is not a constant' do
+    let(:operand) { proc {} }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/function/unary/constant_operand/optimize_spec.rb

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

data/spec/unit/veritas/optimizer/function/unary/operand_spec.rb

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

data/spec/unit/veritas/optimizer/function/unary/unoptimized_operand/optimizable_spec.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Unary::UnoptimizedOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:described_class) { Class.new(Optimizer) { include Optimizer::Function::Unary }                    }
+  let(:function)        { Class.new(Veritas::Function) { include Veritas::Function::Unary }.new(operand) }
+  let(:object)          { described_class.new(function)                                                  }
+
+  before do
+    described_class.class_eval { include Optimizer::Function::Unary::UnoptimizedOperand }
+  end
+
+  context 'when the operand is optimizable' do
+    let(:operand) { Veritas::Function::Numeric::Absolute.new(1) }
+
+    it { should be(true) }
+  end
+
+  context 'when the operand is not optimizable' do
+    let(:operand) { 1 }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/function/unary/unoptimized_operand/optimize_spec.rb

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

data/spec/unit/veritas/optimizer/{logic/predicate → function}/util/class_methods/attribute_spec.rb

@@ -1,9 +1,11 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Predicate::Util, '.attribute?' do
+describe Optimizer::Function::Util, '.attribute?' do
   subject { object.attribute?(operand) }
 
-  let(:object) { Optimizer::Logic::Predicate::Util }
+  let(:object) { Optimizer::Function::Util }
 
   context 'with an attribute' do
     let(:operand) { Attribute::Integer.new(:id) }

data/spec/unit/veritas/optimizer/{logic/predicate → function}/util/class_methods/constant_spec.rb

@@ -1,9 +1,17 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Optimizer::Logic::Predicate::Util, '.constant?' do
+describe Optimizer::Function::Util, '.constant?' do
   subject { object.constant?(operand) }
 
-  let(:object) { Optimizer::Logic::Predicate::Util }
+  let(:object) { Optimizer::Function::Util }
+
+  context 'with a constant' do
+    let(:operand) { 1 }
+
+    it { should be(true) }
+  end
 
   context 'with an attribute' do
     let(:operand) { Attribute::Integer.new(:id) }
@@ -11,9 +19,9 @@ describe Optimizer::Logic::Predicate::Util, '.constant?' do
     it { should be(false) }
   end
 
-  context 'with a constant' do
-    let(:operand) { 1 }
+  context 'with a nil' do
+    let(:operand) { nil }
 
-    it { should be(true) }
+    it { should be(false) }
   end
 end

data/spec/unit/veritas/optimizer/function/util/class_methods/max_spec.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Util, '.max' do
+  subject { object.max(operand) }
+
+  let(:object) { Optimizer::Function::Util }
+
+  context 'with an Integer attribute' do
+    let(:operand) { Attribute::Integer.new(:id, :size => 1..10) }
+
+    it { should == 10 }
+  end
+
+  context 'with a String attribute' do
+    let(:operand) { Attribute::String.new(:id, :min_length => 1, :max_length => 10) }
+
+    it { should == 10 }
+  end
+
+  context 'with a constant' do
+    let(:operand) { 1 }
+
+    it { should == 1 }
+  end
+end

data/spec/unit/veritas/optimizer/function/util/class_methods/min_spec.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Function::Util, '.min' do
+  subject { object.min(operand) }
+
+  let(:object) { Optimizer::Function::Util }
+
+  context 'with an Integer attribute' do
+    let(:operand) { Attribute::Integer.new(:id, :size => 1..10) }
+
+    it { should == 1 }
+  end
+
+  context 'with a String attribute' do
+    let(:operand) { Attribute::String.new(:id, :min_length => 1, :max_length => 10) }
+
+    it { should == 1 }
+  end
+
+  context 'with a constat' do
+    let(:operand) { 1 }
+
+    it { should == 1 }
+  end
+end

data/spec/unit/veritas/optimizer/operation_spec.rb

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

data/spec/unit/veritas/optimizer/optimizable/class_methods/optimizer_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Optimizer::Optimizable::ClassMethods, '#optimizer' do

data/spec/unit/veritas/optimizer/optimizable/optimize_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Optimizer::Optimizable, '#optimize' do
@@ -13,7 +15,7 @@ describe Optimizer::Optimizable, '#optimize' do
   end
 
   context 'when there is an optimizer for the class' do
-    let(:optimized) { mock('Optimized')                     }
+    let(:optimized) { mock('Optimized', :frozen? => true)   }
     let(:optimizer) { mock('Optimizer', :call => optimized) }
 
     before do

data/spec/unit/veritas/optimizer/optimizable_spec.rb

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

data/spec/unit/veritas/optimizer/optimize_spec.rb

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

data/spec/unit/veritas/optimizer/relation/materialized/empty_operand/optimizable_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Optimizer::Relation::Materialized::EmptyOperand, '#optimizable?' do

data/spec/unit/veritas/optimizer/relation/materialized/empty_operand/optimize_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Optimizer::Relation::Materialized::EmptyOperand, '#optimize' do

data/spec/unit/veritas/optimizer/relation/operation/binary/empty_left/optimizable_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Optimizer::Relation::Operation::Binary::EmptyLeft, '#optimizable?' do
@@ -12,10 +14,6 @@ describe Optimizer::Relation::Operation::Binary::EmptyLeft, '#optimizable?' do
     described_class.class_eval { include superclass::EmptyLeft }
   end
 
-  before do
-    right.stub!(:optimize).and_return(right)
-  end
-
   context 'when left is empty' do
     let(:left) { Relation::Empty.new([ [ :id, Integer ] ]) }
 

data/spec/unit/veritas/optimizer/relation/operation/binary/empty_right/optimizable_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Optimizer::Relation::Operation::Binary::EmptyRight, '#optimizable?' do
@@ -12,10 +14,6 @@ describe Optimizer::Relation::Operation::Binary::EmptyRight, '#optimizable?' do
     described_class.class_eval { include superclass::EmptyRight }
   end
 
-  before do
-    left.stub!(:optimize).and_return(left)
-  end
-
   context 'when right is empty' do
     let(:right) { Relation::Empty.new([ [ :id, Integer ] ]) }
 

data/spec/unit/veritas/optimizer/relation/operation/binary/equal_operands/optimizable_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Optimizer::Relation::Operation::Binary::EqualOperands, '#optimizable?' do
@@ -13,11 +15,6 @@ describe Optimizer::Relation::Operation::Binary::EqualOperands, '#optimizable?'
     described_class.class_eval { include superclass::EqualOperands }
   end
 
-  before do
-    left.stub!(:optimize).and_return(left)
-    right.stub!(:optimize).and_return(right)
-  end
-
   context 'when left and right are equal' do
     let(:left)  { not_materialized }
     let(:right) { not_materialized }

data/spec/unit/veritas/optimizer/relation/operation/binary/left_order_operand/optimizable_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Binary::LeftOrderOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:relation) { mock('Relation', :left => left, :right => right) }
+  let(:right)    { mock('Right')                                    }
+  let(:object)   { described_class.new(relation)                    }
+
+  context 'when left is an order' do
+    let(:left) { Relation.new([ [ :id, Integer ] ], [].each).order }
+
+    it { should be(true) }
+  end
+
+  context 'when left is not an order' do
+    let(:left) { Relation.new([ [ :id, Integer ] ], [].each) }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/optimizer/relation/operation/binary/left_order_operand/optimize_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Binary::LeftOrderOperand, '#optimize' do
+  subject { object.optimize }
+
+  let(:base)     { Relation.new([ [ :id, Integer ] ], [].each) }
+  let(:left)     { base.order                                  }
+  let(:right)    { base                                        }
+  let(:relation) { left.union(right)                           }
+  let(:object)   { described_class.new(relation)               }
+
+  before do
+    object.should be_optimizable
+  end
+
+  it { should be_kind_of(relation.class) }
+
+  its(:left) { should equal(base) }
+
+  its(:right) { should equal(right) }
+end

data/spec/unit/veritas/optimizer/relation/operation/binary/left_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Optimizer::Relation::Operation::Binary, '#left' do
@@ -9,9 +11,5 @@ describe Optimizer::Relation::Operation::Binary, '#left' do
   let(:relation)  { mock('Relation', :left => left, :right => right) }
   let(:object)    { described_class.new(relation)                    }
 
-  before do
-    right.stub!(:optimize).and_return(right)
-  end
-
   it { should equal(optimized) }
 end

data/spec/unit/veritas/optimizer/relation/operation/binary/materialized_operand/optimizable_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Optimizer::Relation::Operation::Binary::MaterializedOperand, '#optimizable?' do

data/spec/unit/veritas/optimizer/relation/operation/binary/materialized_operand/optimize_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Optimizer::Relation::Operation::Binary::MaterializedOperand, '#optimize' do

data/spec/unit/veritas/optimizer/relation/operation/binary/right_order_operand/optimizable_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Optimizer::Relation::Operation::Binary::RightOrderOperand, '#optimizable?' do
+  subject { object.optimizable? }
+
+  let(:relation) { mock('Relation', :left => left, :right => right) }
+  let(:left)     { mock('Left')                                     }
+  let(:object)   { described_class.new(relation)                    }
+
+  context 'when right is an order' do
+    let(:right) { Relation.new([ [ :id, Integer ] ], [].each).order }
+
+    it { should be(true) }
+  end
+
+  context 'when right is not an order' do
+    let(:right) { Relation.new([ [ :id, Integer ] ], [].each) }
+
+    it { should be(false) }
+  end
+end