chrono_model 1.2.2 → 2.0.0

data/spec/chrono_model/adapter/migrations_spec.rb

@@ -1,312 +0,0 @@
-require 'spec_helper'
-require 'support/adapter/structure'
-
-shared_examples_for 'temporal table' do
-  it { expect(adapter.is_chrono?(subject)).to be(true) }
-
-  it { is_expected.to_not have_public_backing }
-
-  it { is_expected.to have_temporal_backing }
-  it { is_expected.to have_history_backing }
-  it { is_expected.to have_history_extra_columns }
-  it { is_expected.to have_history_functions }
-  it { is_expected.to have_public_interface }
-
-  it { is_expected.to have_columns(columns) }
-  it { is_expected.to have_temporal_columns(columns) }
-  it { is_expected.to have_history_columns(columns) }
-end
-
-shared_examples_for 'plain table' do
-  it { expect(adapter.is_chrono?(subject)).to be(false) }
-
-  it { is_expected.to have_public_backing }
-
-  it { is_expected.to_not have_temporal_backing }
-  it { is_expected.to_not have_history_backing }
-  it { is_expected.to_not have_history_functions }
-  it { is_expected.to_not have_public_interface }
-
-  it { is_expected.to have_columns(columns) }
-end
-
-describe ChronoModel::Adapter do
-  include ChronoTest::Adapter::Helpers
-  include ChronoTest::Adapter::Structure
-
-  describe '.create_table' do
-    with_temporal_table do
-      it_should_behave_like 'temporal table'
-    end
-
-    with_plain_table do
-      it_should_behave_like 'plain table'
-    end
-  end
-
-  describe '.rename_table' do
-    renamed = 'foo_table'
-    subject { renamed }
-
-    context 'temporal: true' do
-      before :all do
-        adapter.create_table table, :temporal => true, &columns
-        adapter.add_index table, :test
-        adapter.add_index table, [:foo, :bar]
-
-        adapter.rename_table table, renamed
-      end
-      after(:all) { adapter.drop_table(renamed) }
-
-      it_should_behave_like 'temporal table'
-
-      it 'renames indexes' do
-        new_index_names = adapter.indexes(renamed).map(&:name)
-        expected_index_names = [[:test], [:foo, :bar]].map do |idx_cols|
-          "index_#{renamed}_on_#{idx_cols.join('_and_')}"
-        end
-        expect(new_index_names.to_set).to eq expected_index_names.to_set
-      end
-    end
-
-    context 'temporal: false' do
-      before :all do
-        adapter.create_table table, :temporal => false, &columns
-
-        adapter.rename_table table, renamed
-      end
-      after(:all) { adapter.drop_table(renamed) }
-
-      it_should_behave_like 'plain table'
-    end
-  end
-
-  describe '.change_table' do
-    with_temporal_table do
-      before :all do
-        adapter.change_table table, :temporal => false
-      end
-
-      it_should_behave_like 'plain table'
-    end
-
-    with_plain_table do
-      before :all do
-        adapter.add_index table, :foo
-        adapter.add_index table, :bar, :unique => true
-
-        adapter.change_table table, :temporal => true
-      end
-
-      it_should_behave_like 'temporal table'
-
-      let(:history_indexes) do
-        adapter.on_schema(ChronoModel::Adapter::HISTORY_SCHEMA) do
-          adapter.indexes(table)
-        end
-      end
-
-      it "copies plain index to history" do
-        expect(history_indexes.find {|i| i.columns == ['foo']}).to be_present
-      end
-
-      it "copies unique index to history without uniqueness constraint" do
-        expect(history_indexes.find {|i| i.columns == ['bar'] && i.unique == false}).to be_present
-      end
-    end
-  end
-
-  describe '.drop_table' do
-    before :all do
-      adapter.create_table table, :temporal => true, &columns
-
-      adapter.drop_table table
-    end
-
-    it { is_expected.to_not have_public_backing }
-    it { is_expected.to_not have_temporal_backing }
-    it { is_expected.to_not have_history_backing }
-    it { is_expected.to_not have_history_functions }
-    it { is_expected.to_not have_public_interface }
-  end
-
-  describe '.add_index' do
-    with_temporal_table do
-      before :all do
-        adapter.add_index table, [:foo, :bar], :name => 'foobar_index'
-        adapter.add_index table, [:test],      :name => 'test_index'
-      end
-
-      it { is_expected.to have_temporal_index 'foobar_index', %w( foo bar ) }
-      it { is_expected.to have_history_index  'foobar_index', %w( foo bar ) }
-      it { is_expected.to have_temporal_index 'test_index',   %w( test ) }
-      it { is_expected.to have_history_index  'test_index',   %w( test ) }
-
-      it { is_expected.to_not have_index 'foobar_index', %w( foo bar ) }
-      it { is_expected.to_not have_index 'test_index',   %w( test ) }
-    end
-
-    with_plain_table do
-      before :all do
-        adapter.add_index table, [:foo, :bar], :name => 'foobar_index'
-        adapter.add_index table, [:test],      :name => 'test_index'
-      end
-
-      it { is_expected.to_not have_temporal_index 'foobar_index', %w( foo bar ) }
-      it { is_expected.to_not have_history_index  'foobar_index', %w( foo bar ) }
-      it { is_expected.to_not have_temporal_index 'test_index',   %w( test ) }
-      it { is_expected.to_not have_history_index  'test_index',   %w( test ) }
-
-      it { is_expected.to have_index 'foobar_index', %w( foo bar ) }
-      it { is_expected.to have_index 'test_index',   %w( test ) }
-    end
-  end
-
-  describe '.remove_index' do
-    with_temporal_table do
-      before :all do
-        adapter.add_index table, [:foo, :bar], :name => 'foobar_index'
-        adapter.add_index table, [:test],      :name => 'test_index'
-
-        adapter.remove_index table, :name => 'test_index'
-      end
-
-      it { is_expected.to_not have_temporal_index 'test_index', %w( test ) }
-      it { is_expected.to_not have_history_index  'test_index', %w( test ) }
-      it { is_expected.to_not have_index          'test_index', %w( test ) }
-    end
-
-    with_plain_table do
-      before :all do
-        adapter.add_index table, [:foo, :bar], :name => 'foobar_index'
-        adapter.add_index table, [:test],      :name => 'test_index'
-
-        adapter.remove_index table, :name => 'test_index'
-      end
-
-      it { is_expected.to_not have_temporal_index 'test_index', %w( test ) }
-      it { is_expected.to_not have_history_index  'test_index', %w( test ) }
-      it { is_expected.to_not have_index          'test_index', %w( test ) }
-    end
-  end
-
-  describe '.add_column' do
-    let(:extra_columns) { [['foobarbaz', 'integer']] }
-
-    with_temporal_table do
-      before :all do
-        adapter.add_column table, :foobarbaz, :integer
-      end
-
-      it { is_expected.to have_columns(extra_columns) }
-      it { is_expected.to have_temporal_columns(extra_columns) }
-      it { is_expected.to have_history_columns(extra_columns) }
-    end
-
-    with_plain_table do
-      before :all do
-        adapter.add_column table, :foobarbaz, :integer
-      end
-
-      it { is_expected.to have_columns(extra_columns) }
-    end
-  end
-
-  describe '.remove_column' do
-    let(:resulting_columns) { columns.reject {|c,_| c == 'foo'} }
-
-    with_temporal_table do
-      before :all do
-        adapter.remove_column table, :foo
-      end
-
-      it { is_expected.to have_columns(resulting_columns) }
-      it { is_expected.to have_temporal_columns(resulting_columns) }
-      it { is_expected.to have_history_columns(resulting_columns) }
-
-      it { is_expected.to_not have_columns([['foo', 'integer']]) }
-      it { is_expected.to_not have_temporal_columns([['foo', 'integer']]) }
-      it { is_expected.to_not have_history_columns([['foo', 'integer']]) }
-    end
-
-    with_plain_table do
-      before :all do
-        adapter.remove_column table, :foo
-      end
-
-      it { is_expected.to have_columns(resulting_columns) }
-      it { is_expected.to_not have_columns([['foo', 'integer']]) }
-    end
-  end
-
-  describe '.rename_column' do
-    with_temporal_table do
-      before :all do
-        adapter.rename_column table, :foo, :taratapiatapioca
-      end
-
-      it { is_expected.to_not have_columns([['foo', 'integer']]) }
-      it { is_expected.to_not have_temporal_columns([['foo', 'integer']]) }
-      it { is_expected.to_not have_history_columns([['foo', 'integer']]) }
-
-      it { is_expected.to have_columns([['taratapiatapioca', 'integer']]) }
-      it { is_expected.to have_temporal_columns([['taratapiatapioca', 'integer']]) }
-      it { is_expected.to have_history_columns([['taratapiatapioca', 'integer']]) }
-    end
-
-    with_plain_table do
-      before :all do
-        adapter.rename_column table, :foo, :taratapiatapioca
-      end
-
-      it { is_expected.to_not have_columns([['foo', 'integer']]) }
-      it { is_expected.to have_columns([['taratapiatapioca', 'integer']]) }
-    end
-  end
-
-  describe '.change_column' do
-    with_temporal_table do
-      before :all do
-        adapter.change_column table, :foo, :float
-      end
-
-      it { is_expected.to_not have_columns([['foo', 'integer']]) }
-      it { is_expected.to_not have_temporal_columns([['foo', 'integer']]) }
-      it { is_expected.to_not have_history_columns([['foo', 'integer']]) }
-
-      it { is_expected.to have_columns([['foo', 'double precision']]) }
-      it { is_expected.to have_temporal_columns([['foo', 'double precision']]) }
-      it { is_expected.to have_history_columns([['foo', 'double precision']]) }
-    end
-
-    with_plain_table do
-      before(:all) do
-        adapter.change_column table, :foo, :float
-      end
-
-      it { is_expected.to_not have_columns([['foo', 'integer']]) }
-      it { is_expected.to have_columns([['foo', 'double precision']]) }
-    end
-  end
-
-  describe '.remove_column' do
-    with_temporal_table do
-      before :all do
-        adapter.remove_column table, :foo
-      end
-
-      it { is_expected.to_not have_columns([['foo', 'integer']]) }
-      it { is_expected.to_not have_temporal_columns([['foo', 'integer']]) }
-      it { is_expected.to_not have_history_columns([['foo', 'integer']]) }
-    end
-
-    with_plain_table do
-      before :all do
-        adapter.remove_column table, :foo
-      end
-
-      it { is_expected.to_not have_columns([['foo', 'integer']]) }
-    end
-  end
-
-end

data/spec/chrono_model/conversions_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-describe ChronoModel::Conversions do
-
-  describe 'string_to_utc_time' do
-    subject { described_class.string_to_utc_time(string) }
-
-    context 'given a valid UTC time string' do
-      let(:string) { '2017-02-06 09:46:31.129626' }
-
-      it { is_expected.to be_a(Time) }
-      it { expect(subject.year).to  eq 2017 }
-      it { expect(subject.month).to eq 2 }
-      it { expect(subject.day).to   eq 6 }
-      it { expect(subject.hour).to  eq 9 }
-      it { expect(subject.min).to   eq 46 }
-      it { expect(subject.sec).to   eq 31 }
-      it { expect(subject.usec).to  eq 129626 } # Ref Issue #32
-    end
-
-    context 'given a valid UTC string without least significant zeros' do
-      let(:string) { '2017-02-06 09:46:31.129' }
-
-      it { is_expected.to be_a(Time) }
-      it { expect(subject.usec).to eq 129000 } # Ref Issue #32
-    end
-
-    context 'given an invalid UTC time string' do
-      let(:string) { 'foobar' }
-
-      it { is_expected.to be(nil) }
-    end
-  end
-
-  describe 'time_to_utc_string' do
-    subject { described_class.time_to_utc_string(time) }
-
-    let(:time) { Time.utc(1981, 4, 11, 2, 42, 10, 123456) }
-
-    it { is_expected.to eq '1981-04-11 02:42:10.123456' }
-  end
-
-end

data/spec/chrono_model/history_models_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-require 'support/time_machine/structure'
-
-describe ChronoModel do
-  describe '.history_models' do
-    subject { ChronoModel.history_models }
-
-    it 'tracks recorded history models' do
-      expected = {}
-
-      # support/time_machine/structure
-      expected['foos']     = Foo::History     if defined?(Foo::History)
-      expected['bars']     = Bar::History     if defined?(Bar::History)
-      expected['sub_bars'] = SubBar::History  if defined?(SubBar::History)
-
-      # default_scope_spec
-      expected['defoos']   = Defoo::History   if defined?(Defoo::History)
-
-      # counter_cache_race_spec
-      expected['sections'] = Section::History if defined?(Section::History)
-      expected['articles'] = Article::History if defined?(Article::History)
-
-      # sti_spec
-      expected['animals']  = Animal::History  if defined?(Animal::History)
-      expected['elements'] = Element::History if defined?(Element::History)
-
-      is_expected.to eq(expected)
-    end
-
-    it { expect(subject.size).to be > 0 }
-  end
-end

data/spec/chrono_model/json_ops_spec.rb

@@ -1,59 +0,0 @@
-##########################################################
-### DEPRECATED: JSON operators are an hack and there is no
-### reason not to use jsonb other than migrating your data
-##########################################################
-if ENV['HAVE_PLPYTHON'] == '1'
-
-require 'spec_helper'
-require 'support/helpers'
-
-require 'chrono_model/json'
-
-describe 'JSON equality operator' do
-  include ChronoTest::Helpers::Adapter
-
-  table 'json_test'
-
-  before :all do
-    ChronoModel::Json.create
-  end
-
-  after :all do
-    ChronoModel::Json.drop
-  end
-
-  it { expect(adapter.select_value(%[ SELECT '{"a":1}'::json = '{"a":1}'::json ])).to eq true }
-  it { expect(adapter.select_value(%[ SELECT '{"a":1}'::json = '{"a" : 1}'::json ])).to eq true }
-  it { expect(adapter.select_value(%[ SELECT '{"a":1}'::json = '{"a":2}'::json ])).to eq false }
-  it { expect(adapter.select_value(%[ SELECT '{"a":1,"b":2}'::json = '{"b":2,"a":1}'::json ])).to eq true }
-  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 true }
-
-  context 'on a temporal table' do
-    before :all do
-      adapter.create_table table, :temporal => true do |t|
-        t.json 'data'
-      end
-
-      adapter.execute %[
-        INSERT INTO #{table} ( data ) VALUES ( '{"a":1,"b":2}' )
-      ]
-    end
-
-    after :all do
-      adapter.drop_table table
-    end
-
-    it { expect {
-      adapter.execute "UPDATE #{table} SET data = NULL"
-    }.to_not raise_error }
-
-    it { expect {
-      adapter.execute %[UPDATE #{table} SET data = '{"x":1,"y":2}']
-
-    }.to_not raise_error }
-  end
-
-end
-
-
-end

data/spec/chrono_model/time_machine/as_of_spec.rb

@@ -1,188 +0,0 @@
-require 'spec_helper'
-require 'support/time_machine/structure'
-
-describe ChronoModel::TimeMachine do
-  include ChronoTest::TimeMachine::Helpers
-
-  describe '.as_of' do
-    it { expect(Foo.as_of(1.month.ago)).to eq [] }
-
-    it { expect(Foo.as_of($t.foos[0].ts[0])).to eq [$t.foo, $t.foos[0]] }
-    it { expect(Foo.as_of($t.foos[1].ts[0])).to eq [$t.foo, $t.foos[0], $t.foos[1]] }
-    it { expect(Foo.as_of(Time.now     )).to eq [$t.foo, $t.foos[0], $t.foos[1]] }
-
-    it { expect(Bar.as_of($t.foos[1].ts[0])).to eq [$t.bar] }
-
-    it { expect(Bar.as_of($t.bars[0].ts[0])).to eq [$t.bar, $t.bars[0]] }
-    it { expect(Bar.as_of($t.bars[1].ts[0])).to eq [$t.bar, $t.bars[0], $t.bars[1]] }
-    it { expect(Bar.as_of(Time.now     )).to eq [$t.bar, $t.bars[0], $t.bars[1]] }
-
-    it { expect(Foo.as_of($t.foos[0].ts[0]).first).to be_a(Foo) }
-    it { expect(Bar.as_of($t.foos[0].ts[0]).first).to be_a(Bar) }
-
-    # Associations
-    context do
-      subject { $t.foos[0].id }
-
-      it { expect(Foo.as_of($t.foos[0].ts[0]).find(subject).bars).to eq [] }
-      it { expect(Foo.as_of($t.foos[1].ts[0]).find(subject).bars).to eq [] }
-      it { expect(Foo.as_of($t.bars[0].ts[0]).find(subject).bars).to eq [$t.bars[0]] }
-      it { expect(Foo.as_of($t.bars[1].ts[0]).find(subject).bars).to eq [$t.bars[0]] }
-      it { expect(Foo.as_of(Time.now        ).find(subject).bars).to eq [$t.bars[0]] }
-
-      it { expect(Foo.as_of($t.bars[0].ts[0]).find(subject).bars.first).to be_a(Bar) }
-    end
-
-    context do
-      subject { $t.foos[1].id }
-
-      it { expect { Foo.as_of($t.foos[0].ts[0]).find(subject) }.to raise_error(ActiveRecord::RecordNotFound) }
-      it { expect { Foo.as_of($t.foos[1].ts[0]).find(subject) }.to_not raise_error }
-
-      it { expect(Foo.as_of($t.bars[0].ts[0]).find(subject).bars).to eq [] }
-      it { expect(Foo.as_of($t.bars[1].ts[0]).find(subject).bars).to eq [$t.bars[1]] }
-      it { expect(Foo.as_of(Time.now        ).find(subject).bars).to eq [$t.bars[1]] }
-    end
-  end
-
-
-  describe '#as_of' do
-    describe 'accepts a Time instance' do
-      it { expect($t.foo.as_of(Time.now).name).to eq 'new foo' }
-      it { expect($t.bar.as_of(Time.now).name).to eq 'new bar' }
-    end
-
-
-    describe 'ignores time zones' do
-      it { expect($t.foo.as_of(Time.now.in_time_zone('America/Havana')).name).to eq 'new foo' }
-      it { expect($t.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 { expect($t.foo.as_of($t.foo.ts[0]).name).to eq 'foo' }
-      it { expect($t.foo.as_of($t.foo.ts[1]).name).to eq 'foo bar' }
-      it { expect($t.foo.as_of($t.foo.ts[2]).name).to eq 'new foo' }
-
-      it { expect($t.bar.as_of($t.bar.ts[0]).name).to eq 'bar' }
-      it { expect($t.bar.as_of($t.bar.ts[1]).name).to eq 'foo bar' }
-      it { expect($t.bar.as_of($t.bar.ts[2]).name).to eq 'bar bar' }
-      it { expect($t.bar.as_of($t.bar.ts[3]).name).to eq 'new bar' }
-    end
-
-
-    describe 'takes care of associated records' do
-      it { expect($t.foo.as_of($t.foo.ts[0]).bars).to eq [] }
-      it { expect($t.foo.as_of($t.foo.ts[1]).bars).to eq [] }
-      it { expect($t.foo.as_of($t.foo.ts[2]).bars).to eq [$t.bar] }
-
-      it { expect($t.foo.as_of($t.foo.ts[2]).bars.first.name).to eq 'foo bar' }
-
-      it { expect($t.foo.as_of($t.bar.ts[0]).bars).to eq [$t.bar] }
-      it { expect($t.foo.as_of($t.bar.ts[1]).bars).to eq [$t.bar] }
-      it { expect($t.foo.as_of($t.bar.ts[2]).bars).to eq [$t.bar] }
-      it { expect($t.foo.as_of($t.bar.ts[3]).bars).to eq [$t.bar] }
-
-      it { expect($t.foo.as_of($t.bar.ts[0]).bars.first.name).to eq 'bar' }
-      it { expect($t.foo.as_of($t.bar.ts[1]).bars.first.name).to eq 'foo bar' }
-      it { expect($t.foo.as_of($t.bar.ts[2]).bars.first.name).to eq 'bar bar' }
-      it { expect($t.foo.as_of($t.bar.ts[3]).bars.first.name).to eq 'new bar' }
-
-
-      it { expect($t.bar.as_of($t.bar.ts[0]).foo).to eq $t.foo }
-      it { expect($t.bar.as_of($t.bar.ts[1]).foo).to eq $t.foo }
-      it { expect($t.bar.as_of($t.bar.ts[2]).foo).to eq $t.foo }
-      it { expect($t.bar.as_of($t.bar.ts[3]).foo).to eq $t.foo }
-
-      it { expect($t.bar.as_of($t.bar.ts[0]).foo.name).to eq 'foo bar' }
-      it { expect($t.bar.as_of($t.bar.ts[1]).foo.name).to eq 'foo bar' }
-      it { expect($t.bar.as_of($t.bar.ts[2]).foo.name).to eq 'new foo' }
-      it { expect($t.bar.as_of($t.bar.ts[3]).foo.name).to eq 'new foo' }
-    end
-
-
-    describe 'supports historical queries with includes()' do
-      it { expect(Foo.as_of($t.foo.ts[0]).includes(:bars).first.bars).to eq [] }
-      it { expect(Foo.as_of($t.foo.ts[1]).includes(:bars).first.bars).to eq [] }
-      it { expect(Foo.as_of($t.foo.ts[2]).includes(:bars).first.bars).to eq [$t.bar] }
-
-      it { expect(Foo.as_of($t.bar.ts[0]).includes(:bars).first.bars.first.name).to eq 'bar' }
-      it { expect(Foo.as_of($t.bar.ts[1]).includes(:bars).first.bars.first.name).to eq 'foo bar' }
-      it { expect(Foo.as_of($t.bar.ts[2]).includes(:bars).first.bars.first.name).to eq 'bar bar' }
-      it { expect(Foo.as_of($t.bar.ts[3]).includes(:bars).first.bars.first.name).to eq 'new bar' }
-
-
-      it { expect(Foo.as_of($t.foo.ts[0]).includes(bars: :sub_bars).first.bars).to eq [] }
-      it { expect(Foo.as_of($t.foo.ts[1]).includes(bars: :sub_bars).first.bars).to eq [] }
-      it { expect(Foo.as_of($t.foo.ts[2]).includes(bars: :sub_bars).first.bars).to eq [$t.bar] }
-
-      it { expect(Foo.as_of($t.bar.ts[0]).includes(bars: :sub_bars).first.bars.first.name).to eq 'bar' }
-      it { expect(Foo.as_of($t.bar.ts[1]).includes(bars: :sub_bars).first.bars.first.name).to eq 'foo bar' }
-      it { expect(Foo.as_of($t.bar.ts[2]).includes(bars: :sub_bars).first.bars.first.name).to eq 'bar bar' }
-      it { expect(Foo.as_of($t.bar.ts[3]).includes(bars: :sub_bars).first.bars.first.name).to eq 'new bar' }
-
-      it { expect(Bar.as_of($t.bar.ts[0]).includes(:foo).first.foo).to eq $t.foo }
-      it { expect(Bar.as_of($t.bar.ts[1]).includes(:foo).first.foo).to eq $t.foo }
-      it { expect(Bar.as_of($t.bar.ts[2]).includes(:foo).first.foo).to eq $t.foo }
-      it { expect(Bar.as_of($t.bar.ts[3]).includes(:foo).first.foo).to eq $t.foo }
-
-      it { expect(Bar.as_of($t.bar.ts[0]).includes(:foo).first.foo.name).to eq 'foo bar' }
-      it { expect(Bar.as_of($t.bar.ts[1]).includes(:foo).first.foo.name).to eq 'foo bar' }
-      it { expect(Bar.as_of($t.bar.ts[2]).includes(:foo).first.foo.name).to eq 'new foo' }
-      it { expect(Bar.as_of($t.bar.ts[3]).includes(:foo).first.foo.name).to eq 'new foo' }
-
-
-      it { expect(Bar.as_of($t.bar.ts[0]).includes(foo: :sub_bars).first.foo).to eq $t.foo }
-      it { expect(Bar.as_of($t.bar.ts[1]).includes(foo: :sub_bars).first.foo).to eq $t.foo }
-      it { expect(Bar.as_of($t.bar.ts[2]).includes(foo: :sub_bars).first.foo).to eq $t.foo }
-      it { expect(Bar.as_of($t.bar.ts[3]).includes(foo: :sub_bars).first.foo).to eq $t.foo }
-
-      it { expect(Bar.as_of($t.bar.ts[0]).includes(foo: :sub_bars).first.foo.name).to eq 'foo bar' }
-      it { expect(Bar.as_of($t.bar.ts[1]).includes(foo: :sub_bars).first.foo.name).to eq 'foo bar' }
-      it { expect(Bar.as_of($t.bar.ts[2]).includes(foo: :sub_bars).first.foo.name).to eq 'new foo' }
-      it { expect(Bar.as_of($t.bar.ts[3]).includes(foo: :sub_bars).first.foo.name).to eq 'new foo' }
-
-      it { expect(Foo.as_of($t.foo.ts[0]).includes(:bars, :sub_bars).first.sub_bars.count).to eq 0 }
-      it { expect(Foo.as_of($t.foo.ts[1]).includes(:bars, :sub_bars).first.sub_bars.count).to eq 0 }
-      it { expect(Foo.as_of($t.foo.ts[2]).includes(:bars, :sub_bars).first.sub_bars.count).to eq 1 }
-
-      it { expect(Foo.as_of($t.foo.ts[0]).includes(:bars, :sub_bars).first.sub_bars.first).to be nil }
-      it { expect(Foo.as_of($t.foo.ts[1]).includes(:bars, :sub_bars).first.sub_bars.first).to be nil }
-
-      it { expect(Foo.as_of($t.subbar.ts[0]).includes(:bars, :sub_bars).first.sub_bars.first.name).to eq 'sub-bar' }
-      it { expect(Foo.as_of($t.subbar.ts[1]).includes(:bars, :sub_bars).first.sub_bars.first.name).to eq 'bar sub-bar' }
-      it { expect(Foo.as_of($t.subbar.ts[2]).includes(:bars, :sub_bars).first.sub_bars.first.name).to eq 'sub-bar sub-bar' }
-      it { expect(Foo.as_of($t.subbar.ts[3]).includes(:bars, :sub_bars).first.sub_bars.first.name).to eq 'new sub-bar' }
-    end
-
-
-    it 'does not raise RecordNotFound when no history records are found' do
-      expect { $t.foo.as_of(1.minute.ago) }.to_not raise_error
-
-      expect($t.foo.as_of(1.minute.ago)).to be(nil)
-    end
-
-
-    it 'raises ActiveRecord::RecordNotFound in the bang variant' do
-      expect { $t.foo.as_of!(1.minute.ago) }.to raise_error(ActiveRecord::RecordNotFound)
-    end
-
-
-    describe 'proxies from non-temporal models to temporal ones' do
-      it { expect($t.baz.as_of($t.bar.ts[0]).name).to eq 'baz' }
-      it { expect($t.baz.as_of($t.bar.ts[1]).name).to eq 'baz' }
-      it { expect($t.baz.as_of($t.bar.ts[2]).name).to eq 'baz' }
-      it { expect($t.baz.as_of($t.bar.ts[3]).name).to eq 'baz' }
-
-      it { expect($t.baz.as_of($t.bar.ts[0]).bar.name).to eq 'bar' }
-      it { expect($t.baz.as_of($t.bar.ts[1]).bar.name).to eq 'foo bar' }
-      it { expect($t.baz.as_of($t.bar.ts[2]).bar.name).to eq 'bar bar' }
-      it { expect($t.baz.as_of($t.bar.ts[3]).bar.name).to eq 'new bar' }
-
-      it { expect($t.baz.as_of($t.bar.ts[0]).bar.foo.name).to eq 'foo bar' }
-      it { expect($t.baz.as_of($t.bar.ts[1]).bar.foo.name).to eq 'foo bar' }
-      it { expect($t.baz.as_of($t.bar.ts[2]).bar.foo.name).to eq 'new foo' }
-      it { expect($t.baz.as_of($t.bar.ts[3]).bar.foo.name).to eq 'new foo' }
-    end
-  end
-end

data/spec/chrono_model/time_machine/changes_spec.rb

@@ -1,50 +0,0 @@
-require 'spec_helper'
-require 'support/time_machine/structure'
-
-describe ChronoModel::TimeMachine do
-  include ChronoTest::TimeMachine::Helpers
-
-  describe '#last_changes' do
-    context 'on plain records' do
-      context 'having history' do
-        subject { $t.bar.last_changes }
-        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 { is_expected.to be_nil }
-        after { record.destroy.history.delete_all } # UGLY
-      end
-    end
-
-    context 'on history records' do
-      context 'at the beginning of the timeline' do
-        subject { $t.bar.history.first.last_changes }
-        it { is_expected.to be_nil }
-      end
-
-      context 'in the middle of the timeline' do
-        subject { $t.bar.history.second.last_changes }
-        it { is_expected.to eq('name' => ['bar', 'foo bar']) }
-      end
-    end
-  end
-
-  describe '#changes_against' do
-    context 'can compare records against history' do
-      it { expect($t.bar.changes_against($t.bar.history.first)).to eq('name' => ['bar', 'new bar']) }
-      it { expect($t.bar.changes_against($t.bar.history.second)).to eq('name' => ['foo bar', 'new bar']) }
-      it { expect($t.bar.changes_against($t.bar.history.third)).to eq('name' => ['bar bar', 'new bar']) }
-      it { expect($t.bar.changes_against($t.bar.history.last)).to eq({}) }
-    end
-
-    context 'can compare history against history' do
-      it { expect($t.bar.history.first. changes_against($t.bar.history.third)).to eq('name' => ['bar bar', 'bar']) }
-      it { expect($t.bar.history.second.changes_against($t.bar.history.third)).to eq('name' => ['bar bar', 'foo bar']) }
-      it { expect($t.bar.history.third. changes_against($t.bar.history.third)).to eq({}) }
-    end
-  end
-
-end