chrono_model 0.5.3 → 0.8.0

data/spec/support/matchers/index.rb

@@ -10,6 +10,10 @@ module ChronoTest::Matchers
         @schema  = schema
       end
 
+      def description
+        'have index'
+      end
+
       def matches?(table)
         super(table)
 

data/spec/support/matchers/schema.rb

@@ -10,6 +10,10 @@ module ChronoTest::Matchers
         @expected = '"$user", public' if @expected == :default
       end
 
+      def description
+        'be in schema'
+      end
+
       def failure_message_for_should
         "expected to be in schema #@expected, but was in #@current"
       end

data/spec/support/matchers/table.rb

@@ -35,6 +35,10 @@ module ChronoTest::Matchers
         relation_exists? :in => public_schema
       end
 
+      def description
+        'be in the public schema'
+      end
+
       def failure_message_for_should
         "expected #{table} to exist in the #{public_schema} schema"
       end
@@ -55,6 +59,10 @@ module ChronoTest::Matchers
         relation_exists? :in => temporal_schema
       end
 
+      def description
+        'be in the temporal schema'
+      end
+
       def failure_message_for_should
         "expected #{table} to exist in the #{temporal_schema} schema"
       end
@@ -73,14 +81,23 @@ module ChronoTest::Matchers
       def matches?(table)
         super(table)
 
-        table_exists? && inherits_from_temporal?
+        table_exists?           &&
+        inherits_from_temporal? &&
+        has_consistency_constraint? &&
+        has_history_indexes?
+      end
+
+      def description
+        'be in history schema'
       end
 
       def failure_message_for_should
         "expected #{table} ".tap do |message|
           message << [
             ("to exist in the #{history_schema} schema"    unless @existance),
-            ("to inherit from #{temporal_schema}.#{table}" unless @inheritance)
+            ("to inherit from #{temporal_schema}.#{table}" unless @inheritance),
+            ("to have a timeline consistency constraint"   unless @constraint),
+            ("to have history indexes"                     unless @indexes)
           ].compact.to_sentence
         end
       end
@@ -101,6 +118,58 @@ module ChronoTest::Matchers
             )
           SQL
         end
+
+        def has_history_indexes?
+          binds = [ history_schema, table ]
+
+          indexes = select_values(<<-SQL, binds, 'Check history indexes')
+            SELECT indexdef FROM pg_indexes
+             WHERE schemaname = $1
+               AND tablename  = $2
+          SQL
+
+          fqtn = [history_schema, table].join('.')
+
+          expected = [
+            "CREATE INDEX index_#{table}_temporal_on_lower_validity ON #{fqtn} USING btree (lower(validity))",
+            "CREATE INDEX index_#{table}_temporal_on_upper_validity ON #{fqtn} USING btree (upper(validity))",
+            "CREATE INDEX index_#{table}_temporal_on_validity ON #{fqtn} USING gist (validity)",
+
+            "CREATE INDEX #{table}_inherit_pkey ON #{fqtn} USING btree (id)",
+            "CREATE INDEX #{table}_instance_history ON #{fqtn} USING btree (id, recorded_at)",
+            "CREATE UNIQUE INDEX #{table}_pkey ON #{fqtn} USING btree (hid)",
+            "CREATE INDEX #{table}_recorded_at ON #{fqtn} USING btree (recorded_at)",
+            "CREATE INDEX #{table}_timeline_consistency ON #{fqtn} USING gist (id, validity)"
+          ]
+
+          @indexes = (expected - indexes).empty?
+        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
+          ]
+
+          @constraint = select_value(<<-SQL, binds, 'Check Consistency Constraint') == 't'
+            SELECT EXISTS (
+              SELECT 1 FROM pg_catalog.pg_constraint
+              WHERE conname = $1
+                AND contype = 'x'
+                AND conrelid = $3::regclass
+                AND connamespace = (
+                  SELECT oid FROM pg_catalog.pg_namespace WHERE nspname = $2
+                )
+                AND conkey = (
+                  SELECT array_agg(attnum) FROM pg_catalog.pg_attribute
+                  WHERE attname IN ($4, 'validity')
+                    AND attrelid = $3::regclass
+                )
+            )
+          SQL
+        end
     end
 
     def have_history_backing
@@ -110,23 +179,27 @@ module ChronoTest::Matchers
 
     # ##################################################################
     # Checks that a table exists in the Public schema, is an updatable
-    # view and has an INSERT, UPDATE and DELETE rule.
+    # view and has an INSERT, UPDATE and DELETE triggers.
     #
     class HavePublicInterface < Base
       def matches?(table)
         super(table)
 
-        view_exists? && [ is_updatable?, has_rules? ].all?
+        view_exists? && [ is_updatable?, has_triggers? ].all?
+      end
+
+      def description
+        'be an updatable view'
       end
 
       def failure_message_for_should
         "expected #{table} ".tap do |message|
           message << [
-            ("to exist in the #{public_schema} schema" unless @existance  ),
-            ('to be an updatable view'                 unless @updatable  ),
-            ('to have an INSERT rule'                  unless @insert_rule),
-            ('to have an UPDATE rule'                  unless @update_rule),
-            ('to have a DELETE rule'                   unless @delete_rule)
+            ("to exist in the #{public_schema} schema" unless @existance     ),
+            ('to be an updatable view'                 unless @updatable     ),
+            ('to have an INSERT trigger'               unless @insert_trigger),
+            ('to have an UPDATE trigger'               unless @update_trigger),
+            ('to have a DELETE trigger'                unless @delete_trigger)
           ].compact.to_sentence
         end
       end
@@ -145,21 +218,21 @@ module ChronoTest::Matchers
           SQL
         end
 
-        def has_rules?
-          rules = select_values(<<-SQL, [ public_schema, table ], 'Check rules')
-            SELECT UNNEST(REGEXP_MATCHES(
-                definition, 'ON (INSERT|UPDATE|DELETE) TO #{table} DO INSTEAD'
-              ))
-             FROM pg_catalog.pg_rules
-            WHERE schemaname = $1
-              AND tablename  = $2
+        def has_triggers?
+          triggers = select_values(<<-SQL, [ public_schema, table ], 'Check triggers')
+            SELECT t.tgname
+              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;
           SQL
 
-          @insert_rule = rules.include? 'INSERT'
-          @update_rule = rules.include? 'UPDATE'
-          @delete_rule = rules.include? 'DELETE'
+          @insert_trigger = triggers.include? 'chronomodel_insert'
+          @update_trigger = triggers.include? 'chronomodel_update'
+          @delete_trigger = triggers.include? 'chronomodel_delete'
 
-          @insert_rule && @update_rule && @delete_rule
+          @insert_trigger && @update_trigger && @delete_trigger
         end
     end
 

data/spec/time_machine_spec.rb

@@ -24,6 +24,18 @@ describe ChronoModel::TimeMachine do
   #
   baz = Baz.create :name => 'baz', :bar => bar
 
+  describe '.chrono?' do
+    context 'on a temporal model' do
+      subject { Foo }
+      it { should be_chrono }
+    end
+
+    context 'on a plain model' do
+      subject { Plain }
+      it { should_not be_chrono }
+    end
+  end
+
   # Specs start here
   #
   describe '.chrono_models' do
@@ -164,12 +176,15 @@ describe ChronoModel::TimeMachine do
     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/ }
-      it { foo.history.select('max (id) as foo, min(id) as bar').first.attributes.keys.should == %w( foo bar ) }
+      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 ) }
     end
 
-    describe 'orders by recorded_at, hid by default' do
-      it { foo.history.to_sql.should =~ /order by.*recorded_at,.*hid/i }
+    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
@@ -177,12 +192,12 @@ describe ChronoModel::TimeMachine do
       it { foo.history.order('id').to_sql.should =~ /order by id/i }
     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'] }
+    context '.sorted' do
+      describe 'orders by recorded_at, hid' do
+        it { foo.history.sorted.to_sql.should =~ /order by .+"recorded_at", .+"hid"/i }
+      end
     end
+
   end
 
   describe '#pred' do
@@ -303,11 +318,10 @@ describe ChronoModel::TimeMachine do
 
     timestamps_from = lambda {|*records|
       ts = records.map(&:history).flatten!.inject([]) {|ret, rec|
-        ret.concat [
-          [rec.valid_from.to_i, rec.valid_from.usec + 2],
-          [rec.valid_to.to_i,   rec.valid_to.usec + 2]
-        ]
-      }.sort.uniq[0..-2]
+        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
@@ -425,31 +439,44 @@ describe ChronoModel::TimeMachine do
     end
   end
 
-  context do
-    let!(:history) { foo.history.first }
-    let!(:current) { foo }
+  describe 'timestamp methods' do
+    history_methods = %w( valid_from valid_to recorded_at )
+    current_methods = %w( as_of_time )
 
-    spec = lambda {|attr|
-      return lambda {|*|
-        describe 'on history records' do
-          subject { history.public_send(attr) }
+    context 'on history records' do
+      let(:record) { foo.history.first }
+
+      (history_methods + current_methods).each do |attr|
+        describe ['#', attr].join do
+          subject { record.public_send(attr) }
 
           it { should be_present }
           it { should be_a(Time) }
           it { should be_utc }
         end
+      end
+    end
 
-        describe 'on current records' do
-          subject { current.public_send(attr) }
+    context 'on current records' do
+      let(:record) { foo }
 
-          it { should be_nil }
+      history_methods.each do |attr|
+        describe ['#', attr].join do
+          subject { record.public_send(attr) }
+
+          it { expect { subject }.to raise_error(NoMethodError) }
         end
-      }
-    }
+      end
 
-    %w( valid_from valid_to recorded_at as_of_time ).each do |attr|
-      describe ['#', attr].join, &spec.call(attr)
+      current_methods.each do |attr|
+        describe ['#', attr].join do
+          subject { record.public_send(attr) }
+
+          it { should be_nil }
+        end
+      end
     end
+
   end
 
   # Class methods
@@ -507,6 +534,13 @@ describe ChronoModel::TimeMachine do
       it { Foo.history.all.map(&:name).should == foo_history }
       it { Bar.history.all.map(&:name).should == bar_history }
     end
+
+    describe '.time_query' do
+      it { Foo.history.time_query(:after, :now).count.should == 3 }
+      it { Foo.history.time_query(:before, :now).count.should == 5 }
+      it { Foo.history.past.size.should == 2 }
+    end
+
   end
 
   # Transactions

data/spec/time_query_spec.rb

@@ -0,0 +1,227 @@
+require 'spec_helper'
+require 'support/helpers'
+
+describe ChronoModel::TimeMachine::TimeQuery do
+  include ChronoTest::Helpers::TimeMachine
+
+  setup_schema!
+  define_models!
+
+  # Create a set of events
+  #
+  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)
+  collect = Event.create! name: 'collect', interval: (12.days.ago.to_date...10.days.ago.to_date)
+  start   = Event.create! name: 'start',   interval: (8.days.ago.to_date...7.days.ago.to_date)
+  build   = Event.create! name: 'build',   interval: (7.days.ago.to_date...Date.yesterday)
+  profit  = Event.create! name: 'profit',  interval: (Date.tomorrow...1.year.from_now.to_date)
+
+  describe :at do
+    describe 'with a single timestamp' do
+      subject { Event.time_query(:at, time.try(:to_date) || time, on: :interval).to_a }
+
+      context 'no records' do
+        let(:time) { 16.days.ago }
+        it { should be_empty }
+      end
+
+      context 'single record' do
+        let(:time) { 15.days.ago }
+        it { should == [think] }
+      end
+
+      context 'multiple overlapping records' do
+        let(:time) { 14.days.ago }
+        it { should =~ [think, plan] }
+      end
+
+      context 'on an edge of an open interval' do
+        let(:time) { 10.days.ago }
+        it { should be_empty }
+      end
+
+      context 'in an hole' do
+        let(:time) { 9.days.ago }
+        it { should be_empty }
+      end
+
+      context 'today' do
+        let(:time) { Date.today }
+        it { should be_empty }
+      end
+
+      context 'server-side :today' do
+        let(:time) { :today }
+        it { should be_empty }
+      end
+    end
+
+    describe 'with a range' do
+      subject { Event.time_query(:at, times.map!(&:to_date), on: :interval, type: :daterange).to_a }
+
+      context 'that is empty' do
+        let(:times) { [ 14.days.ago, 14.days.ago ] }
+        it { should be_empty }
+      end
+
+      context 'overlapping no records' do
+        let(:times) { [ 20.days.ago, 16.days.ago ] }
+        it { should be_empty }
+      end
+
+      context 'overlapping a single record' do
+        let(:times) { [ 16.days.ago, 14.days.ago ] }
+        it { should == [think] }
+      end
+
+      context 'overlapping more records' do
+        let(:times) { [ 16.days.ago, 11.days.ago ] }
+        it { should =~ [think, plan, collect] }
+      end
+
+      context 'on the edge of an open interval and an hole' do
+        let(:times) { [ 10.days.ago, 9.days.ago ] }
+        it { should be_empty }
+      end
+    end
+  end
+
+  describe :before do
+    subject { Event.time_query(:before, time.try(:to_date) || time, on: :interval, type: :daterange).to_a }
+
+    context '16 days ago' do
+      let(:time) { 16.days.ago }
+      it { should be_empty }
+    end
+
+    context '14 days ago' do
+      let(:time) { 14.days.ago }
+      it { should == [think] }
+    end
+
+    context '11 days ago' do
+      let(:time) { 11.days.ago }
+      it { should =~ [think, plan, collect] }
+    end
+
+    context '10 days ago' do
+      let(:time) { 10.days.ago }
+      it { should =~ [think, plan, collect] }
+    end
+
+    context '8 days ago' do
+      let(:time) { 8.days.ago }
+      it { should =~ [think, plan, collect] }
+    end
+
+    context 'today' do
+      let(:time) { Date.today }
+      it { should =~ [think, plan, collect, start, build] }
+    end
+
+    context ':today' do
+      let(:time) { :today }
+      it { should =~ [think, plan, collect, start, build] }
+    end
+  end
+
+  describe :after do
+    subject { Event.time_query(:after, time.try(:to_date) || time, on: :interval, type: :daterange).to_a }
+
+    context 'one month ago' do
+      let(:time) { 1.month.ago }
+      it { should =~ [think, plan, collect, start, build, profit] }
+    end
+
+    context '10 days ago' do
+      let(:time) { 10.days.ago }
+      it { should =~ [start, build, profit] }
+    end
+
+    context 'yesterday' do
+      let(:time) { Date.yesterday }
+      it { should == [profit] }
+    end
+
+    context 'today' do
+      let(:time) { Date.today }
+      it { should == [profit] }
+    end
+
+    context 'server-side :today' do
+      let(:time) { :today }
+      it { should == [profit] }
+    end
+
+    context 'tomorrow' do
+      let(:time) { Date.tomorrow }
+      it { should == [profit] }
+    end
+
+    context 'one month from now' do
+      let(:time) { 1.month.from_now }
+      it { should == [profit] }
+    end
+
+    context 'far future' do
+      let(:time) { 1.year.from_now }
+      it { should be_empty }
+    end
+  end
+
+  describe :not do
+    context 'with a single timestamp' do
+      subject { Event.time_query(:not, time.try(:to_date) || time, on: :interval, type: :daterange).to_a }
+
+      context '14 days ago' do
+        let(:time) { 14.days.ago }
+        it { should =~ [collect, start, build, profit] }
+      end
+
+      context '9 days ago' do
+        let(:time) { 9.days.ago }
+        it { should =~ [think, plan, collect, start, build, profit] }
+      end
+
+      context '8 days ago' do
+        let(:time) { 8.days.ago }
+        it { should =~ [think, plan, collect, build, profit] }
+      end
+
+      context 'today' do
+        let(:time) { Date.today }
+        it { should =~ [think, plan, collect, start, build, profit] }
+      end
+
+      context ':today' do
+        let(:time) { :today }
+        it { should =~ [think, plan, collect, start, build, profit] }
+      end
+
+      context '1 month from now' do
+        let(:time) { 1.month.from_now }
+        it { should =~ [think, plan, collect, start, build] }
+      end
+    end
+
+    context 'with a range' do
+      subject { Event.time_query(:not, time.map(&:to_date), on: :interval, type: :daterange).to_a }
+
+      context 'eliminating a single record' do
+        let(:time) { [1.month.ago, 14.days.ago] }
+        it { should =~ [plan, collect, start, build, profit] }
+      end
+
+      context 'eliminating multiple records' do
+        let(:time) { [1.month.ago, Date.today] }
+        it { should == [profit] }
+      end
+
+      context 'from an edge' do
+        let(:time) { [14.days.ago, 10.days.ago] }
+        it { should == [start, build, profit] }
+      end
+    end
+  end
+
+end