chrono_model 1.2.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15a81b8b75b7b77c03e9e750db3122cc0107e238696882bd67f2fe8fc7647274
-  data.tar.gz: 599dd55436b014a5db0ce7c1b003aa34ce15e3e12f08dac3e5cc0c5549823a8e
+  metadata.gz: 21c2181fc18f6dd3a5bdd89940eae284b340427bc81a4f024b6ad0686c146598
+  data.tar.gz: e7afa88021f63cd42e160a800f66e84bff1ba90f706c209df436059f70ae04e3
 SHA512:
-  metadata.gz: 2ba2dc61cc6a62e573dea411005abf071e8010bcd249b05f274afefc756b1ac85b47e6469a6c9988f3b97c3f340891606bbe32d97cd75dfc4fcf0c1f99148805
-  data.tar.gz: 2cce42ff59e611beb10929f8484b8a0ec9eb106f2284770566d51d979eb6b8bb0c0627f88a4e8d1ef0c83cd7dfbd0733b44e09b339994a0424e7114181a74bf6
+  metadata.gz: a99b96b4166a7355016840fd7e7c6cf01febc86e89b1a6e07421db89e7d234972e214a9881b9a3bea2c8210bac2f83735a0d5d7d52c877c5b60160165fc09b16
+  data.tar.gz: 84300076a2b5211d3f1f3b317c087f893c754fcec43a2b64614b1a80b53304d95d6e686b5e25144758dd5731d7cd12de662dd45b981d9e259810346e186fe75d

data/Rakefile

@@ -3,7 +3,8 @@ require "bundler/gem_tasks"
 
 # RSpec
 require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new
+spec_task = RSpec::Core::RakeTask.new
+spec_task.rspec_opts = '-f doc'
 task :default => ['testapp:create', :spec]
 
 # Create a test Rails app in tmp/railsapp for testing the rake

data/lib/chrono_model/time_machine.rb

@@ -132,7 +132,7 @@ module ChronoModel
     # Returns a boolean indicating whether this record is an history entry.
     #
     def historical?
-      self.as_of_time.present? || self.kind_of?(self.class.history)
+      self.as_of_time.present?
     end
 
     # Inhibit destroy of historical records

data/lib/chrono_model/time_machine/history_model.rb

@@ -145,6 +145,10 @@ module ChronoModel
         self.class.with_hid_pkey { super }
       end
 
+      def historical?
+        true
+      end
+
       # Returns the previous history entry, or nil if this
       # is the first one.
       #

data/lib/chrono_model/version.rb

@@ -1,3 +1,3 @@
 module ChronoModel
-  VERSION = "1.2.0"
+  VERSION = "1.2.1"
 end

data/spec/chrono_model/adapter/base_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+require 'support/adapter/structure'
+
+describe ChronoModel::Adapter do
+  include ChronoTest::Adapter::Helpers
+  include ChronoTest::Adapter::Structure
+
+  subject { adapter }
+  it { is_expected.to be_a_kind_of(ChronoModel::Adapter) }
+
+  context do
+    subject { adapter.adapter_name }
+    it { is_expected.to eq 'PostgreSQL' }
+  end
+
+  context do
+    before { expect(adapter).to receive(:postgresql_version).and_return(90300) }
+    it { is_expected.to be_chrono_supported }
+  end
+
+  context do
+    before { expect(adapter).to receive(:postgresql_version).and_return(90000) }
+    it { is_expected.to_not be_chrono_supported }
+  end
+
+  describe '.primary_key' do
+    subject { adapter.primary_key(table) }
+
+    assert = proc do
+      it { is_expected.to eq 'id' }
+    end
+
+    with_temporal_table(&assert)
+    with_plain_table(   &assert)
+  end
+
+  describe '.indexes' do
+    subject { adapter.indexes(table) }
+
+    assert = proc do
+      before(:all) do
+        adapter.add_index table, :foo,         :name => 'foo_index'
+        adapter.add_index table, [:bar, :baz], :name => 'bar_index'
+      end
+
+      it { expect(subject.map(&:name)).to match_array %w( foo_index bar_index ) }
+      it { expect(subject.map(&:columns)).to match_array [['foo'], ['bar', 'baz']] }
+    end
+
+    with_temporal_table(&assert)
+    with_plain_table(   &assert)
+  end
+
+  describe '.column_definitions' do
+    subject { adapter.column_definitions(table).map {|d| d.take(2)} }
+
+    assert = proc do
+      it { expect(subject & columns).to eq columns }
+      it { is_expected.to include(['id', pk_type]) }
+    end
+
+    with_temporal_table(&assert)
+    with_plain_table(   &assert)
+  end
+
+  describe '.on_schema' do
+    before(:all) do
+      adapter.execute 'BEGIN'
+      5.times {|i| adapter.execute "CREATE SCHEMA test_#{i}"}
+    end
+
+    after(:all) do
+      adapter.execute 'ROLLBACK'
+    end
+
+    context 'by default' do
+      it 'saves the schema at each recursion' do
+        is_expected.to be_in_schema(:default)
+
+        adapter.on_schema('test_1') { is_expected.to be_in_schema('test_1')
+          adapter.on_schema('test_2') { is_expected.to be_in_schema('test_2')
+            adapter.on_schema('test_3') { is_expected.to be_in_schema('test_3')
+            }
+            is_expected.to be_in_schema('test_2')
+          }
+          is_expected.to be_in_schema('test_1')
+        }
+
+        is_expected.to be_in_schema(:default)
+      end
+
+      context 'when errors occur' do
+        subject do
+          adapter.on_schema('test_1') do
+
+            adapter.on_schema('test_2') do
+              adapter.execute 'BEGIN'
+              adapter.execute 'ERRORING ON PURPOSE'
+            end
+
+          end
+        end
+
+        it {
+          expect { subject }.
+            to raise_error(/current transaction is aborted/).
+            and change { adapter.instance_variable_get(:@schema_search_path) }
+        }
+
+        after do
+          adapter.execute 'ROLLBACK'
+        end
+      end
+    end
+
+    context 'with recurse: :ignore' do
+      it 'ignores recursive calls' do
+        is_expected.to be_in_schema(:default)
+
+        adapter.on_schema('test_1', recurse: :ignore) { is_expected.to be_in_schema('test_1')
+          adapter.on_schema('test_2', recurse: :ignore) { is_expected.to be_in_schema('test_1')
+            adapter.on_schema('test_3', recurse: :ignore) { is_expected.to be_in_schema('test_1')
+        } } }
+
+        is_expected.to be_in_schema(:default)
+      end
+    end
+  end
+
+  describe '.is_chrono?' do
+    with_temporal_table do
+      it { expect(adapter.is_chrono?(table)).to be(true) }
+    end
+
+    with_plain_table do
+      it { expect(adapter.is_chrono?(table)).to be(false) }
+    end
+
+    context 'when schemas are not there yet' do
+      before(:all) do
+        adapter.execute 'BEGIN'
+        adapter.execute 'DROP SCHEMA temporal CASCADE'
+        adapter.execute 'DROP SCHEMA history CASCADE'
+        adapter.execute 'CREATE TABLE test_table (id integer)'
+      end
+
+      after(:all) do
+        adapter.execute 'ROLLBACK'
+      end
+
+      it { expect { adapter.is_chrono?(table) }.to_not raise_error }
+
+      it { expect(adapter.is_chrono?(table)).to be(false) }
+    end
+  end
+
+end

data/spec/chrono_model/adapter/ddl_spec.rb

@@ -0,0 +1,243 @@
+require 'spec_helper'
+require 'support/adapter/structure'
+
+describe ChronoModel::Adapter do
+  include ChronoTest::Adapter::Helpers
+  include ChronoTest::Adapter::Structure
+
+  let(:current) { [ChronoModel::Adapter::TEMPORAL_SCHEMA, table].join('.') }
+  let(:history) { [ChronoModel::Adapter::HISTORY_SCHEMA,  table].join('.') }
+
+  def count(table)
+    adapter.select_value("SELECT COUNT(*) FROM ONLY #{table}").to_i
+  end
+
+  def ids(table)
+    adapter.select_values("SELECT id FROM ONLY #{table} ORDER BY id")
+  end
+
+  context 'INSERT multiple values' do
+    before :all do
+      adapter.create_table table, :temporal => true, &columns
+    end
+
+    after :all do
+      adapter.drop_table table
+    end
+
+    context 'when succeeding' do
+      def insert
+        adapter.execute <<-SQL
+          INSERT INTO #{table} (test, foo) VALUES
+            ('test1', 1),
+            ('test2', 2);
+        SQL
+      end
+
+      it { expect { insert }.to_not raise_error }
+      it { expect(count(current)).to eq 2 }
+      it { expect(count(history)).to eq 2 }
+    end
+
+    context 'when failing' do
+      def insert
+        adapter.execute <<-SQL
+          INSERT INTO #{table} (test, foo) VALUES
+            ('test3', 3),
+            (NULL,    0);
+        SQL
+      end
+
+      it { expect { insert }.to raise_error(ActiveRecord::StatementInvalid) }
+      it { expect(count(current)).to eq 2 } # Because the previous
+      it { expect(count(history)).to eq 2 } # records are preserved
+    end
+
+    context 'after a failure' do
+      def insert
+        adapter.execute <<-SQL
+          INSERT INTO #{table} (test, foo) VALUES
+            ('test4', 3),
+            ('test5', 4);
+        SQL
+      end
+
+      it { expect { insert }.to_not raise_error }
+
+      it { expect(count(current)).to eq 4 }
+      it { expect(count(history)).to eq 4 }
+
+      it { expect(ids(current)).to eq ids(history) }
+    end
+  end
+
+  context 'INSERT on NOT NULL columns but with a DEFAULT value' do
+    before :all do
+      adapter.create_table table, :temporal => true, &columns
+    end
+
+    after :all do
+      adapter.drop_table table
+    end
+
+    def insert
+      adapter.execute <<-SQL
+        INSERT INTO #{table} DEFAULT VALUES
+      SQL
+    end
+
+    def select
+      adapter.select_values <<-SQL
+        SELECT test FROM #{table}
+      SQL
+    end
+
+    it { expect { insert }.to_not raise_error }
+    it { insert; expect(select.uniq).to eq ['default-value'] }
+  end
+
+  context 'redundant UPDATEs' do
+
+    before :all do
+      adapter.create_table table, :temporal => true, &columns
+
+      adapter.execute <<-SQL
+        INSERT INTO #{table} (test, foo) VALUES ('test1', 1);
+      SQL
+
+      adapter.execute <<-SQL
+        UPDATE #{table} SET test = 'test2';
+      SQL
+
+      adapter.execute <<-SQL
+        UPDATE #{table} SET test = 'test2';
+      SQL
+    end
+
+    after :all do
+      adapter.drop_table table
+    end
+
+    it { expect(count(current)).to eq 1 }
+    it { expect(count(history)).to eq 2 }
+
+  end
+
+  context 'updates on non-journaled fields' do
+    before :all do
+      adapter.create_table table, :temporal => true do |t|
+        t.string 'test'
+        t.timestamps null: false
+      end
+
+      adapter.execute <<-SQL
+        INSERT INTO #{table} (test, created_at, updated_at) VALUES ('test', now(), now());
+      SQL
+
+      adapter.execute <<-SQL
+        UPDATE #{table} SET test = 'test2', updated_at = now();
+      SQL
+
+      2.times do
+        adapter.execute <<-SQL # Redundant update with only updated_at change
+          UPDATE #{table} SET test = 'test2', updated_at = now();
+        SQL
+
+        adapter.execute <<-SQL
+          UPDATE #{table} SET updated_at = now();
+        SQL
+      end
+    end
+
+    after :all do
+      adapter.drop_table table
+    end
+
+    it { expect(count(current)).to eq 1 }
+    it { expect(count(history)).to eq 2 }
+  end
+
+  context 'selective journaled fields' do
+    describe 'basic behaviour' do
+      specify do
+        adapter.create_table table, :temporal => true, :journal => %w( foo ) do |t|
+          t.string 'foo'
+          t.string 'bar'
+        end
+
+        adapter.execute <<-SQL
+          INSERT INTO #{table} (foo, bar) VALUES ('test foo', 'test bar');
+        SQL
+
+        adapter.execute <<-SQL
+          UPDATE #{table} SET foo = 'test foo', bar = 'no history';
+        SQL
+
+        2.times do
+          adapter.execute <<-SQL
+            UPDATE #{table} SET bar = 'really no history';
+          SQL
+        end
+
+        expect(count(current)).to eq 1
+        expect(count(history)).to eq 1
+
+        adapter.drop_table table
+      end
+    end
+
+    describe 'schema changes' do
+      table 'journaled_things'
+
+      before do
+        adapter.create_table table, :temporal => true, :journal => %w( foo ) do |t|
+          t.string 'foo'
+          t.string 'bar'
+          t.string 'baz'
+        end
+      end
+
+      after do
+        adapter.drop_table table
+      end
+
+      it 'preserves options upon column change' do
+        adapter.change_table table, temporal: true, journal: %w(foo bar)
+
+        adapter.execute <<-SQL
+          INSERT INTO #{table} (foo, bar) VALUES ('test foo', 'test bar');
+        SQL
+
+        expect(count(current)).to eq 1
+        expect(count(history)).to eq 1
+
+        adapter.execute <<-SQL
+          UPDATE #{table} SET foo = 'test foo', bar = 'chronomodel';
+        SQL
+
+        expect(count(current)).to eq 1
+        expect(count(history)).to eq 2
+      end
+
+      it 'changes option upon table change' do
+        adapter.change_table table, temporal: true, journal: %w(bar)
+
+        adapter.execute <<-SQL
+          INSERT INTO #{table} (foo, bar) VALUES ('test foo', 'test bar');
+          UPDATE #{table} SET foo = 'test foo', bar = 'no history';
+        SQL
+
+        expect(count(current)).to eq 1
+        expect(count(history)).to eq 1
+
+        adapter.execute <<-SQL
+          UPDATE #{table} SET foo = 'test foo again', bar = 'no history';
+        SQL
+
+        expect(count(current)).to eq 1
+        expect(count(history)).to eq 1
+      end
+    end
+  end
+
+end