chrono_model 1.2.0 → 1.2.1

data/spec/chrono_model/{time_query_spec.rb → time_machine/time_query_spec.rb}

@@ -1,13 +1,30 @@
 require 'spec_helper'
-require 'support/helpers'
+require 'support/time_machine/structure'
 
 describe ChronoModel::TimeMachine::TimeQuery do
-  include ChronoTest::Helpers::TimeMachine
+  include ChronoTest::TimeMachine::Helpers
 
-  setup_schema!
-  define_models!
+  adapter.create_table 'events' do |t|
+    t.string :name
+    t.daterange :interval
+  end
+
+  class ::Event < ActiveRecord::Base
+    extend ChronoModel::TimeMachine::TimeQuery
+  end
 
-  # Create a set of events
+  # Main timeline quick test
+  #
+  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 { expect(Foo.history.past.size).to eq 2 }
+
+  # Extended thorough test.
+  #
+  # Create a set of events and then run time queries on them.
   #
   think   = Event.create! name: 'think',   interval: (15.days.ago.to_date...13.days.ago.to_date)
   plan    = Event.create! name: 'plan',    interval: (14.days.ago.to_date...12.days.ago.to_date)

data/spec/chrono_model/time_machine/timeline_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+require 'support/time_machine/structure'
+
+describe ChronoModel::TimeMachine do
+  include ChronoTest::TimeMachine::Helpers
+
+  describe '#timeline' do
+    split = lambda {|ts| ts.map!{|t| [t.to_i, t.usec]} }
+
+    timestamps_from = lambda {|*records|
+      records.map(&:history).flatten!.inject([]) {|ret, rec|
+        ret.push [rec.valid_from.to_i, rec.valid_from.usec] if rec.try(:valid_from)
+        ret.push [rec.valid_to  .to_i, rec.valid_to  .usec] if rec.try(:valid_to)
+        ret
+      }.sort.uniq
+    }
+
+    describe 'on records having an :has_many relationship' do
+      describe 'by default returns timestamps of the record only' do
+        subject { split.call($t.foo.timeline) }
+
+        it { expect(subject.size).to eq $t.foo.ts.size }
+        it { is_expected.to eq timestamps_from.call($t.foo) }
+      end
+
+      describe 'when asked, returns timestamps including the related objects' do
+        subject { split.call($t.foo.timeline(with: :bars)) }
+
+        it { expect(subject.size).to eq($t.foo.ts.size + $t.bar.ts.size) }
+        it { is_expected.to eq(timestamps_from.call($t.foo, *$t.foo.bars)) }
+      end
+    end
+
+    describe 'on records using has_timeline :with' do
+      subject { split.call($t.bar.timeline) }
+
+      describe 'returns timestamps of the record and its associations' do
+
+        let!(:expected) do
+          creat = $t.bar.history.first.valid_from
+          c_sec, c_usec = creat.to_i, creat.usec
+
+          timestamps_from.call($t.foo, $t.bar).reject {|sec, usec|
+            sec < c_sec || ( sec == c_sec && usec < c_usec )
+          }
+        end
+
+        it { expect(subject.size).to eq expected.size }
+        it { is_expected.to eq expected }
+      end
+    end
+
+    describe 'on non-temporal records using has_timeline :with' do
+      subject { split.call($t.baz.timeline) }
+
+      describe 'returns timestamps of its temporal associations' do
+        it { expect(subject.size).to eq $t.bar.ts.size }
+        it { is_expected.to eq timestamps_from.call($t.bar) }
+      end
+    end
+  end
+
+end

data/spec/chrono_model/time_machine/timestamps_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'support/time_machine/structure'
+
+describe ChronoModel::TimeMachine do
+  include ChronoTest::TimeMachine::Helpers
+
+  history_methods = %w( valid_from valid_to recorded_at )
+  current_methods = %w( as_of_time )
+
+  context 'on history records' do
+    let(:record) { $t.foo.history.first }
+
+    (history_methods + current_methods).each do |attr|
+      describe ['#', attr].join do
+        subject { record.public_send(attr) }
+
+        it { is_expected.to be_present }
+        it { is_expected.to be_a(Time) }
+        it { is_expected.to be_utc }
+      end
+    end
+  end
+
+  context 'on current records' do
+    let(:record) { $t.foo }
+
+    history_methods.each do |attr|
+      describe ['#', attr].join do
+        subject { record.public_send(attr) }
+
+        it { expect { subject }.to raise_error(NoMethodError) }
+      end
+    end
+
+    current_methods.each do |attr|
+      describe ['#', attr].join do
+        subject { record.public_send(attr) }
+
+        it { is_expected.to be(nil) }
+      end
+    end
+  end
+end

data/spec/chrono_model/time_machine/transactions_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+require 'support/time_machine/structure'
+
+describe ChronoModel::TimeMachine do
+  include ChronoTest::TimeMachine::Helpers
+
+  # Transactions
+  context 'multiple updates to an existing record' do
+    let!(:r1) do
+      Foo.create!(:name => 'xact test').tap do |record|
+        Foo.transaction do
+          record.update_attribute 'name', 'lost into oblivion'
+          record.update_attribute 'name', 'does work'
+        end
+      end
+    end
+
+    it "generate only a single history record" do
+      expect(r1.history.size).to eq(2)
+
+      expect(r1.history.first.name).to eq 'xact test'
+      expect(r1.history.last.name).to  eq 'does work'
+    end
+
+    after do
+      r1.destroy
+      r1.history.delete_all
+    end
+  end
+
+  context 'insertion and subsequent update' do
+    let!(:r2) do
+      Foo.transaction do
+        Foo.create!(:name => 'lost into oblivion').tap do |record|
+          record.update_attribute 'name', 'I am Bar'
+          record.update_attribute 'name', 'I am Foo'
+        end
+      end
+    end
+
+    it 'generates a single history record' do
+      expect(r2.history.size).to eq(1)
+      expect(r2.history.first.name).to eq 'I am Foo'
+    end
+
+    after do
+      r2.destroy
+      r2.history.delete_all
+    end
+  end
+
+  context 'insertion and subsequent deletion' do
+    let!(:r3) do
+      Foo.transaction do
+        Foo.create!(:name => 'it never happened').destroy
+      end
+    end
+
+    it 'does not generate any history' do
+      expect(Foo.history.where(:id => r3.id)).to be_empty
+    end
+
+    after do
+      r3.destroy
+      r3.history.delete_all
+    end
+  end
+
+end

data/spec/support/adapter/helpers.rb

@@ -0,0 +1,53 @@
+module ChronoTest::Adapter
+
+  module Helpers
+    def self.included(base)
+      base.extend DSL
+
+      base.instance_eval do
+        delegate :adapter, :to => ChronoTest
+        delegate :columns, :table, :pk_type, :to => DSL
+      end
+    end
+
+    module DSL
+      def with_temporal_table(&block)
+        context ':temporal => true' do
+          before(:all) { adapter.create_table(table, :temporal => true, &DSL.columns) }
+          after(:all)  { adapter.drop_table table }
+
+          instance_eval(&block)
+        end
+      end
+
+      def with_plain_table(&block)
+        context ':temporal => false' do
+          before(:all) { adapter.create_table(table, :temporal => false, &DSL.columns) }
+          after(:all)  { adapter.drop_table table }
+
+          instance_eval(&block)
+        end
+      end
+
+      def self.table(table = nil)
+        @table = table if table
+        @table
+      end
+
+      def self.columns(&block)
+        @columns = block.call if block
+        @columns
+      end
+
+      def self.pk_type
+        @pk_type ||= if ActiveRecord::VERSION::MAJOR == 5 && ActiveRecord::VERSION::MINOR >= 1
+          'bigint'
+        else
+          'integer'
+        end
+      end
+      delegate :columns, :table, :pk_type, :to => self
+    end
+  end
+
+end

data/spec/support/adapter/structure.rb

@@ -0,0 +1,44 @@
+require 'support/adapter/helpers'
+
+# This module contains the definition of a test structure that is used by the
+# adapter methods tests, that look up in the database directly whether the
+# expected objects have been created.
+#
+# The structure defintiion below serves as a blueprint of what it can be
+# defined, ans as a reference of what it is expected to have been created by
+# the +ChronoModel::Adapter+ methods.
+#
+module ChronoTest::Adapter
+
+  module Structure
+    extend ActiveSupport::Concern
+
+    included do
+      table 'test_table'
+      subject { table }
+
+      columns do
+        native = [
+          ['test', 'character varying'],
+          ['foo',  'integer'],
+          ['bar',  'double precision'],
+          ['baz',  'text']
+        ]
+
+        def native.to_proc
+          proc {|t|
+            t.string  :test, null: false, default: 'default-value'
+            t.integer :foo
+            t.float   :bar
+            t.text    :baz
+            t.integer :ary, array: true, null: false, default: []
+            t.boolean :bool, null: false, default: false
+          }
+        end
+
+        native
+      end
+    end
+  end
+
+end

data/spec/support/time_machine/helpers.rb

@@ -0,0 +1,47 @@
+module ChronoTest::TimeMachine
+
+  # This module contains helpers used throughout the
+  # +ChronoModel::TimeMachine+ specs.
+  #
+  module Helpers
+    def self.included(base)
+      base.extend(self)
+    end
+
+    def adapter
+      ChronoTest.connection
+    end
+
+    def with_revert
+      adapter.transaction do
+        adapter.create_savepoint 'revert'
+
+        yield
+
+        adapter.exec_rollback_to_savepoint 'revert'
+      end
+    end
+
+    # If a context object is given, evaluates the given
+    # block in its instance context, then defines a `ts`
+    # on it, backed by an Array, and adds the current
+    # database timestamp to it.
+    #
+    # If a context object is not given, the block is
+    # evaluated in the current context and the above
+    # mangling is done on the blocks' return value.
+    #
+    def ts_eval(ctx = nil, &block)
+      ret = (ctx || self).instance_eval(&block)
+      (ctx || ret).tap do |obj|
+        obj.singleton_class.instance_eval do
+          define_method(:ts) { @_ts ||= [] }
+        end unless obj.methods.include?(:ts)
+
+        now = ChronoTest.connection.select_value('select now()::timestamp') + 'Z'
+        obj.ts.push(Time.parse(now))
+      end
+    end
+  end
+
+end

data/spec/support/time_machine/structure.rb

@@ -0,0 +1,111 @@
+require 'support/time_machine/helpers'
+
+# This module contains the test DDL and models used by most of the
+# +TimeMachine+ specs.
+#
+# The models exercise different ActiveRecord features.
+#
+# They look candidate of unwinding by their respective specs, however this
+# test suite aims also at testing within a "real" use case scenario, in which
+# multiple models are defined and they interact - with their AR side effects,
+# still ChronoModel should provide the expected results.
+#
+# The +$t+ global variable holds a timeline of events that have happened in
+# the form of .create! and update_attributes, that aim to mimic the most of
+# AR with the least of the effort. Full coverage exercises are most welcome.
+#
+module ChronoTest::TimeMachine
+  include ChronoTest::TimeMachine::Helpers
+
+  # Set up database structure
+  #
+  adapter.create_table 'foos', :temporal => true do |t|
+    t.string     :name
+    t.integer    :fooity
+  end
+
+  class ::Foo < ActiveRecord::Base
+    include ChronoModel::TimeMachine
+
+    has_many :bars
+    has_many :sub_bars, :through => :bars
+  end
+
+
+  adapter.create_table 'bars', :temporal => true do |t|
+    t.string     :name
+    t.references :foo
+  end
+
+  class ::Bar < ActiveRecord::Base
+    include ChronoModel::TimeMachine
+
+    belongs_to :foo
+    has_many :sub_bars
+    has_one :baz
+
+    has_timeline :with => :foo
+  end
+
+
+  adapter.create_table 'sub_bars', :temporal => true do |t|
+    t.string     :name
+    t.references :bar
+  end
+
+  class ::SubBar < ActiveRecord::Base
+    include ChronoModel::TimeMachine
+
+    belongs_to :bar
+
+    has_timeline :with => :bar
+  end
+
+
+  adapter.create_table 'bazs' do |t|
+    t.string     :name
+    t.references :bar
+  end
+
+  class ::Baz < ActiveRecord::Base
+    include ChronoModel::TimeGate
+
+    belongs_to :bar
+
+    has_timeline :with => :bar
+  end
+
+  # Master timeline, used in multiple specs. It is defined here
+  # as a global variable to be able to be shared across specs.
+  #
+  $t = Struct.new(:foo, :bar, :baz, :subbar, :foos, :bars).new
+
+  # Set up associated records, with intertwined updates
+  #
+  $t.foo = ts_eval { Foo.create! :name => 'foo', :fooity => 1 }
+  ts_eval($t.foo) { update_attributes! :name => 'foo bar' }
+
+  #
+  $t.bar = ts_eval { Bar.create! :name => 'bar', :foo => $t.foo }
+  ts_eval($t.bar) { update_attributes! :name => 'foo bar' }
+
+  #
+  $t.subbar = ts_eval { SubBar.create! :name => 'sub-bar', :bar => $t.bar }
+  ts_eval($t.subbar) { update_attributes! :name => 'bar sub-bar' }
+
+  ts_eval($t.foo) { update_attributes! :name => 'new foo' }
+
+  ts_eval($t.bar) { update_attributes! :name => 'bar bar' }
+  ts_eval($t.bar) { update_attributes! :name => 'new bar' }
+
+  ts_eval($t.subbar) { update_attributes! :name => 'sub-bar sub-bar' }
+  ts_eval($t.subbar) { update_attributes! :name => 'new sub-bar' }
+
+  #
+  $t.foos = Array.new(2) {|i| ts_eval { Foo.create! :name => "foo #{i}" } }
+  $t.bars = Array.new(2) {|i| ts_eval { Bar.create! :name => "bar #{i}", :foo => $t.foos[i] } }
+
+  #
+  $t.baz = Baz.create :name => 'baz', :bar => $t.bar
+
+end