chrono_model 0.8.2 → 0.9.0

data/spec/json_ops_spec.rb

@@ -14,11 +14,11 @@ describe 'JSON equality operator' do
     ChronoModel::Json.drop
   end
 
-  it { adapter.select_value(%[ SELECT '{"a":1}'::json = '{"a":1}'::json ]).should == 't' }
-  it { adapter.select_value(%[ SELECT '{"a":1}'::json = '{"a" : 1}'::json ]).should == 't' }
-  it { adapter.select_value(%[ SELECT '{"a":1}'::json = '{"a":2}'::json ]).should == 'f' }
-  it { adapter.select_value(%[ SELECT '{"a":1,"b":2}'::json = '{"b":2,"a":1}'::json ]).should == 't' }
-  it { adapter.select_value(%[ SELECT '{"a":1,"b":2,"x":{"c":4,"d":5}}'::json = '{"b":2, "x": { "d": 5, "c": 4}, "a":1}'::json ]).should == 't' }
+  it { expect(adapter.select_value(%[ SELECT '{"a":1}'::json = '{"a":1}'::json ])).to eq 't' }
+  it { expect(adapter.select_value(%[ SELECT '{"a":1}'::json = '{"a" : 1}'::json ])).to eq 't' }
+  it { expect(adapter.select_value(%[ SELECT '{"a":1}'::json = '{"a":2}'::json ])).to eq 'f' }
+  it { expect(adapter.select_value(%[ SELECT '{"a":1,"b":2}'::json = '{"b":2,"a":1}'::json ])).to eq 't' }
+  it { expect(adapter.select_value(%[ SELECT '{"a":1,"b":2,"x":{"c":4,"d":5}}'::json = '{"b":2, "x": { "d": 5, "c": 4}, "a":1}'::json ])).to eq 't' }
 
   context 'on a temporal table' do
     before :all do

data/spec/spec_helper.rb

@@ -1,5 +1,8 @@
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 #
+require 'codeclimate-test-reporter'
+CodeClimate::TestReporter.start
+
 require 'chrono_model'
 
 require 'support/connection'
@@ -9,8 +12,6 @@ require 'support/matchers/column'
 require 'support/matchers/index'
 
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
-
   config.include(ChronoTest::Matchers::Schema)
   config.include(ChronoTest::Matchers::Table)
   config.include(ChronoTest::Matchers::Column)

data/spec/support/matchers/base.rb

@@ -1,7 +1,7 @@
-require 'ostruct'
-
 module ChronoTest::Matchers
   class Base
+    include ActiveRecord::Sanitization::ClassMethods
+
     attr_reader :table
 
     def matches?(table)
@@ -15,6 +15,7 @@ module ChronoTest::Matchers
     end
 
     protected
+
       def connection
         ChronoTest.connection
       end
@@ -46,13 +47,9 @@ module ChronoTest::Matchers
       end
 
     private
-      FooColumn = OpenStruct.new(:name => '')
-
       def exec_query(sql, binds, name)
-        binds.map! do |col, val|
-          val ? [col, val] : [FooColumn, col]
-        end
-        connection.exec_query(sql, name, binds)
+        sql = sanitize_sql_array([ sql, *Array.wrap(binds) ])
+        connection.exec_query(sql, name)
       end
   end
 

data/spec/support/matchers/column.rb

@@ -21,25 +21,38 @@ module ChronoTest::Matchers
         @matches.values.all?
       end
 
-      def failure_message_for_should
-        "expected #{@schema}.#{table} to have ".tap do |message|
-          message << @matches.map do |(name, type), match|
-            "a #{name}(#{type}) column" unless match
-          end.compact.to_sentence
-        end
+      def failure_message
+        message_matches("expected #{@schema}.#{table} to have")
+      end
+
+      def failure_message_when_negated
+        message_matches("expected #{@schema}.#{table} to not have")
       end
 
       protected
         def has_column?(name, type)
+          column_type(name) == [name, type]
+        end
+
+        def column_type(name)
           table = "#{@schema}.#{self.table}"
 
-          select_rows(<<-SQL, [table, name], 'Check column').first == [name, type]
+          select_rows(<<-SQL, [table, name], 'Check column').first
             SELECT attname, FORMAT_TYPE(atttypid, atttypmod)
               FROM pg_attribute
-             WHERE attrelid = $1::regclass::oid
-               AND attname = $2
+             WHERE attrelid = ?::regclass::oid
+               AND attname = ?
           SQL
         end
+
+      private
+        def message_matches(message)
+          (message << ' ').tap do |message|
+            message << @matches.map do |(name, type), match|
+              "a #{name}(#{type}) column" unless match
+            end.compact.to_sentence
+          end
+        end
     end
 
     def have_columns(*args)

data/spec/support/matchers/index.rb

@@ -24,18 +24,22 @@ module ChronoTest::Matchers
             JOIN pg_class i ON i.oid = d.indexrelid
             JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(d.indkey)
            WHERE i.relkind = 'i'
-             AND t.relname = $1
-             AND i.relname = $2
+             AND t.relname = ?
+             AND i.relname = ?
              AND i.relnamespace = (
-              SELECT oid FROM pg_namespace WHERE nspname = $3
+              SELECT oid FROM pg_namespace WHERE nspname = ?
             )
            ORDER BY a.attname
         SQL
       end
 
-      def failure_message_for_should
+      def failure_message
         "expected #{schema}.#{table} to have a #{name} index on #{columns}"
       end
+
+      def failure_message_when_negated
+        "expected #{schema}.#{table} to not have a #{name} index on #{columns}"
+      end
     end
 
     def have_index(*args)

data/spec/support/matchers/schema.rb

@@ -14,10 +14,14 @@ module ChronoTest::Matchers
         'be in schema'
       end
 
-      def failure_message_for_should
+      def failure_message
         "expected to be in schema #@expected, but was in #@current"
       end
 
+      def failure_message_when_negated
+        "expected to be in schema #@current, but was in #@expected"
+      end
+
       def matches?(*)
         @current = select_value(<<-SQL, [], 'Current schema')
           SHOW search_path

data/spec/support/matchers/table.rb

@@ -18,8 +18,8 @@ module ChronoTest::Matchers
                 FROM pg_class c
                 LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
                WHERE c.relkind = '#{kind}'
-                 AND c.relname = $1
-                 AND n.nspname = $2
+                 AND c.relname = ?
+                 AND n.nspname = ?
             )
           SQL
         end
@@ -39,9 +39,13 @@ module ChronoTest::Matchers
         'be in the public schema'
       end
 
-      def failure_message_for_should
+      def failure_message
         "expected #{table} to exist in the #{public_schema} schema"
       end
+
+      def failure_message_when_negated
+        "expected #{table} to not exist in the #{public_schema} schema"
+      end
     end
 
     def have_public_backing
@@ -63,9 +67,13 @@ module ChronoTest::Matchers
         'be in the temporal schema'
       end
 
-      def failure_message_for_should
+      def failure_message
         "expected #{table} to exist in the #{temporal_schema} schema"
       end
+
+      def failure_message_when_negated
+        "expected #{table} to not exist in the #{temporal_schema} schema"
+      end
     end
 
     def have_temporal_backing
@@ -91,7 +99,7 @@ module ChronoTest::Matchers
         'be in history schema'
       end
 
-      def failure_message_for_should
+      def failure_message
         "expected #{table} ".tap do |message|
           message << [
             ("to exist in the #{history_schema} schema"    unless @existance),
@@ -102,6 +110,17 @@ module ChronoTest::Matchers
         end
       end
 
+      def failure_message_when_negated
+        "expected #{table} ".tap do |message|
+          message << [
+            ("to not exist in the #{history_schema} schema"    if @existance),
+            ("to not inherit from #{temporal_schema}.#{table}" if @inheritance),
+            ("to not have a timeline consistency constraint"   if @constraint),
+            ("to not have history indexes"                     if @indexes)
+          ].compact.to_sentence
+        end
+      end
+
       private
         def table_exists?
           @existance = relation_exists? :in => history_schema
@@ -113,8 +132,8 @@ module ChronoTest::Matchers
           @inheritance = select_value(<<-SQL, binds, 'Check inheritance') == 't'
             SELECT EXISTS (
               SELECT 1 FROM pg_catalog.pg_inherits
-               WHERE inhrelid  = $1::regclass::oid
-                 AND inhparent = $2::regclass::oid
+               WHERE inhrelid  = ?::regclass::oid
+                 AND inhparent = ?::regclass::oid
             )
           SQL
         end
@@ -124,8 +143,8 @@ module ChronoTest::Matchers
 
           indexes = select_values(<<-SQL, binds, 'Check history indexes')
             SELECT indexdef FROM pg_indexes
-             WHERE schemaname = $1
-               AND tablename  = $2
+             WHERE schemaname = ?
+               AND tablename  = ?
           SQL
 
           fqtn = [history_schema, table].join('.')
@@ -146,26 +165,26 @@ module ChronoTest::Matchers
         end
 
         def has_consistency_constraint?
-          binds = [
-            connection.timeline_consistency_constraint_name(table), # conname
-            history_schema,                                         # connamespace
-            [history_schema, table].join('.'),                      # conrelid, attrelid
-            connection.primary_key(table)                           # attnum
-          ]
+          binds = {
+            conname:      connection.timeline_consistency_constraint_name(table),
+            connamespace: history_schema,
+            conrelid:     [history_schema, table].join('.'),
+            attname:      connection.primary_key(table)
+          }
 
           @constraint = select_value(<<-SQL, binds, 'Check Consistency Constraint') == 't'
             SELECT EXISTS (
               SELECT 1 FROM pg_catalog.pg_constraint
-              WHERE conname = $1
+              WHERE conname = :conname
                 AND contype = 'x'
-                AND conrelid = $3::regclass
+                AND conrelid = :conrelid::regclass
                 AND connamespace = (
-                  SELECT oid FROM pg_catalog.pg_namespace WHERE nspname = $2
+                  SELECT oid FROM pg_catalog.pg_namespace WHERE nspname = :connamespace
                 )
                 AND conkey = (
                   SELECT array_agg(attnum) FROM pg_catalog.pg_attribute
-                  WHERE attname IN ($4, 'validity')
-                    AND attrelid = $3::regclass
+                  WHERE attname IN (:attname, 'validity')
+                    AND attrelid = :conrelid::regclass
                 )
             )
           SQL
@@ -192,7 +211,7 @@ module ChronoTest::Matchers
         'be an updatable view'
       end
 
-      def failure_message_for_should
+      def failure_message
         "expected #{table} ".tap do |message|
           message << [
             ("to exist in the #{public_schema} schema" unless @existance     ),
@@ -204,6 +223,18 @@ module ChronoTest::Matchers
         end
       end
 
+      def failure_message_when_negated
+        "expected #{table} ".tap do |message|
+          message << [
+            ("to not exist in the #{public_schema} schema" if @existance     ),
+            ('to not be an updatable view'                 if @updatable     ),
+            ('to not have an INSERT trigger'               if @insert_trigger),
+            ('to not have an UPDATE trigger'               if @update_trigger),
+            ('to not have a DELETE trigger'                if @delete_trigger)
+          ].compact.to_sentence
+        end
+      end
+
       private
         def view_exists?
           @existance = relation_exists? :in => public_schema, :kind => :view
@@ -214,7 +245,7 @@ module ChronoTest::Matchers
 
           @updatable = select_value(<<-SQL, binds, 'Check updatable') == 'YES'
             SELECT is_updatable FROM information_schema.views
-             WHERE table_schema = $1 AND table_name = $2
+             WHERE table_schema = ? AND table_name = ?
           SQL
         end
 
@@ -224,8 +255,8 @@ module ChronoTest::Matchers
               FROM pg_catalog.pg_trigger t, pg_catalog.pg_class c, pg_catalog.pg_namespace n
              WHERE t.tgrelid = c.relfilenode
                AND n.oid = c.relnamespace
-               AND n.nspname = $1
-               AND c.relname = $2;
+               AND n.nspname = ?
+               AND c.relname = ?;
           SQL
 
           @insert_trigger = triggers.include? 'chronomodel_insert'

data/spec/time_machine_spec.rb

@@ -25,85 +25,118 @@ describe ChronoModel::TimeMachine do
   baz = Baz.create :name => 'baz', :bar => bar
 
   describe '.chrono?' do
+    subject { model.chrono? }
+
     context 'on a temporal model' do
-      subject { Foo }
-      it { should be_chrono }
+      let(:model) { Foo }
+      it { is_expected.to be(true) }
+    end
+
+    context 'on a plain model' do
+      let(:model) { Plain }
+      it { is_expected.to be(false) }
+    end
+  end
+
+  describe '.history?' do
+    subject { model.history? }
+
+    context 'on a temporal parent model' do
+      let(:model) { Foo }
+      it { is_expected.to be(false) }
+    end
+
+    context 'on a temporal history model' do
+      let(:model) { Foo::History }
+      it { is_expected.to be(true) }
     end
 
     context 'on a plain model' do
-      subject { Plain }
-      it { should_not be_chrono }
+      let(:model) { Plain }
+      it { expect { subject }.to raise_error(NoMethodError) }
     end
   end
 
+  describe '.descendants' do
+    subject { Element.descendants }
+    it { is_expected.to_not include(Element::History) }
+    it { is_expected.to     include(Publication) }
+  end
+
+  describe '.descendants_with_history' do
+    subject { Element.descendants_with_history }
+    it { is_expected.to include(Element::History) }
+    it { is_expected.to include(Publication) }
+  end
+
   # Specs start here
   #
   describe '.chrono_models' do
     subject { ChronoModel::TimeMachine.chrono_models }
 
-    it { should == {
+    it { is_expected.to eq(
       'foos'     => Foo::History,
       'defoos'   => Defoo::History,
       'bars'     => Bar::History,
       'elements' => Element::History
-    } }
+    ) }
   end
 
   describe '#as_of' do
     describe 'accepts a Time instance' do
-      it { foo.as_of(Time.now).name.should == 'new foo' }
-      it { bar.as_of(Time.now).name.should == 'new bar' }
+      it { expect(foo.as_of(Time.now).name).to eq 'new foo' }
+      it { expect(bar.as_of(Time.now).name).to eq 'new bar' }
     end
 
     describe 'ignores time zones' do
-      it { foo.as_of(Time.now.in_time_zone('America/Havana')).name.should == 'new foo' }
-      it { bar.as_of(Time.now.in_time_zone('America/Havana')).name.should == 'new bar' }
+      it { expect(foo.as_of(Time.now.in_time_zone('America/Havana')).name).to eq 'new foo' }
+      it { expect(bar.as_of(Time.now.in_time_zone('America/Havana')).name).to eq 'new bar' }
     end
 
     describe 'returns records as they were before' do
-      it { foo.as_of(foo.ts[0]).name.should == 'foo' }
-      it { foo.as_of(foo.ts[1]).name.should == 'foo bar' }
-      it { foo.as_of(foo.ts[2]).name.should == 'new foo' }
+      it { expect(foo.as_of(foo.ts[0]).name).to eq 'foo' }
+      it { expect(foo.as_of(foo.ts[1]).name).to eq 'foo bar' }
+      it { expect(foo.as_of(foo.ts[2]).name).to eq 'new foo' }
 
-      it { bar.as_of(bar.ts[0]).name.should == 'bar' }
-      it { bar.as_of(bar.ts[1]).name.should == 'foo bar' }
-      it { bar.as_of(bar.ts[2]).name.should == 'bar bar' }
-      it { bar.as_of(bar.ts[3]).name.should == 'new bar' }
+      it { expect(bar.as_of(bar.ts[0]).name).to eq 'bar' }
+      it { expect(bar.as_of(bar.ts[1]).name).to eq 'foo bar' }
+      it { expect(bar.as_of(bar.ts[2]).name).to eq 'bar bar' }
+      it { expect(bar.as_of(bar.ts[3]).name).to eq 'new bar' }
     end
 
     describe 'takes care of associated records' do
-      it { foo.as_of(foo.ts[0]).bars.should == [] }
-      it { foo.as_of(foo.ts[1]).bars.should == [] }
-      it { foo.as_of(foo.ts[2]).bars.should == [bar] }
+      it { expect(foo.as_of(foo.ts[0]).bars).to eq [] }
+      it { expect(foo.as_of(foo.ts[1]).bars).to eq [] }
+      it { expect(foo.as_of(foo.ts[2]).bars).to eq [bar] }
 
-      it { foo.as_of(foo.ts[2]).bars.first.name.should == 'foo bar' }
+      it { expect(foo.as_of(foo.ts[2]).bars.first.name).to eq 'foo bar' }
 
 
-      it { foo.as_of(bar.ts[0]).bars.should == [bar] }
-      it { foo.as_of(bar.ts[1]).bars.should == [bar] }
-      it { foo.as_of(bar.ts[2]).bars.should == [bar] }
-      it { foo.as_of(bar.ts[3]).bars.should == [bar] }
+      it { expect(foo.as_of(bar.ts[0]).bars).to eq [bar] }
+      it { expect(foo.as_of(bar.ts[1]).bars).to eq [bar] }
+      it { expect(foo.as_of(bar.ts[2]).bars).to eq [bar] }
+      it { expect(foo.as_of(bar.ts[3]).bars).to eq [bar] }
 
-      it { foo.as_of(bar.ts[0]).bars.first.name.should == 'bar' }
-      it { foo.as_of(bar.ts[1]).bars.first.name.should == 'foo bar' }
-      it { foo.as_of(bar.ts[2]).bars.first.name.should == 'bar bar' }
-      it { foo.as_of(bar.ts[3]).bars.first.name.should == 'new bar' }
+      it { expect(foo.as_of(bar.ts[0]).bars.first.name).to eq 'bar' }
+      it { expect(foo.as_of(bar.ts[1]).bars.first.name).to eq 'foo bar' }
+      it { expect(foo.as_of(bar.ts[2]).bars.first.name).to eq 'bar bar' }
+      it { expect(foo.as_of(bar.ts[3]).bars.first.name).to eq 'new bar' }
 
 
-      it { bar.as_of(bar.ts[0]).foo.should == foo }
-      it { bar.as_of(bar.ts[1]).foo.should == foo }
-      it { bar.as_of(bar.ts[2]).foo.should == foo }
-      it { bar.as_of(bar.ts[3]).foo.should == foo }
+      it { expect(bar.as_of(bar.ts[0]).foo).to eq foo }
+      it { expect(bar.as_of(bar.ts[1]).foo).to eq foo }
+      it { expect(bar.as_of(bar.ts[2]).foo).to eq foo }
+      it { expect(bar.as_of(bar.ts[3]).foo).to eq foo }
 
-      it { bar.as_of(bar.ts[0]).foo.name.should == 'foo bar' }
-      it { bar.as_of(bar.ts[1]).foo.name.should == 'foo bar' }
-      it { bar.as_of(bar.ts[2]).foo.name.should == 'new foo' }
-      it { bar.as_of(bar.ts[3]).foo.name.should == 'new foo' }
+      it { expect(bar.as_of(bar.ts[0]).foo.name).to eq 'foo bar' }
+      it { expect(bar.as_of(bar.ts[1]).foo.name).to eq 'foo bar' }
+      it { expect(bar.as_of(bar.ts[2]).foo.name).to eq 'new foo' }
+      it { expect(bar.as_of(bar.ts[3]).foo.name).to eq 'new foo' }
     end
 
     it 'doesn\'t raise RecordNotFound when no history records are found' do
       expect { foo.as_of(1.minute.ago) }.to_not raise_error
-      foo.as_of(1.minute.ago).should be_nil
+      expect(foo.as_of(1.minute.ago)).to be(nil)
     end
 
 
@@ -118,164 +151,161 @@ describe ChronoModel::TimeMachine do
       hidden = ts_eval { Defoo.create! :name => 'hidden 1', :active => false }
       ts_eval(hidden) { update_attributes! :name => 'hidden 2' }
 
-      it { Defoo.as_of(active.ts[0]).map(&:name).should == ['active 1'] }
-      it { Defoo.as_of(active.ts[1]).map(&:name).should == ['active 2'] }
-      it { Defoo.as_of(hidden.ts[0]).map(&:name).should == ['active 2'] }
-      it { Defoo.as_of(hidden.ts[1]).map(&:name).should == ['active 2'] }
+      it { expect(Defoo.as_of(active.ts[0]).map(&:name)).to eq ['active 1'] }
+      it { expect(Defoo.as_of(active.ts[1]).map(&:name)).to eq ['active 2'] }
+      it { expect(Defoo.as_of(hidden.ts[0]).map(&:name)).to eq ['active 2'] }
+      it { expect(Defoo.as_of(hidden.ts[1]).map(&:name)).to eq ['active 2'] }
 
-      it { Defoo.unscoped.as_of(active.ts[0]).map(&:name).should == ['active 1'] }
-      it { Defoo.unscoped.as_of(active.ts[1]).map(&:name).should == ['active 2'] }
-      it { Defoo.unscoped.as_of(hidden.ts[0]).map(&:name).should == ['active 2', 'hidden 1'] }
-      it { Defoo.unscoped.as_of(hidden.ts[1]).map(&:name).should == ['active 2', 'hidden 2'] }
+      it { expect(Defoo.unscoped.as_of(active.ts[0]).map(&:name)).to eq ['active 1'] }
+      it { expect(Defoo.unscoped.as_of(active.ts[1]).map(&:name)).to eq ['active 2'] }
+      it { expect(Defoo.unscoped.as_of(hidden.ts[0]).map(&:name)).to eq ['active 2', 'hidden 1'] }
+      it { expect(Defoo.unscoped.as_of(hidden.ts[1]).map(&:name)).to eq ['active 2', 'hidden 2'] }
     end
 
     describe 'proxies from non-temporal models to temporal ones' do
-      it { baz.as_of(bar.ts[0]).name.should == 'baz' }
-      it { baz.as_of(bar.ts[1]).name.should == 'baz' }
-      it { baz.as_of(bar.ts[2]).name.should == 'baz' }
-      it { baz.as_of(bar.ts[3]).name.should == 'baz' }
+      it { expect(baz.as_of(bar.ts[0]).name).to eq 'baz' }
+      it { expect(baz.as_of(bar.ts[1]).name).to eq 'baz' }
+      it { expect(baz.as_of(bar.ts[2]).name).to eq 'baz' }
+      it { expect(baz.as_of(bar.ts[3]).name).to eq 'baz' }
 
-      it { baz.as_of(bar.ts[0]).bar.name.should == 'bar' }
-      it { baz.as_of(bar.ts[1]).bar.name.should == 'foo bar' }
-      it { baz.as_of(bar.ts[2]).bar.name.should == 'bar bar' }
-      it { baz.as_of(bar.ts[3]).bar.name.should == 'new bar' }
+      it { expect(baz.as_of(bar.ts[0]).bar.name).to eq 'bar' }
+      it { expect(baz.as_of(bar.ts[1]).bar.name).to eq 'foo bar' }
+      it { expect(baz.as_of(bar.ts[2]).bar.name).to eq 'bar bar' }
+      it { expect(baz.as_of(bar.ts[3]).bar.name).to eq 'new bar' }
 
-      it { baz.as_of(bar.ts[0]).bar.foo.name.should == 'foo bar' }
-      it { baz.as_of(bar.ts[1]).bar.foo.name.should == 'foo bar' }
-      it { baz.as_of(bar.ts[2]).bar.foo.name.should == 'new foo' }
-      it { baz.as_of(bar.ts[3]).bar.foo.name.should == 'new foo' }
+      it { expect(baz.as_of(bar.ts[0]).bar.foo.name).to eq 'foo bar' }
+      it { expect(baz.as_of(bar.ts[1]).bar.foo.name).to eq 'foo bar' }
+      it { expect(baz.as_of(bar.ts[2]).bar.foo.name).to eq 'new foo' }
+      it { expect(baz.as_of(bar.ts[3]).bar.foo.name).to eq 'new foo' }
     end
   end
 
   describe '#history' do
     describe 'returns historical instances' do
-      it { foo.history.should have(3).entries }
-      it { foo.history.map(&:name).should == ['foo', 'foo bar', 'new foo'] }
+      it { expect(foo.history.size).to eq(3) }
+      it { expect(foo.history.map(&:name)).to eq ['foo', 'foo bar', 'new foo'] }
 
-      it { bar.history.should have(4).entries }
-      it { bar.history.map(&:name).should == ['bar', 'foo bar', 'bar bar', 'new bar'] }
+      it { expect(bar.history.size).to eq(4) }
+      it { expect(bar.history.map(&:name)).to eq ['bar', 'foo bar', 'bar bar', 'new bar'] }
     end
 
     describe 'does not return read only records' do
-      it { foo.history.all?(&:readonly?).should_not be_true }
-      it { bar.history.all?(&:readonly?).should_not be_true }
+      it { expect(foo.history.all?(&:readonly?)).to be(false) }
+      it { expect(bar.history.all?(&:readonly?)).to be(false) }
     end
 
     describe 'takes care of associated records' do
       subject { foo.history.map {|f| f.bars.first.try(:name)} }
-      it { should == [nil, 'foo bar', 'new bar'] }
+      it { is_expected.to eq [nil, 'foo bar', 'new bar'] }
     end
 
     describe 'does not return read only associated records' do
-      it { foo.history[2].bars.all?(&:readonly?).should_not be_true }
-      it { bar.history.all? {|b| b.foo.readonly?}.should_not be_true }
+      it { expect(foo.history[2].bars.all?(&:readonly?)).to_not be(true) }
+      it { expect(bar.history.all? {|b| b.foo.readonly?}).to_not be(true) }
     end
 
     describe 'allows a custom select list' do
-      it { foo.history.select(:id).first.attributes.keys.should == %w( id as_of_time ) }
+      it { expect(foo.history.select(:id).first.attributes.keys).to eq %w( id ) }
     end
 
     describe 'does not add as_of_time when there are aggregates' do
-      it { foo.history.select('max (id)').to_sql.should_not =~ /as_of_time/ } # The id is automatically added by ActiveRecord
-      it { foo.history.select('max(id) as foo, min(id) as bar').order(nil).first.attributes.keys.should == %w( foo bar id ) }
+      it { expect(foo.history.select('max(id)').to_sql).to_not match /as_of_time/ }
+
+      it { expect(foo.history.except(:order).select('max(id) as foo, min(id) as bar').group('id').first.attributes.keys).to eq %w( id foo bar ) }
     end
 
     context 'with STI models' do
       pub = ts_eval { Publication.create! :title => 'wrong title' }
       ts_eval(pub) { update_attributes! :title => 'correct title' }
 
-      it { pub.history.map(&:title).should == ['wrong title', 'correct title'] }
-    end
-
-    describe 'allows a custom order list' do
-      it { expect { foo.history.order('id') }.to_not raise_error }
-      it { foo.history.order('id').to_sql.should =~ /order by id/i }
+      it { expect(pub.history.map(&:title)).to eq ['wrong title', 'correct title'] }
     end
 
     context '.sorted' do
       describe 'orders by recorded_at, hid' do
-        it { foo.history.sorted.to_sql.should =~ /order by .+"recorded_at", .+"hid"/i }
+        it { expect(foo.history.sorted.to_sql).to match /order by .+"recorded_at", .+"hid"/i }
       end
     end
-
   end
 
   describe '#pred' do
     context 'on the first history entry' do
       subject { foo.history.first.pred }
-      it { should be_nil }
+      it { is_expected.to be(nil) }
     end
 
     context 'on the second history entry' do
       subject { foo.history.second.pred }
-      it { should == foo.history.first }
+      it { is_expected.to eq foo.history.first }
     end
 
     context 'on the last history entry' do
       subject { foo.history.last.pred }
-      it { should == foo.history[foo.history.size - 2] }
+      it { is_expected.to eq foo.history[foo.history.size - 2] }
     end
   end
 
   describe '#succ' do
     context 'on the first history entry' do
       subject { foo.history.first.succ }
-      it { should == foo.history.second }
+      it { is_expected.to eq foo.history.second }
     end
 
     context 'on the second history entry' do
       subject { foo.history.second.succ }
-      it { should == foo.history.third }
+      it { is_expected.to eq foo.history.third }
     end
 
     context 'on the last history entry' do
       subject { foo.history.last.succ }
-      it { should be_nil }
+      it { is_expected.to be(nil) }
     end
   end
 
   describe '#first' do
     subject { foo.history.sample.first }
-    it { should == foo.history.first }
+    it { is_expected.to eq foo.history.first }
   end
 
   describe '#last' do
     subject { foo.history.sample.last }
-    it { should == foo.history.last }
+    it { is_expected.to eq foo.history.last }
   end
 
   describe '#current_version' do
     describe 'on plain records' do
       subject { foo.current_version }
-      it { should == foo }
+      it { is_expected.to eq foo }
     end
 
     describe 'from #as_of' do
       subject { foo.as_of(Time.now) }
-      it { should == foo }
+      it { is_expected.to eq foo }
     end
 
     describe 'on historical records' do
       subject { foo.history.sample.current_version }
-      it { should == foo }
+      it { is_expected.to eq foo }
     end
   end
 
   describe '#historical?' do
+    subject { record.historical? }
+
     describe 'on plain records' do
-      subject { foo.historical? }
-      it { should be_false }
+      let(:record) { foo }
+      it { is_expected.to be(false) }
     end
 
     describe 'on historical records' do
       describe 'from #history' do
-        subject { foo.history.first }
-        it { should be_true }
+        let(:record) { foo.history.first }
+        it { is_expected.to be(true) }
       end
 
       describe 'from #as_of' do
-        subject { foo.as_of(Time.now) }
-        it { should be_true }
+        let(:record) { foo.as_of(Time.now) }
+        it { is_expected.to be(true) }
       end
     end
   end
@@ -302,24 +332,26 @@ describe ChronoModel::TimeMachine do
       it { expect { rec.reload }.to raise_error(ActiveRecord::RecordNotFound) }
 
       describe 'does not delete its history' do
+        subject { record.name }
+
         context do
-          subject { rec.as_of(rec.ts.first) }
-          its(:name) { should == 'alive foo' }
+          let(:record) { rec.as_of(rec.ts.first) }
+          it { is_expected.to eq 'alive foo' }
         end
 
         context do
-          subject { rec.as_of(rec.ts.last) }
-          its(:name) { should == 'dying foo' }
+          let(:record) { rec.as_of(rec.ts.last) }
+          it { is_expected.to eq 'dying foo' }
         end
 
         context do
-          subject { Foo.as_of(rec.ts.first).where(:fooity => 42).first }
-          its(:name) { should == 'alive foo' }
+          let(:record) { Foo.as_of(rec.ts.first).where(:fooity => 42).first }
+          it { is_expected.to eq 'alive foo' }
         end
 
         context do
           subject { Foo.history.where(:fooity => 42).map(&:name) }
-          it { should == ['alive foo', 'dying foo'] }
+          it { is_expected.to eq ['alive foo', 'dying foo'] }
         end
       end
     end
@@ -339,14 +371,14 @@ describe ChronoModel::TimeMachine do
     describe 'on records having an :has_many relationship' do
       describe 'by default returns timestamps of the record only' do
         subject { split.call(foo.timeline) }
-        its(:size) { should == foo.ts.size }
-        it { should == timestamps_from.call(foo) }
+        it { expect(subject.size).to eq foo.ts.size }
+        it { is_expected.to eq timestamps_from.call(foo) }
       end
 
       describe 'when asked, returns timestamps including the related objects' do
         subject { split.call(foo.timeline(:with => :bars)) }
-        its(:size) { should == foo.ts.size + bar.ts.size }
-        it { should == timestamps_from.call(foo, *foo.bars) }
+        it { expect(subject.size).to eq(foo.ts.size + bar.ts.size) }
+        it { is_expected.to eq(timestamps_from.call(foo, *foo.bars)) }
       end
     end
 
@@ -364,8 +396,8 @@ describe ChronoModel::TimeMachine do
           }
         end
 
-        its(:size) { should == expected.size }
-        it { should == expected }
+        it { expect(subject.size).to eq expected.size }
+        it { is_expected.to eq expected }
       end
     end
 
@@ -373,8 +405,8 @@ describe ChronoModel::TimeMachine do
       subject { split.call(baz.timeline) }
 
       describe 'returns timestamps of its temporal associations' do
-        its(:size) { should == bar.ts.size }
-        it { should == timestamps_from.call(bar) }
+        it { expect(subject.size).to eq bar.ts.size }
+        it { is_expected.to eq timestamps_from.call(bar) }
       end
     end
   end
@@ -383,13 +415,13 @@ describe ChronoModel::TimeMachine do
     context 'on plain records' do
       context 'having history' do
         subject { bar.last_changes }
-        it { should == {'name' => ['bar bar', 'new bar']} }
+        it { is_expected.to eq('name' => ['bar bar', 'new bar']) }
       end
 
       context 'without history' do
         let(:record) { Bar.create!(:name => 'foreveralone') }
         subject { record.last_changes }
-        it { should be_nil }
+        it { is_expected.to be_nil }
         after { record.destroy.history.delete_all } # UGLY
       end
     end
@@ -397,56 +429,46 @@ describe ChronoModel::TimeMachine do
     context 'on history records' do
       context 'at the beginning of the timeline' do
         subject { bar.history.first.last_changes }
-        it { should be_nil }
+        it { is_expected.to be_nil }
       end
 
       context 'in the middle of the timeline' do
         subject { bar.history.second.last_changes }
-        it { should == {'name' => ['bar', 'foo bar']} }
+        it { is_expected.to eq('name' => ['bar', 'foo bar']) }
       end
     end
   end
 
   describe '#changes_against' do
     context 'can compare records against history' do
-      it { bar.changes_against(bar.history.first).should ==
-             {'name' => ['bar', 'new bar']} }
-
-      it { bar.changes_against(bar.history.second).should ==
-             {'name' => ['foo bar', 'new bar']} }
-
-      it { bar.changes_against(bar.history.third).should ==
-             {'name' => ['bar bar', 'new bar']} }
-
-      it { bar.changes_against(bar.history.last).should == {} }
+      it { expect(bar.changes_against(bar.history.first)).to eq('name' => ['bar', 'new bar']) }
+      it { expect(bar.changes_against(bar.history.second)).to eq('name' => ['foo bar', 'new bar']) }
+      it { expect(bar.changes_against(bar.history.third)).to eq('name' => ['bar bar', 'new bar']) }
+      it { expect(bar.changes_against(bar.history.last)).to eq({}) }
     end
 
     context 'can compare history against history' do
-      it { bar.history.first.changes_against(bar.history.third).should ==
-             {'name' => ['bar bar', 'bar']} }
-
-      it { bar.history.second.changes_against(bar.history.third).should ==
-             {'name' => ['bar bar', 'foo bar']} }
-
-      it { bar.history.third.changes_against(bar.history.third).should == {} }
+      it { expect(bar.history.first.changes_against(bar.history.third)).to eq('name' => ['bar bar', 'bar']) }
+      it { expect(bar.history.second.changes_against(bar.history.third)).to eq('name' => ['bar bar', 'foo bar']) }
+      it { expect(bar.history.third.changes_against(bar.history.third)).to eq({}) }
     end
   end
 
   describe '#pred' do
     context 'on records having history' do
       subject { bar.pred }
-      its(:name) { should == 'bar bar' }
+      it { expect(subject.name).to eq 'bar bar' }
     end
 
     context 'when there is enough history' do
       subject { bar.pred.pred.pred.pred }
-      its(:name) { should == 'bar' }
+      it { expect(subject.name).to eq 'bar' }
     end
 
     context 'when no history is recorded' do
       let(:record) { Bar.create!(:name => 'quuuux') }
       subject { record.pred }
-      it { should be_nil }
+      it { is_expected.to be(nil) }
       after { record.destroy.history.delete_all }
     end
   end
@@ -462,9 +484,9 @@ describe ChronoModel::TimeMachine do
         describe ['#', attr].join do
           subject { record.public_send(attr) }
 
-          it { should be_present }
-          it { should be_a(Time) }
-          it { should be_utc }
+          it { is_expected.to be_present }
+          it { is_expected.to be_a(Time) }
+          it { is_expected.to be_utc }
         end
       end
     end
@@ -484,7 +506,7 @@ describe ChronoModel::TimeMachine do
         describe ['#', attr].join do
           subject { record.public_send(attr) }
 
-          it { should be_nil }
+          it { is_expected.to be(nil) }
         end
       end
     end
@@ -499,38 +521,38 @@ describe ChronoModel::TimeMachine do
     after(:all) { foos.each(&:destroy); bars.each(&:destroy) }
 
     describe '.as_of' do
-      it { Foo.as_of(1.month.ago).should == [] }
+      it { expect(Foo.as_of(1.month.ago)).to eq [] }
 
-      it { Foo.as_of(foos[0].ts[0]).should == [foo, foos[0]] }
-      it { Foo.as_of(foos[1].ts[0]).should == [foo, foos[0], foos[1]] }
-      it { Foo.as_of(Time.now     ).should == [foo, foos[0], foos[1]] }
+      it { expect(Foo.as_of(foos[0].ts[0])).to eq [foo, foos[0]] }
+      it { expect(Foo.as_of(foos[1].ts[0])).to eq [foo, foos[0], foos[1]] }
+      it { expect(Foo.as_of(Time.now     )).to eq [foo, foos[0], foos[1]] }
 
-      it { Bar.as_of(foos[1].ts[0]).should == [bar] }
+      it { expect(Bar.as_of(foos[1].ts[0])).to eq [bar] }
 
-      it { Bar.as_of(bars[0].ts[0]).should == [bar, bars[0]] }
-      it { Bar.as_of(bars[1].ts[0]).should == [bar, bars[0], bars[1]] }
-      it { Bar.as_of(Time.now     ).should == [bar, bars[0], bars[1]] }
+      it { expect(Bar.as_of(bars[0].ts[0])).to eq [bar, bars[0]] }
+      it { expect(Bar.as_of(bars[1].ts[0])).to eq [bar, bars[0], bars[1]] }
+      it { expect(Bar.as_of(Time.now     )).to eq [bar, bars[0], bars[1]] }
 
       # Associations
       context do
-        subject { foos[0] }
+        subject { foos[0].id }
 
-        it { Foo.as_of(foos[0].ts[0]).find(subject).bars.should == [] }
-        it { Foo.as_of(foos[1].ts[0]).find(subject).bars.should == [] }
-        it { Foo.as_of(bars[0].ts[0]).find(subject).bars.should == [bars[0]] }
-        it { Foo.as_of(bars[1].ts[0]).find(subject).bars.should == [bars[0]] }
-        it { Foo.as_of(Time.now     ).find(subject).bars.should == [bars[0]] }
+        it { expect(Foo.as_of(foos[0].ts[0]).find(subject).bars).to eq [] }
+        it { expect(Foo.as_of(foos[1].ts[0]).find(subject).bars).to eq [] }
+        it { expect(Foo.as_of(bars[0].ts[0]).find(subject).bars).to eq [bars[0]] }
+        it { expect(Foo.as_of(bars[1].ts[0]).find(subject).bars).to eq [bars[0]] }
+        it { expect(Foo.as_of(Time.now     ).find(subject).bars).to eq [bars[0]] }
       end
 
       context do
-        subject { foos[1] }
+        subject { foos[1].id }
 
         it { expect { Foo.as_of(foos[0].ts[0]).find(subject) }.to raise_error(ActiveRecord::RecordNotFound) }
         it { expect { Foo.as_of(foos[1].ts[0]).find(subject) }.to_not raise_error }
 
-        it { Foo.as_of(bars[0].ts[0]).find(subject).bars.should == [] }
-        it { Foo.as_of(bars[1].ts[0]).find(subject).bars.should == [bars[1]] }
-        it { Foo.as_of(Time.now     ).find(subject).bars.should == [bars[1]] }
+        it { expect(Foo.as_of(bars[0].ts[0]).find(subject).bars).to eq [] }
+        it { expect(Foo.as_of(bars[1].ts[0]).find(subject).bars).to eq [bars[1]] }
+        it { expect(Foo.as_of(Time.now     ).find(subject).bars).to eq [bars[1]] }
       end
     end
 
@@ -543,17 +565,17 @@ describe ChronoModel::TimeMachine do
         ['bar', 'foo bar', 'bar bar', 'new bar', 'bar 0', 'bar 1']
       }
 
-      it { Foo.history.all.map(&:name).should == foo_history }
-      it { Bar.history.all.map(&:name).should == bar_history }
+      it { expect(Foo.history.all.map(&:name)).to eq foo_history }
+      it { expect(Bar.history.all.map(&:name)).to eq bar_history }
     end
 
     describe '.time_query' do
-      it { Foo.history.time_query(:after,  :now, inclusive: true ).count.should == 3 }
-      it { Foo.history.time_query(:after,  :now, inclusive: false).count.should == 0 }
-      it { Foo.history.time_query(:before, :now, inclusive: true ).count.should == 5 }
-      it { Foo.history.time_query(:before, :now, inclusive: false).count.should == 2 }
+      it { expect(Foo.history.time_query(:after,  :now, inclusive: true ).count).to eq 3 }
+      it { expect(Foo.history.time_query(:after,  :now, inclusive: false).count).to eq 0 }
+      it { expect(Foo.history.time_query(:before, :now, inclusive: true ).count).to eq 5 }
+      it { expect(Foo.history.time_query(:before, :now, inclusive: false).count).to eq 2 }
 
-      it { Foo.history.past.size.should == 2 }
+      it { expect(Foo.history.past.size).to eq 2 }
     end
 
   end
@@ -571,10 +593,10 @@ describe ChronoModel::TimeMachine do
       end
 
       it "generate only a single history record" do
-        r1.history.should have(2).entries
+        expect(r1.history.size).to eq(2)
 
-        r1.history.first.name.should == 'xact test'
-        r1.history.last.name.should  == 'does work'
+        expect(r1.history.first.name).to eq 'xact test'
+        expect(r1.history.last.name).to  eq 'does work'
       end
     end
 
@@ -589,9 +611,8 @@ describe ChronoModel::TimeMachine do
       end
 
       it 'generates a single history record' do
-        r2.history.should have(1).entry
-
-        r2.history.first.name.should == 'I am Foo'
+        expect(r2.history.size).to eq(1)
+        expect(r2.history.first.name).to eq 'I am Foo'
       end
     end
 
@@ -603,7 +624,7 @@ describe ChronoModel::TimeMachine do
       end
 
       it 'does not generate any history' do
-        Foo.history.where(:id => r3.id).should be_empty
+        expect(Foo.history.where(:id => r3.id)).to be_empty
       end
     end
   end
@@ -620,9 +641,8 @@ describe ChronoModel::TimeMachine do
         subject.reload
       end
 
-      it { should be_a(Bar::History) }
-      it { should be_true }
-      its(:name) { should == 'modified bar history' }
+      it { is_expected.to be_a(Bar::History) }
+      it { expect(subject.name).to eq 'modified bar history' }
     end
 
     describe '#save!' do
@@ -634,9 +654,8 @@ describe ChronoModel::TimeMachine do
         subject.reload
       end
 
-      it { should be_a(Bar::History) }
-      it { should be_true }
-      its(:name) { should == 'another modified bar history' }
+      it { is_expected.to be_a(Bar::History) }
+      it { expect(subject.name).to eq 'another modified bar history' }
     end
   end