chrono_model 1.2.2 → 3.0.1

data/spec/chrono_model/time_machine/counter_cache_race_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-require 'support/time_machine/structure'
-
-describe 'models with counter cache' do
-  include ChronoTest::TimeMachine::Helpers
-
-  adapter.create_table 'sections', temporal: true, no_journal: %w( articles_count ) do |t|
-    t.string :name
-    t.integer :articles_count, default: 0
-  end
-
-  adapter.create_table 'articles', temporal: true do |t|
-    t.string :title
-    t.references :section
-  end
-
-  class ::Section < ActiveRecord::Base
-    include ChronoModel::TimeMachine
-
-    has_many :articles
-  end
-
-  class ::Article < ActiveRecord::Base
-    include ChronoModel::TimeMachine
-
-    belongs_to :section, counter_cache: true
-  end
-
-  describe 'are not subject to race condition if no_journal is set on the counter cache column' do
-    specify do
-      section = Section.create!
-
-      expect(section.articles_count).to eq(0)
-      Article.create!(section_id: section.id)
-      expect(section.reload.articles_count).to eq(1)
-
-      num_threads = 10
-
-      expect {
-        Array.new(num_threads).map do
-          Thread.new { Article.create!(section_id: section.id) }
-        end.each(&:join)
-      }.to_not raise_error
-    end
-  end
-end

data/spec/chrono_model/time_machine/default_scope_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-require 'support/time_machine/structure'
-
-describe ChronoModel::TimeMachine do
-  include ChronoTest::TimeMachine::Helpers
-
-  # Set up database structure
-  #
-  adapter.create_table 'defoos', :temporal => true do |t|
-    t.string  :name
-    t.boolean :active
-  end
-
-  class ::Defoo < ActiveRecord::Base
-    include ChronoModel::TimeMachine
-
-    default_scope proc { where(:active => true) }
-  end
-
-  active = ts_eval { Defoo.create! :name => 'active 1', :active => true }
-  ts_eval(active) { update_attributes! :name => 'active 2' }
-
-  hidden = ts_eval { Defoo.create! :name => 'hidden 1', :active => false }
-  ts_eval(hidden) { update_attributes! :name => 'hidden 2' }
-
-  describe 'it honors default_scopes' do
-    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 { 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
-end

data/spec/chrono_model/time_machine/history_spec.rb

@@ -1,104 +0,0 @@
-require 'spec_helper'
-require 'support/time_machine/structure'
-
-describe ChronoModel::TimeMachine do
-  include ChronoTest::TimeMachine::Helpers
-
-  describe '.history' do
-    let(:foo_history) {
-      ['foo', 'foo bar', 'new foo', 'foo 0', 'foo 1']
-    }
-
-    let(:bar_history) {
-      ['bar', 'foo bar', 'bar bar', 'new bar', 'bar 0', 'bar 1']
-    }
-
-    it { expect(Foo.history.all.map(&:name)).to eq foo_history }
-    it { expect(Bar.history.all.map(&:name)).to eq bar_history }
-
-    it { expect(Foo.history.first).to be_a(Foo::History) }
-    it { expect(Bar.history.first).to be_a(Bar::History) }
-  end
-
-
-  describe '#history' do
-    describe 'returns historical instances' do
-      it { expect($t.foo.history.size).to eq(3) }
-      it { expect($t.foo.history.map(&:name)).to eq ['foo', 'foo bar', 'new foo'] }
-
-      it { expect($t.bar.history.size).to eq(4) }
-      it { expect($t.bar.history.map(&:name)).to eq ['bar', 'foo bar', 'bar bar', 'new bar'] }
-    end
-
-    describe 'does not return read only records' do
-      it { expect($t.foo.history.all?(&:readonly?)).to be(false) }
-      it { expect($t.bar.history.all?(&:readonly?)).to be(false) }
-    end
-
-    describe 'takes care of associated records' do
-      subject { $t.foo.history.map {|f| f.bars.first.try(:name)} }
-      it { is_expected.to eq [nil, 'foo bar', 'new bar'] }
-    end
-
-    describe 'does not return read only associated records' do
-      it { expect($t.foo.history[2].bars.all?(&:readonly?)).to_not be(true) }
-      it { expect($t.bar.history.all? {|b| b.foo.readonly?}).to_not be(true) }
-    end
-
-    describe 'allows a custom select list' do
-      it { expect($t.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 { expect($t.foo.history.select('max(id)').to_sql).to_not match(/as_of_time/) }
-
-      it { expect($t.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 '.sorted' do
-      describe 'orders by recorded_at, hid' do
-        it { expect($t.foo.history.sorted.to_sql).to match(/order by .+"recorded_at" ASC, .+"hid" ASC/i) }
-      end
-    end
-  end
-
-
-  describe '#current_version' do
-    describe 'on plain records' do
-      subject { $t.foo.current_version }
-      it { is_expected.to eq $t.foo }
-    end
-
-    describe 'from #as_of' do
-      subject { $t.foo.as_of(Time.now) }
-      it { is_expected.to eq $t.foo }
-    end
-
-    describe 'on historical records' do
-      subject { $t.foo.history.sample.current_version }
-      it { is_expected.to eq $t.foo }
-    end
-  end
-
-
-  describe '#historical?' do
-    subject { record.historical? }
-
-    describe 'on plain records' do
-      let(:record) { $t.foo }
-      it { is_expected.to be(false) }
-    end
-
-    describe 'on historical records' do
-      describe 'from #history' do
-        let(:record) { $t.foo.history.first }
-        it { is_expected.to be(true) }
-      end
-
-      describe 'from #as_of' do
-        let(:record) { $t.foo.as_of(Time.now) }
-        it { is_expected.to be(true) }
-      end
-    end
-  end
-end

data/spec/chrono_model/time_machine/keep_cool_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-require 'support/time_machine/structure'
-
-describe ChronoModel::TimeMachine do
-  include ChronoTest::TimeMachine::Helpers
-
-  describe 'does not interfere with AR standard behaviour' do
-    let(:all_foos) { [ $t.foo ] + $t.foos }
-    let(:all_bars) { [ $t.bar ] + $t.bars }
-
-    it { expect(Foo.count).to eq all_foos.size }
-    it { expect(Bar.count).to eq all_bars.size }
-
-    it { expect(Foo.includes(bars: :sub_bars)).to eq all_foos }
-    it { expect(Foo.includes(:bars).preload(bars: :sub_bars)).to eq all_foos }
-
-    it { expect(Foo.includes(:bars).first.name).to eq 'new foo' }
-    it { expect(Foo.includes(:bars).as_of($t.foo.ts[0]).first.name).to eq 'foo' }
-
-    it { expect(Foo.joins(:bars).map(&:bars).flatten).to eq all_bars }
-    it { expect(Foo.joins(:bars).first.bars.joins(:sub_bars).first.name).to eq 'new bar' }
-
-    it { expect(Foo.joins(bars: :sub_bars).first.bars.joins(:sub_bars).first.sub_bars.first.name).to eq 'new sub-bar' }
-
-    it { expect(Foo.first.bars.includes(:sub_bars)).to eq [ $t.bar ] }
-  end
-end

data/spec/chrono_model/time_machine/manipulations_spec.rb

@@ -1,84 +0,0 @@
-require 'spec_helper'
-require 'support/time_machine/structure'
-
-describe ChronoModel::TimeMachine do
-  include ChronoTest::TimeMachine::Helpers
-
-  describe '#save' do
-    subject { $t.bar.history.first }
-
-    it do
-      with_revert do
-        subject.name = 'modified bar history'
-        subject.save
-        subject.reload
-
-        is_expected.to be_a(Bar::History)
-        expect(subject.name).to eq 'modified bar history'
-      end
-    end
-  end
-
-  describe '#save!' do
-    subject { $t.bar.history.second }
-
-    it do
-      with_revert do
-        subject.name = 'another modified bar history'
-        subject.save
-        subject.reload
-
-        is_expected.to be_a(Bar::History)
-        expect(subject.name).to eq 'another modified bar history'
-      end
-    end
-  end
-
-  describe '#destroy' do
-    describe 'on historical records' do
-      subject { $t.foo.history.first.destroy }
-      it { expect { subject }.to raise_error(ActiveRecord::ReadOnlyRecord) }
-    end
-
-    describe 'on current records' do
-      rec = nil
-      before(:all) do
-        rec = ts_eval { Foo.create!(:name => 'alive foo', :fooity => 42) }
-        ts_eval(rec) { update_attributes!(:name => 'dying foo') }
-      end
-      after(:all) do
-        rec.history.delete_all
-      end
-
-      subject { rec.destroy }
-
-      it { expect { subject }.to_not raise_error }
-      it { expect { rec.reload }.to raise_error(ActiveRecord::RecordNotFound) }
-
-      describe 'does not delete its history' do
-        subject { record.name }
-
-        context do
-          let(:record) { rec.as_of(rec.ts.first) }
-          it { is_expected.to eq 'alive foo' }
-        end
-
-        context do
-          let(:record) { rec.as_of(rec.ts.last) }
-          it { is_expected.to eq 'dying foo' }
-        end
-
-        context do
-          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 { is_expected.to eq ['alive foo', 'dying foo'] }
-        end
-      end
-    end
-  end
-
-end

data/spec/chrono_model/time_machine/model_identification_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-require 'support/time_machine/structure'
-
-describe ChronoModel::TimeMachine do
-  include ChronoTest::TimeMachine::Helpers
-
-  adapter.create_table 'plains' do |t|
-    t.string :foo
-  end
-
-  class ::Plain < ActiveRecord::Base
-  end
-
-  describe '.chrono?' do
-    subject { model.chrono? }
-
-    context 'on a temporal model' do
-      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
-      let(:model) { Plain }
-      it { expect { subject }.to raise_error(NoMethodError) }
-    end
-  end
-end

data/spec/chrono_model/time_machine/sequence_spec.rb

@@ -1,74 +0,0 @@
-require 'spec_helper'
-require 'support/time_machine/structure'
-
-describe ChronoModel::TimeMachine do
-  include ChronoTest::TimeMachine::Helpers
-
-  describe '#pred' do
-    context 'on the first history entry' do
-      subject { $t.foo.history.first.pred }
-      it { is_expected.to be(nil) }
-    end
-
-    context 'on the second history entry' do
-      subject { $t.foo.history.second.pred }
-      it { is_expected.to eq $t.foo.history.first }
-    end
-
-    context 'on the last history entry' do
-      subject { $t.foo.history.last.pred }
-      it { is_expected.to eq $t.foo.history[$t.foo.history.size - 2] }
-    end
-
-    context 'on records having history' do
-      subject { $t.bar.pred }
-      it { expect(subject.name).to eq 'bar bar' }
-    end
-
-    context 'when there is enough history' do
-      subject { $t.bar.pred.pred.pred.pred }
-      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 { is_expected.to be(nil) }
-
-      after { record.destroy.history.delete_all }
-    end
-  end
-
-  describe '#succ' do
-    context 'on the first history entry' do
-      subject { $t.foo.history.first.succ }
-
-      it { is_expected.to eq $t.foo.history.second }
-    end
-
-    context 'on the second history entry' do
-      subject { $t.foo.history.second.succ }
-
-      it { is_expected.to eq $t.foo.history.third }
-    end
-
-    context 'on the last history entry' do
-      subject { $t.foo.history.last.succ }
-
-      it { is_expected.to be(nil) }
-    end
-  end
-
-  describe '#first' do
-    subject { $t.foo.history.sample.first }
-    it { is_expected.to eq $t.foo.history.first }
-  end
-
-  describe '#last' do
-    subject { $t.foo.history.sample.last }
-    it { is_expected.to eq $t.foo.history.last }
-  end
-
-end

data/spec/chrono_model/time_machine/sti_spec.rb

@@ -1,100 +0,0 @@
-require 'spec_helper'
-require 'support/time_machine/structure'
-
-# STI cases
-#
-# - https://github.com/ifad/chronomodel/issues/5
-# - https://github.com/ifad/chronomodel/issues/47
-#
-describe 'models with STI' do
-  include ChronoTest::TimeMachine::Helpers
-
-  adapter.create_table 'elements', :temporal => true do |t|
-    t.string :title
-    t.string :type
-  end
-
-  class ::Element < ActiveRecord::Base
-    include ChronoModel::TimeMachine
-  end
-
-  class ::Publication < Element
-  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
-
-  describe 'timeline' do
-    let(:publication) do
-      pub = ts_eval { Publication.create! :title => 'wrong title' }
-      ts_eval(pub) { update_attributes! :title => 'correct title' }
-
-      pub
-    end
-
-    it { expect(publication.history.map(&:title)).to eq ['wrong title', 'correct title'] }
-  end
-
-  describe 'identity' do
-    adapter.create_table 'animals', temporal: true do |t|
-      t.string :type
-    end
-
-    class ::Animal < ActiveRecord::Base
-      include ChronoModel::TimeMachine
-    end
-
-    class ::Dog < Animal
-    end
-
-    class ::Goat < Animal
-    end
-
-    before do
-      Dog.create!
-      @later = Time.new
-      Goat.create!
-    end
-
-    after do
-      tables = ['temporal.animals', 'history.animals']
-      ActiveRecord::Base.connection.execute "truncate #{tables.join(', ')} cascade"
-    end
-
-    specify "select" do
-      expect(Animal.first).to be_a(Animal)
-      expect(Animal.as_of(@later).first).to be_a(Animal)
-
-      expect(Animal.where(type: 'Dog').first).to be_a(Dog)
-      expect(Dog.first).to be_a(Dog)
-      expect(Dog.as_of(@later).first).to be_a(Dog)
-
-      expect(Animal.where(type: 'Goat').first).to be_a(Goat)
-      expect(Goat.first).to be_a(Goat)
-      expect(Goat.as_of(@later).first).to be(nil)
-      expect(Goat.as_of(Time.now).first).to be_a(Goat)
-    end
-
-    specify "count" do
-      expect(Animal.count).to eq(2)
-      expect(Animal.as_of(@later).count).to eq(1)
-
-      expect(Dog.count).to eq(1)
-      expect(Dog.as_of(@later).count).to eq(1)
-
-      expect(Goat.count).to eq(1)
-      expect(Goat.as_of(@later).count).to eq(0)
-    end
-  end
-end