veritas 0.0.4 → 0.0.5

data/spec/unit/veritas/relation/materialize_spec.rb

@@ -5,14 +5,14 @@ require 'spec_helper'
 describe Relation, '#materialize' do
   subject { object.materialize }
 
-  let(:header) { Relation::Header.new([ [ :id, Integer ] ])        }
-  let(:object) { described_class.new(header, [ [ 1 ] ].each).order }
+  let(:header) { Relation::Header.new([ [ :id, Integer ] ])                       }
+  let(:object) { described_class.new(header, [ [ 1 ] ].each).sort_by { |r| r.id } }
 
   before do
     object.should be_kind_of(described_class)
   end
 
-  it { should be_kind_of(Relation::Materialized) }
+  it { should be_instance_of(Relation::Materialized) }
 
   its(:header) { should equal(header) }
 

data/spec/unit/veritas/relation/materialized/class_methods/new_spec.rb

@@ -12,7 +12,7 @@ describe Relation::Materialized, '.new' do
 
     let(:directions) { [ header[:id] ] }
 
-    it { should be_kind_of(object) }
+    it { should be_instance_of(object) }
 
     its(:header) { should equal(header) }
 
@@ -24,7 +24,7 @@ describe Relation::Materialized, '.new' do
   context 'with no directions' do
     subject { object.new(header, tuples) }
 
-    it { should be_kind_of(object) }
+    it { should be_instance_of(object) }
 
     its(:header) { should equal(header) }
 

data/spec/unit/veritas/relation/materialized/materialized_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Materialized, '#materialized?' do
+  subject { object.materialized? }
+
+  let(:object) { described_class.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+
+  before do
+    object.should be_instance_of(described_class)
+  end
+
+  it { should be(true) }
+end

data/spec/unit/veritas/relation/materialized_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation, '#materialized?' do
+  subject { object.materialized? }
+
+  let(:object) { described_class.new([ [ :id, Integer ] ], [].each) }
+
+  before do
+    object.should be_instance_of(described_class)
+  end
+
+  it { should be(false) }
+end

data/spec/unit/veritas/relation/operation/binary/class_methods/new_spec.rb

@@ -11,21 +11,21 @@ require File.expand_path('../../fixtures/classes', __FILE__)
    let(:object)         { BinaryRelationOperationSpecs::Object                     }
 
    context 'with left and right ordered' do
-     let(:left)  { original_left.order  { |r| r[:id]   } }
-     let(:right) { original_right.order { |r| r[:name] } }
+     let(:left)  { original_left.sort_by  { |r| r.id   } }
+     let(:right) { original_right.sort_by { |r| r.name } }
 
-     it { should be_kind_of(object) }
+     it { should be_instance_of(object) }
    end
 
    context 'with left and right unordered' do
      let(:left)  { original_left  }
      let(:right) { original_right }
 
-     it { should be_kind_of(object) }
+     it { should be_instance_of(object) }
    end
 
    context 'with left ordered, and right unordered' do
-     let(:left)  { original_left.order { |r| r[:id] } }
+     let(:left)  { original_left.sort_by { |r| r.id } }
      let(:right) { original_right                     }
 
      specify { expect { subject }.to raise_error(RelationMismatchError, 'both relations must be ordered or neither may be ordered') }
@@ -33,7 +33,7 @@ require File.expand_path('../../fixtures/classes', __FILE__)
 
    context 'with right ordered, and left unordered' do
      let(:left)  { original_left                         }
-     let(:right) { original_right.order { |r| r[:name] } }
+     let(:right) { original_right.sort_by { |r| r.name } }
 
      specify { expect { subject }.to raise_error(RelationMismatchError, 'both relations must be ordered or neither may be ordered') }
    end

data/spec/unit/veritas/relation/operation/binary/header_spec.rb

@@ -13,7 +13,7 @@ describe Relation::Operation::Binary, '#header' do
 
   it_should_behave_like 'an idempotent method'
 
-  it { should be_kind_of(Relation::Header) }
+  it { should be_instance_of(Relation::Header) }
 
   it { should == [ [ :id, Integer ], [ :name, String ] ] }
 end

data/spec/unit/veritas/relation/operation/combination/header_spec.rb

@@ -13,7 +13,7 @@ describe Relation::Operation::Combination, '#header' do
 
   it_should_behave_like 'an idempotent method'
 
-  it { should be_kind_of(Relation::Header) }
+  it { should be_instance_of(Relation::Header) }
 
   it 'unions the headers' do
     should == [ [ :id, Integer ], [ :name, String ] ]

data/spec/unit/veritas/relation/operation/limit/class_methods/new_spec.rb

@@ -9,17 +9,17 @@ describe Relation::Operation::Limit, '.new' do
   let(:object)            { described_class                                      }
 
   context 'with an ordered relation' do
-    let(:relation) { original_relation.order { |r| r[:id] } }
+    let(:relation) { original_relation.sort_by { |r| r.id } }
     let(:limit)    { 1                                      }
 
-    it { should be_kind_of(object) }
+    it { should be_instance_of(object) }
   end
 
   context 'with an ordered relation having an empty header' do
-    let(:relation) { original_relation.order { |r| r[:id] }.project([]) }
+    let(:relation) { original_relation.sort_by { |r| r.id }.project([]) }
     let(:limit)    { 1                                                  }
 
-    it { should be_kind_of(object) }
+    it { should be_instance_of(object) }
   end
 
   context 'without an ordered relation' do
@@ -30,9 +30,16 @@ describe Relation::Operation::Limit, '.new' do
   end
 
   context 'with an limit less than 0' do
-    let(:relation) { original_relation.order { |r| r[:id] } }
+    let(:relation) { original_relation.sort_by { |r| r.id } }
     let(:limit)    { -1                                     }
 
     specify { expect { subject }.to raise_error(InvalidLimitError, 'limit must be greater than or equal to 0, but was -1') }
   end
+
+  context 'with a nil limit' do
+    let(:relation) { original_relation.sort_by { |r| r.id } }
+    let(:limit)    { nil                                    }
+
+    specify { expect { subject }.to raise_error(InvalidLimitError, 'limit must be greater than or equal to 0, but was nil') }
+  end
 end

data/spec/unit/veritas/relation/operation/limit/directions_spec.rb

@@ -7,7 +7,7 @@ describe Relation::Operation::Limit, '#directions' do
 
   let(:relation) { Relation.new([ [ :id, Integer ] ], [].each) }
   let(:object)   { described_class.new(ordered, 1)             }
-  let(:ordered)  { relation.order                              }
+  let(:ordered)  { relation.sort_by { |r| r.id }               }
 
   it_should_behave_like 'an idempotent method'
 

data/spec/unit/veritas/relation/operation/limit/each_spec.rb

@@ -6,7 +6,7 @@ describe Relation::Operation::Limit, '#each' do
   subject { object.each { |tuple| yields << tuple } }
 
   let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ], [ 3 ] ]) }
-  let(:order)    { relation.order                                              }
+  let(:order)    { relation.sort_by { |r| r.id }                               }
   let(:object)   { described_class.new(order, 1)                               }
   let(:yields)   { []                                                          }
 

data/spec/unit/veritas/relation/operation/limit/eql_spec.rb

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Relation::Operation::Limit, '#eql?' do
   subject { object.eql?(other) }
 
-  let(:operand) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ], [ 3 ] ]).order }
-  let(:limit)   { 1                                                                 }
-  let(:object)  { described_class.new(operand, limit)                               }
+  let(:operand) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ], [ 3 ] ]).sort_by { |r| r.id } }
+  let(:limit)   { 1                                                                                }
+  let(:object)  { described_class.new(operand, limit)                                              }
 
   context 'with the same object' do
     let(:other) { object }
@@ -15,7 +15,7 @@ describe Relation::Operation::Limit, '#eql?' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 
@@ -25,7 +25,7 @@ describe Relation::Operation::Limit, '#eql?' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 
@@ -35,19 +35,19 @@ describe Relation::Operation::Limit, '#eql?' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 
   context 'with an object having a different operand' do
-    let(:other_operand) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]).order }
-    let(:other_limit)   { limit                                                      }
-    let(:other)         { described_class.new(other_operand, other_limit)            }
+    let(:other_operand) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]).sort_by { |r| r.id } }
+    let(:other_limit)   { limit                                                                     }
+    let(:other)         { described_class.new(other_operand, other_limit)                           }
 
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 
@@ -59,7 +59,7 @@ describe Relation::Operation::Limit, '#eql?' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 end

data/spec/unit/veritas/relation/operation/limit/hash_spec.rb

@@ -6,7 +6,7 @@ describe Relation::Operation::Limit, '#hash' do
   subject { object.hash }
 
   let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ], [ 3 ] ]) }
-  let(:operand)  { relation.order                                              }
+  let(:operand)  { relation.sort_by { |r| r.id }                               }
   let(:limit)    { 1                                                           }
   let(:object)   { described_class.new(operand, limit)                         }
 

data/spec/unit/veritas/relation/operation/limit/limit_spec.rb

@@ -6,7 +6,7 @@ describe Relation::Operation::Limit, '#limit' do
   subject { object.limit }
 
   let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ], [ 3 ] ]) }
-  let(:order)    { relation.order                                              }
+  let(:order)    { relation.sort_by { |r| r.id }                               }
   let(:limit)    { 1                                                           }
   let(:object)   { described_class.new(order, limit)                           }
 

data/spec/unit/veritas/relation/operation/limit/methods/first_spec.rb

@@ -5,12 +5,12 @@ require 'spec_helper'
 describe Relation::Operation::Limit::Methods, '#first' do
   let(:described_class) { Relation                                                                }
   let(:relation)        { described_class.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ], [ 3 ] ].each) }
-  let(:object)          { relation.order                                                          }
+  let(:object)          { relation.sort_by { |r| r.id }                                           }
 
   context 'with no arguments' do
     subject { object.first }
 
-    it { should be_kind_of(Relation::Operation::Limit) }
+    it { should be_instance_of(Relation::Operation::Limit) }
 
     its(:limit) { should == 1 }
 
@@ -28,7 +28,7 @@ describe Relation::Operation::Limit::Methods, '#first' do
 
     let(:limit) { 2 }
 
-    it { should be_kind_of(Relation::Operation::Limit) }
+    it { should be_instance_of(Relation::Operation::Limit) }
 
     its(:limit) { should == limit }
 

data/spec/unit/veritas/relation/operation/limit/methods/last_spec.rb

@@ -5,12 +5,12 @@ require 'spec_helper'
 describe Relation::Operation::Limit::Methods, '#last' do
   let(:described_class) { Relation                                                                }
   let(:relation)        { described_class.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ], [ 3 ] ].each) }
-  let(:object)          { relation.order                                                          }
+  let(:object)          { relation.sort_by { |r| r.id }                                           }
 
   context 'with no arguments' do
     subject { object.last }
 
-    it { should be_kind_of(Relation::Operation::Reverse) }
+    it { should be_instance_of(Relation::Operation::Reverse) }
 
     it 'returns the expected tuples' do
       should == [ [ 3 ] ]
@@ -26,7 +26,7 @@ describe Relation::Operation::Limit::Methods, '#last' do
 
     let(:limit) { 2 }
 
-    it { should be_kind_of(Relation::Operation::Reverse) }
+    it { should be_instance_of(Relation::Operation::Reverse) }
 
     it 'returns the expected tuples' do
       should == [ [ 2 ], [ 3 ] ]

data/spec/unit/veritas/relation/operation/limit/methods/take_spec.rb

@@ -8,9 +8,9 @@ describe Relation::Operation::Limit::Methods, '#take' do
   let(:described_class) { Relation                                                         }
   let(:limit)           { 1                                                                }
   let(:relation)        { described_class.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ].each) }
-  let(:object)          { relation.order                                                   }
+  let(:object)          { relation.sort_by { |r| r.id }                                    }
 
-  it { should be_kind_of(Relation::Operation::Limit) }
+  it { should be_instance_of(Relation::Operation::Limit) }
 
   its(:limit) { should == limit }
 

data/spec/unit/veritas/relation/operation/offset/class_methods/new_spec.rb

@@ -9,17 +9,17 @@ describe Relation::Operation::Offset, '.new' do
   let(:object)            { described_class                                      }
 
   context 'with an ordered relation' do
-    let(:relation) { original_relation.order { |r| r[:id] } }
+    let(:relation) { original_relation.sort_by { |r| r.id } }
     let(:offset)   { 1                                      }
 
-    it { should be_kind_of(object) }
+    it { should be_instance_of(object) }
   end
 
   context 'with an ordered relation having an empty header' do
-    let(:relation) { original_relation.order { |r| r[:id] }.project([]) }
+    let(:relation) { original_relation.sort_by { |r| r.id }.project([]) }
     let(:offset)   { 1                                                  }
 
-    it { should be_kind_of(object) }
+    it { should be_instance_of(object) }
   end
 
   context 'without an ordered relation' do
@@ -30,9 +30,16 @@ describe Relation::Operation::Offset, '.new' do
   end
 
   context 'with an offset less than 0' do
-    let(:relation) { original_relation.order { |r| r[:id] } }
+    let(:relation) { original_relation.sort_by { |r| r.id } }
     let(:offset)   { -1                                     }
 
     specify { expect { subject }.to raise_error(InvalidOffsetError, 'offset must be greater than or equal to 0, but was -1') }
   end
+
+  context 'with a nil offset' do
+    let(:relation) { original_relation.sort_by { |r| r.id } }
+    let(:offset)   { nil                                    }
+
+    specify { expect { subject }.to raise_error(InvalidOffsetError, 'offset must be greater than or equal to 0, but was nil') }
+  end
 end

data/spec/unit/veritas/relation/operation/offset/directions_spec.rb

@@ -7,7 +7,7 @@ describe Relation::Operation::Offset, '#directions' do
 
   let(:relation) { Relation.new([ [ :id, Integer ] ], [].each) }
   let(:object)   { described_class.new(ordered, 0)             }
-  let(:ordered)  { relation.order                              }
+  let(:ordered)  { relation.sort_by { |r| r.id }               }
 
   it_should_behave_like 'an idempotent method'
 

data/spec/unit/veritas/relation/operation/offset/each_spec.rb

@@ -6,7 +6,7 @@ describe Relation::Operation::Offset, '#each' do
   subject { object.each { |tuple| yields << tuple } }
 
   let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ], [ 3 ] ]) }
-  let(:order)    { relation.order                                              }
+  let(:order)    { relation.sort_by { |r| r.id }                               }
   let(:object)   { described_class.new(order, 1)                               }
   let(:yields)   { []                                                          }
 

data/spec/unit/veritas/relation/operation/offset/eql_spec.rb

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Relation::Operation::Offset, '#eql?' do
   subject { object.eql?(other) }
 
-  let(:operand) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ], [ 3 ] ]).order }
-  let(:offset)  { 1                                                                 }
-  let(:object)  { described_class.new(operand, offset)                              }
+  let(:operand) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ], [ 3 ] ]).sort_by { |r| r.id } }
+  let(:offset)  { 1                                                                                }
+  let(:object)  { described_class.new(operand, offset)                                             }
 
   context 'with the same object' do
     let(:other) { object }
@@ -15,7 +15,7 @@ describe Relation::Operation::Offset, '#eql?' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 
@@ -25,7 +25,7 @@ describe Relation::Operation::Offset, '#eql?' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 
@@ -35,19 +35,19 @@ describe Relation::Operation::Offset, '#eql?' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 
   context 'with an object having a different operand' do
-    let(:other_operand) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]).order }
-    let(:other_offset)  { offset                                                     }
-    let(:other)         { described_class.new(other_operand, other_offset)           }
+    let(:other_operand) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]).sort_by { |r| r.id } }
+    let(:other_offset)  { offset                                                                    }
+    let(:other)         { described_class.new(other_operand, other_offset)                          }
 
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 
@@ -59,7 +59,7 @@ describe Relation::Operation::Offset, '#eql?' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 end

data/spec/unit/veritas/relation/operation/offset/hash_spec.rb

@@ -6,7 +6,7 @@ describe Relation::Operation::Offset, '#hash' do
   subject { object.hash }
 
   let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ], [ 3 ] ]) }
-  let(:operand)  { relation.order                                              }
+  let(:operand)  { relation.sort_by { |r| r.id }                               }
   let(:offset)   { 1                                                           }
   let(:object)   { described_class.new(operand, offset)                        }
 

data/spec/unit/veritas/relation/operation/offset/methods/drop_spec.rb

@@ -8,9 +8,9 @@ describe Relation::Operation::Offset::Methods, '#drop' do
   let(:described_class) { Relation                                                         }
   let(:offset)          { 1                                                                }
   let(:relation)        { described_class.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ].each) }
-  let(:object)          { relation.order                                                   }
+  let(:object)          { relation.sort_by { |r| r.id }                                    }
 
-  it { should be_kind_of(Relation::Operation::Offset) }
+  it { should be_instance_of(Relation::Operation::Offset) }
 
   its(:offset) { should == offset }
 

data/spec/unit/veritas/relation/operation/offset/offset_spec.rb

@@ -6,7 +6,7 @@ describe Relation::Operation::Offset, '#offset' do
   subject { object.offset }
 
   let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ], [ 3 ] ]) }
-  let(:order)    { relation.order                                              }
+  let(:order)    { relation.sort_by { |r| r.id }                               }
   let(:offset)   { 1                                                           }
   let(:object)   { described_class.new(order, offset)                          }
 

data/spec/unit/veritas/relation/operation/order/ascending/reverse_spec.rb

@@ -8,7 +8,7 @@ describe Relation::Operation::Order::Ascending, '#reverse' do
   let(:attribute) { Attribute::Integer.new(:id)    }
   let(:object)    { described_class.new(attribute) }
 
-  it { should be_kind_of(Relation::Operation::Order::Descending) }
+  it { should be_instance_of(Relation::Operation::Order::Descending) }
 
   its(:attribute) { should equal(attribute) }
 end

data/spec/unit/veritas/relation/operation/order/class_methods/new_spec.rb

@@ -13,7 +13,7 @@ describe Relation::Operation::Order, '.new' do
   context 'with all attributes specified in the directions' do
     let(:directions) { [ relation[:id], relation[:name] ] }
 
-    it { should be_kind_of(object) }
+    it { should be_instance_of(object) }
 
     its(:operand) { should equal(relation) }
 
@@ -23,15 +23,11 @@ describe Relation::Operation::Order, '.new' do
   context 'without no attributes specified in the directions' do
     let(:directions) { [] }
 
-    it { should be_kind_of(object) }
-
-    its(:operand) { should equal(relation) }
-
-    its(:directions) { should == [ relation[:id].asc, relation[:name].asc ] }
+    specify { expect { subject }.to raise_error(InvalidDirectionsError, 'directions must include every attribute in the header') }
   end
 
   context 'without all attributes specified in the directions' do
-    let(:directions) { [ :id ] }
+    let(:directions) { [ relation[:id] ] }
 
     specify { expect { subject }.to raise_error(InvalidDirectionsError, 'directions must include every attribute in the header') }
   end

data/spec/unit/veritas/relation/operation/order/descending/reverse_spec.rb

@@ -8,7 +8,7 @@ describe Relation::Operation::Order::Descending, '#reverse' do
   let(:attribute) { Attribute::Integer.new(:id)    }
   let(:object)    { described_class.new(attribute) }
 
-  it { should be_kind_of(Relation::Operation::Order::Ascending) }
+  it { should be_instance_of(Relation::Operation::Order::Ascending) }
 
   its(:attribute) { should equal(attribute) }
 end

data/spec/unit/veritas/relation/operation/order/direction/class_methods/coerce_spec.rb

@@ -17,7 +17,7 @@ describe Relation::Operation::Order::Direction, '.coerce' do
   context 'when the argument is an Attribute' do
     let(:argument) { attribute }
 
-    it { should be_kind_of(object) }
+    it { should be_instance_of(object) }
 
     its(:attribute) { should equal(attribute) }
   end

data/spec/unit/veritas/relation/operation/order/direction/eql_spec.rb

@@ -16,7 +16,7 @@ require 'spec_helper'
       it { should be(true) }
 
       it 'is symmetric' do
-        should == other.send(method, object)
+        should eql(other.send(method, object))
       end
     end
 
@@ -26,7 +26,7 @@ require 'spec_helper'
       it { should be(true) }
 
       it 'is symmetric' do
-        should == other.send(method, object)
+        should eql(other.send(method, object))
       end
     end
 
@@ -36,7 +36,7 @@ require 'spec_helper'
       it { should be(false) }
 
       it 'is symmetric' do
-        should == other.send(method, object)
+        should eql(other.send(method, object))
       end
     end
 
@@ -47,7 +47,7 @@ require 'spec_helper'
       it { should be(false) }
 
       it 'is symmetric' do
-        should == other.send(method, object)
+        should eql(other.send(method, object))
       end
     end
   end

data/spec/unit/veritas/relation/operation/order/direction/rename_spec.rb

@@ -13,7 +13,7 @@ describe Relation::Operation::Order::Direction, '#rename' do
   context 'with aliases matching the attribute' do
     let(:aliases) { Algebra::Rename::Aliases.coerce(header, :id => :other_id) }
 
-    it { should be_kind_of(described_class) }
+    it { should be_instance_of(described_class) }
 
     its(:attribute) { should == attribute.rename(:other_id) }
   end

data/spec/unit/veritas/relation/operation/order/direction_set/attributes_spec.rb

@@ -8,7 +8,7 @@ describe Relation::Operation::Order::DirectionSet, '#attributes' do
   let(:attribute) { Attribute::Integer.new(:id)        }
   let(:object)    { described_class.new([ attribute ]) }
 
-  it { should be_kind_of(Array) }
+  it { should be_instance_of(Array) }
 
   it { should == [ attribute ] }
 end

data/spec/unit/veritas/relation/operation/order/direction_set/class_methods/coerce_spec.rb

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Relation::Operation::Order::DirectionSet, '.coerce' do
   subject { object.coerce(argument) }
 
-  let(:directions)    { [ :id ]                }
-  let(:object)        { described_class        }
-  let(:direction_set) { object.new(directions) }
+  let(:directions)    { [ Attribute::Integer.new(:id) ] }
+  let(:object)        { described_class                 }
+  let(:direction_set) { object.new(directions)          }
 
   context 'when the argument is a DirectionSet' do
     let(:argument) { direction_set }
@@ -18,7 +18,7 @@ describe Relation::Operation::Order::DirectionSet, '.coerce' do
   context 'when the argument responds to #to_ary' do
     let(:argument) { directions }
 
-    it { should be_kind_of(object) }
+    it { should be_instance_of(object) }
 
     it { should == direction_set }
   end