chrono_model 1.2.0 → 1.2.1

data/spec/chrono_model/adapter/indexes_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'support/adapter/structure'
+
+describe ChronoModel::Adapter do
+  include ChronoTest::Adapter::Helpers
+  include ChronoTest::Adapter::Structure
+
+  before :all do
+    adapter.create_table :meetings do |t|
+      t.string :name
+      t.tsrange :interval
+    end
+  end
+
+  after :all do
+    adapter.drop_table :meetings
+  end
+
+  describe '.add_temporal_indexes' do
+    before do
+      adapter.add_temporal_indexes :meetings, :interval
+    end
+
+    it { expect(adapter.indexes(:meetings).map(&:name)).to eq [
+      'index_meetings_temporal_on_interval',
+      'index_meetings_temporal_on_lower_interval',
+      'index_meetings_temporal_on_upper_interval'
+    ] }
+
+    after do
+      adapter.remove_temporal_indexes :meetings, :interval
+    end
+  end
+
+  describe '.remove_temporal_indexes' do
+    before :all do
+      adapter.add_temporal_indexes :meetings, :interval
+    end
+
+    before do
+      adapter.remove_temporal_indexes :meetings, :interval
+    end
+
+    it { expect(adapter.indexes(:meetings)).to be_empty }
+  end
+
+  describe '.add_timeline_consistency_constraint' do
+    before do
+      adapter.add_timeline_consistency_constraint(:meetings, :interval)
+    end
+
+    it { expect(adapter.indexes(:meetings).map(&:name)).to eq [
+      'meetings_timeline_consistency'
+    ] }
+
+    after do
+      adapter.remove_timeline_consistency_constraint(:meetings)
+    end
+  end
+
+  describe '.remove_timeline_consistency_constraint' do
+    before :all do
+      adapter.add_timeline_consistency_constraint :meetings, :interval
+    end
+
+    before do
+      adapter.remove_timeline_consistency_constraint(:meetings)
+    end
+
+    it { expect(adapter.indexes(:meetings)).to be_empty }
+  end
+end

data/spec/chrono_model/adapter/migrations_spec.rb

@@ -0,0 +1,312 @@
+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/history_models_spec.rb

@@ -0,0 +1,32 @@
+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/time_machine/as_of_spec.rb

@@ -0,0 +1,188 @@
+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