hoodoo 1.2.0 → 1.2.1

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MjI0N2Q4YmRmMTIyYzA5NDhiZTdmYjY3YjBiNDg2ZWI4ZTQ5ODU2MQ==
+    OWM1YWFkNDAxZGQ1MGUyZTNmNTIyZjk3MGYxMzNmYjRlYzZiYmRmYw==
   data.tar.gz: !binary |-
-    M2U5ZjY5OTEyZWI4Y2NiN2M5M2VjM2MyNzYyZWQyNGQ3YzdmZThkZQ==
+    YjRmZDVjYjk1YzBkMjU2ODczMGU3YTJjYzZhMjdjYTE1ZDgyYzE1NA==
 SHA512:
   metadata.gz: !binary |-
-    Mjc4MGE2ZjMyMDNkNGMzYTViNzM5YmEyOTQ1M2M1ZTgyZGYwNjA4N2M1ZThl
-    ODNkOTZjNTcwNjQyNmY2OGRmMmRlOTE5ZTEyZTljYTg3MTI5MjZlNmIzYzY2
-    NTUwZWQ0ZmVjZDgxNzRkYzRmZWQ0YTAwM2U2MzE2NWNiMTNmYjI=
+    ZTRiOGNkNjYzOTE3YjJkYWE0N2M4ZjdkZTllM2JhMTkwMTFjMTM1NWJjYTU5
+    YTVkMThjYjZkMmU3ZGJiMTk0NzM1YmRlNWZiZTk4ZTgxYTQwMGNlMTE2YjAy
+    ZTc4OTNiNGY5Mjg3MDc0NGI1MDg5OTg2MmU5YzFlNzczZTM1NTA=
   data.tar.gz: !binary |-
-    MjY2N2QwNjViZjhiYjM1NDBkNDczMGVkNDVlOTczYzVlOTRlYzM2NGQ4ODEx
-    NDFkNDI4YjI1NmYzZTVlNmNmYjdiMDhlZWU1NDk1YTRhNjg1YzE0YjNmZDY2
-    ZmM5NWM5MTc5OTEyOGQzN2I4MTUwMDE2NTRlNGQ5NTQ3MWVjYjY=
+    ZmFiZTNiZDZhZGI4NzA0NzAyYWM4ZTI3YTAxM2E5OTRlYzNlN2NkZWM4ZDUx
+    Y2NkNmJmZTA4Njg3N2EyNmQwMmY3YThmOGM4NWFiNmI3MTRmMDEzNWQ4MmFj
+    ZjI3NTJmNzVmYTgxOGNkYWEwOTA3OWExNGFlZDkzYzQzMDFmZmI=

data/lib/hoodoo/active/active_record/manually_dated.rb

@@ -189,6 +189,10 @@ module Hoodoo
     #       #
     #       TABLES_TO_CONVERT = [ :table_name, :another_table_name, ... ]
     #
+    #       # This will come in handy later.
+    #       #
+    #       SQL_DATE_MAXIMUM = ActiveRecord::Base.connection.quoted_date( Hoodoo::ActiveRecord::ManuallyDated::DATE_MAXIMUM )
+    #
     #       def up
     #
     #         # If you have any uniqueness constraints on this table, you'll need to
@@ -211,9 +215,17 @@ module Hoodoo
     #           add_column table, :effective_end,   :datetime, :null  => true # (initially, but see below)
     #           add_column table, :uuid,            :string,   :limit => 32
     #
-    #           add_index table, [        :effective_start, :effective_end ],                  :name => "index_#{ table }_start_end"
-    #           add_index table, [ :uuid, :effective_start, :effective_end ],                  :name => "index_#{ table }_id_start_end"
-    #           add_index table, [ :uuid,                   :effective_end ], :unique => true, :name => "index_#{ table }_id_end"
+    #           add_index table, [        :effective_start, :effective_end ], :name => "index_#{ table }_start_end"
+    #           add_index table, [ :uuid, :effective_start, :effective_end ], :name => "index_#{ table }_uuid_start_end"
+    #
+    #           # We can't allow duplicate UUIDs. Here's how to correctly scope based on
+    #           # any 'contemporary' record, given its known fixed 'effective_end'.
+    #           #
+    #           ActiveRecord::Migration.add_index table,
+    #                                             :uuid,
+    #                                             :unique => true,
+    #                                             :name   => "index_#{ table }_uuid_end_unique",
+    #                                             :where  => "(effective_end = '#{ SQL_DATE_MAXIMUM }')"
     #
     #           # If there's any data in the table already, it can't have any historic
     #           # entries. So, we want to set the UUID to the 'id' field's old value,
@@ -241,21 +253,21 @@ module Hoodoo
     #
     #         end
     #
-    #         # Now add back any indices dropped earlier, but add them as two composite
-    #         # indices each - one with just :effective_end added, the other with both
-    #         # :effective_start and :effective_end added.
-    #         #
-    #         # For example, suppose you had declared this index somewhere:
+    #         # Now add back any indices dropped earlier, but add them back as a
+    #         # conditional index as shown earlier for the "uuid" column. For example,
+    #         # suppose you had declared this index somewhere:
     #         #
     #         #   add_index :accounts, :account_number, :unique => true
     #         #
     #         # You need to have done "remove_index :accounts, :account_number" earlier;
-    #         # then now add the two new equivalents. You may well find you have to give
-    #         # them custom names to avoid hitting index name length limits in your
-    #         # database if ActiveRecord is allowed to generate a name automatically:
+    #         # then now add the new equivalent. You may well find you have to give it a
+    #         # custom name to avoid hitting index name length limits in your database:
     #         #
-    #         #   add_index :accounts, [ :account_number, :effective_start, :effective_end ],                  :name => 'index_accounts_an_es_ee'
-    #         #   add_index :accounts, [ :account_number,                   :effective_end ], :unique => true, :name => 'index_accounts_an_ee'
+    #         # ActiveRecord::Migration.add_index :accounts,
+    #         #                                   :account_number,
+    #         #                                   :unique => true,
+    #         #                                   :name   => "index_#{ table }_account_number_end_unique",
+    #         #                                   :where  => "(effective_end = '#{ SQL_DATE_MAXIMUM }')"
     #         #
     #         # You might want to perform more detailed analysis on your index
     #         # requirements once manual dating is enabled, but the above is a good rule
@@ -396,7 +408,11 @@ module Hoodoo
         def manual_dating_enabled
           self.nz_co_loyalty_hoodoo_manually_dated = true
 
-          before_save do
+          # This is the 'tightest'/innermost callback available for creation.
+          # Intentionally have nothing for updates/deletes as the high level
+          # API here must be used; we don't want to introduce any more magic.
+
+          before_create do
             now = Time.now.utc.round( SECONDS_DECIMAL_PLACES )
 
             self.created_at      ||= now
@@ -569,86 +585,83 @@ module Hoodoo
                                       attributes: context.request.body,
                                       scope:      all() )
 
-          new_record      = nil
-          retry_operation = false
+          new_record        = nil
+          retried_operation = false
 
           begin
-            begin
 
-              # 'requires_new' => exceptions in nested transactions will cause
-              # rollback; see the comment documentation for the Writer module's
-              # "persist_in" method for details.
+            # 'requires_new' => exceptions in nested transactions will cause
+            # rollback; see the comment documentation for the Writer module's
+            # "persist_in" method for details.
+            #
+            self.transaction( :requires_new => true ) do
+
+              lock_scope = scope.acquisition_scope( ident ).lock( true )
+              self.connection.execute( lock_scope.to_sql )
+
+              original = scope.manually_dated_contemporary().acquire( ident )
+              break if original.nil?
+
+              # The only way this can fail is by throwing an exception.
               #
-              self.transaction( :requires_new => true ) do
-
-                lock_scope = scope.acquisition_scope( ident ).lock( true )
-                self.connection.execute( lock_scope.to_sql )
-
-                original = scope.manually_dated_contemporary().acquire( ident )
-                break if original.nil?
-
-                # The only way this can fail is by throwing an exception.
-                #
-                original.update_column( :effective_end, Time.now.utc.round( SECONDS_DECIMAL_PLACES ) )
-
-                # When you 'dup' a live model, ActiveRecord clears the 'created_at'
-                # and 'updated_at' values, and the 'id' column - even if you set
-                # the "primary_key=..." value on the model to something else. Put
-                # it all back together again.
-                #
-                # Duplicate, apply attributes, then overwrite anything that is
-                # vital for dating so that the inbound attributes hash can't cause
-                # any inconsistencies.
-                #
-                new_record = original.dup
-                new_record.assign_attributes( attributes )
-
-                new_record.id              = nil
-                new_record.uuid            = original.uuid
-                new_record.created_at      = original.created_at
-                new_record.updated_at      = original.effective_end # (sic.)
-                new_record.effective_start = original.effective_end # (sic.)
-                new_record.effective_end   = DATE_MAXIMUM
-
-                # Save with validation but no exceptions. The caller examines the
-                # returned object to see if there were any validation errors.
-                #
-                new_record.save()
-
-                # Must roll back if the new record didn't save, to undo the
-                # 'effective_end' column update on 'original' earlier.
-                #
-                raise ::ActiveRecord::Rollback if new_record.errors.present?
-              end
-
-              retry_operation = false
-
-            rescue ::ActiveRecord::StatementInvalid => exception
-
-              # By observation, PostgreSQL can start worrying about deadlocks
-              # with the above. TODO: I don't know why; I can't see how it can
-              # possibly end up trying to do the things the logs imply given
-              # that the locking is definitely working and blocking anything
-              # other than one transaction at a time from working on a set of
-              # rows scoped by a particular resource UUID.
+              original.update_column( :effective_end, Time.now.utc.round( SECONDS_DECIMAL_PLACES ) )
+
+              # When you 'dup' a live model, ActiveRecord clears the 'created_at'
+              # and 'updated_at' values, and the 'id' column - even if you set
+              # the "primary_key=..." value on the model to something else. Put
+              # it all back together again.
               #
-              # In such a case, retry. But only do so once; then give up.
+              # Duplicate, apply attributes, then overwrite anything that is
+              # vital for dating so that the inbound attributes hash can't cause
+              # any inconsistencies.
               #
-              if retry_operation == false && exception.message.downcase.include?( 'deadlock' )
-                retry_operation = true
+              new_record = original.dup
+              new_record.assign_attributes( attributes )
+
+              new_record.id              = nil
+              new_record.uuid            = original.uuid
+              new_record.created_at      = original.created_at
+              new_record.updated_at      = original.effective_end # (sic.)
+              new_record.effective_start = original.effective_end # (sic.)
+              new_record.effective_end   = DATE_MAXIMUM
+
+              # Save with validation but no exceptions. The caller examines the
+              # returned object to see if there were any validation errors.
+              #
+              new_record.save()
 
-                # Give other Threads time to run, maximising chance of deadlock
-                # being resolved before retry.
-                #
-                sleep 0.1
+              # Must roll back if the new record didn't save, to undo the
+              # 'effective_end' column update on 'original' earlier.
+              #
+              raise ::ActiveRecord::Rollback if new_record.errors.present?
+            end
+
+          rescue ::ActiveRecord::StatementInvalid => exception
+
+            # By observation, PostgreSQL can start worrying about deadlocks
+            # with the above. Leading theory is that it's "half way through"
+            # inserting the new row when someone else comes along and waits
+            # on the lock, but that new waiting thread has also ended up
+            # capturing a lock on the half-inserted row (since inserting
+            # involves lots of internal steps and locks).
+            #
+            # In such a case, retry. But only do so once; then give up.
+            #
+            if retried_operation == false && exception.message.downcase.include?( 'deadlock' )
+              retried_operation = true
+
+              # Give other Threads time to run, maximising chance of deadlock
+              # being resolved before retry.
+              #
+              sleep( 0.1 )
+              retry
 
-              else
-                raise exception
+            else
+              raise exception
 
-              end
+            end
 
-            end # "begin"..."rescue"..."end"
-          end while ( retry_operation ) # "begin"..."end while"
+          end # "begin"..."rescue"..."end"
 
           return new_record
         end

data/lib/hoodoo/version.rb

@@ -12,6 +12,6 @@ module Hoodoo
   # The Hoodoo gem version. If this changes, ensure that the date in
   # "hoodoo.gemspec" is correct and run "bundle install" (or "update").
   #
-  VERSION = '1.2.0'
+  VERSION = '1.2.1'
 
 end

data/spec/active/active_record/manually_dated_spec.rb

@@ -16,11 +16,35 @@ describe Hoodoo::ActiveRecord::ManuallyDated do
         t.string :id,   :null => false, :length => 32
 
         t.text :data
+        t.text :unique
 
         t.timestamps
         t.datetime :effective_start, :null => false
         t.datetime :effective_end,   :null => false
       end
+
+      # Documentation recommends these constraints in migrations, so ensure
+      # everything works when they're present.
+
+      ActiveRecord::Migration.add_index :r_spec_model_manual_date_tests, [        :effective_start, :effective_end ], :name => "index_rspec_mmdt_start_end"
+      ActiveRecord::Migration.add_index :r_spec_model_manual_date_tests, [ :uuid, :effective_start, :effective_end ], :name => "index_rspec_mmdt_id_start_end"
+
+      sql_date_maximum = ActiveRecord::Base.connection.quoted_date( Hoodoo::ActiveRecord::ManuallyDated::DATE_MAXIMUM )
+
+      ActiveRecord::Migration.add_index :r_spec_model_manual_date_tests,
+                                        :uuid,
+                                        :unique => true,
+                                        :name   => "index_rspec_mmdt_id_end",
+                                        :where  => "(effective_end = '#{ sql_date_maximum }')"
+
+      # Documentation gives something similar to this as an example of how
+      # to enforce a previously-simple uniqness constraint on one column.
+
+      ActiveRecord::Migration.add_index :r_spec_model_manual_date_tests,
+                                        :unique,
+                                        :unique => true,
+                                        :name   => "index_rspec_mmdt_unique_ee",
+                                        :where  => "(effective_end = '#{ sql_date_maximum }')"
     end
 
     class RSpecModelManualDateTest < ActiveRecord::Base
@@ -448,7 +472,7 @@ describe Hoodoo::ActiveRecord::ManuallyDated do
           }.to change( RSpecModelManualDateTest, :count ).by( 1 )
 
           expect( result ).to_not be_nil
-          expect( result.errors ).to be_empty
+          expect( result.errors.messages ).to be_empty
           expect( result.persisted? ).to eq( true )
         end
 
@@ -593,6 +617,7 @@ describe Hoodoo::ActiveRecord::ManuallyDated do
           )
 
           expect( result ).to_not be_nil
+          expect( result.errors.messages ).to be_empty
           expect( result.persisted? ).to eq( true )
         end
 
@@ -618,6 +643,212 @@ describe Hoodoo::ActiveRecord::ManuallyDated do
     end
   end
 
+  # Rapid updates within configured date resolution might not be resolvable
+  # as individual history items via API, but they should still exist and
+  # things like uuid/start/end uniqueness constraint columns ought to still
+  # function without false positives.
+  #
+  context 'rapid updates' do
+    it 'does not hit uniqueness constraint violations during very rapid update attempts' do
+      overall_before      = RSpecModelManualDateTest.count
+      historic_before     = RSpecModelManualDateTest.manually_dated_historic.count
+      contemporary_before = RSpecModelManualDateTest.manually_dated_contemporary.count
+      update_count        = 20
+
+      record = RSpecModelManualDateTest.new( {
+        :data       => Hoodoo::UUID.generate(),
+        :created_at => Time.now - 1.year
+      } )
+
+      record.save!
+
+      1.upto( update_count ) do
+        result = RSpecModelManualDateTest.manually_dated_update_in(
+          @context,
+          ident: record.uuid,
+          attributes: { 'data' => Hoodoo::UUID.generate() }
+        )
+
+        expect( result ).to_not be_nil
+        expect( result.errors.messages ).to be_empty
+        expect( result.persisted? ).to eq( true )
+      end
+
+      overall_after      = RSpecModelManualDateTest.count
+      historic_after     = RSpecModelManualDateTest.manually_dated_historic.count
+      contemporary_after = RSpecModelManualDateTest.manually_dated_contemporary.count
+
+      expect( overall_after      - overall_before      ).to eq( update_count + 1 )
+      expect( historic_after     - historic_before     ).to eq( update_count     )
+      expect( contemporary_after - contemporary_before ).to eq( 1                )
+
+      expect( RSpecModelManualDateTest.where( :uuid => record.uuid ).count ).to eq( update_count + 1 )
+      expect( RSpecModelManualDateTest.manually_dated_historic.where( :uuid => record.uuid ).count ).to eq( update_count )
+      expect( RSpecModelManualDateTest.manually_dated_contemporary.where( :uuid => record.uuid ).count ).to eq( 1 )
+    end
+  end
+
+  context 'uniqueness' do
+    before :all do
+      @unique = Hoodoo::UUID.generate()
+    end
+
+    it 'allows duplications within same resource instance history' do
+
+      # First generate a unique record
+
+      record = RSpecModelManualDateTest.new( {
+        :data       => Hoodoo::UUID.generate(),
+        :unique     => @unique,
+        :created_at => Time.now - 1.year
+      } )
+
+      record.save!
+
+      # Now update it
+
+      result = RSpecModelManualDateTest.manually_dated_update_in(
+        @context,
+        ident: record.uuid,
+        attributes: { 'data' => Hoodoo::UUID.generate() }
+      )
+
+      # We should end up with two records; one historic and one contemporary
+
+      expect( result ).to_not be_nil
+      expect( result.errors.messages ).to be_empty
+      expect( result.persisted? ).to eq( true )
+      expect( RSpecModelManualDateTest.where( :unique => @unique ).count ).to eq( 2 )
+      expect( RSpecModelManualDateTest.manually_dated_historic.where( :unique => @unique ).count ).to eq( 1 )
+      expect( RSpecModelManualDateTest.manually_dated_contemporary.where( :unique => @unique ).count ).to eq( 1 )
+
+    end
+
+    it 'prohibits duplicates across different resource instances' do
+
+      # First generate a unique record
+
+      record = RSpecModelManualDateTest.new( {
+        :data       => Hoodoo::UUID.generate(),
+        :unique     => @unique,
+        :created_at => Time.now - 1.year
+      } )
+
+      record.save!
+
+      # Now make another one; this should be prohibited.
+
+      another_record = RSpecModelManualDateTest.new( {
+        :data   => Hoodoo::UUID.generate(),
+        :unique => @unique
+      } )
+
+      expect {
+        another_record.save!
+      }.to raise_error( ::ActiveRecord::RecordNotUnique )
+
+      expect( RSpecModelManualDateTest.where( :unique => @unique ).count ).to eq( 1 )
+
+    end
+
+    it 'prohibits duplications when there is resource history and a contemporary record' do
+
+      # A fair bit of cut-and-paste here.. First generate, then update
+      # one record.
+
+      record = RSpecModelManualDateTest.new( {
+        :data       => Hoodoo::UUID.generate(),
+        :unique     => @unique,
+        :created_at => Time.now - 1.year
+      } )
+
+      record.save!
+
+      result = RSpecModelManualDateTest.manually_dated_update_in(
+        @context,
+        ident: record.uuid,
+        attributes: { 'data' => Hoodoo::UUID.generate() }
+      )
+
+      # We should end up with two records; one historic and one contemporary
+
+      expect( result ).to_not be_nil
+      expect( result.errors.messages ).to be_empty
+      expect( result.persisted? ).to eq( true )
+      expect( RSpecModelManualDateTest.where( :unique => @unique ).count ).to eq( 2 )
+      expect( RSpecModelManualDateTest.manually_dated_historic.where( :unique => @unique ).count ).to eq( 1 )
+      expect( RSpecModelManualDateTest.manually_dated_contemporary.where( :unique => @unique ).count ).to eq( 1 )
+
+      # We should be unable to make a new instance that duplicates the unique
+      # value.
+
+      another_record = RSpecModelManualDateTest.new( {
+        :data   => Hoodoo::UUID.generate(),
+        :unique => @unique
+      } )
+
+      expect {
+        another_record.save!
+      }.to raise_error( ::ActiveRecord::RecordNotUnique )
+
+      expect( RSpecModelManualDateTest.where( :unique => @unique ).count ).to eq( 2 )
+
+    end
+
+    it 'allows duplications when an old resource instance has been deleted' do
+
+      # First generate a unique record
+
+      record = RSpecModelManualDateTest.new( {
+        :data       => Hoodoo::UUID.generate(),
+        :unique     => @unique,
+        :created_at => Time.now - 1.year
+      } )
+
+      record.save!
+
+      # Now delete it
+
+      result = RSpecModelManualDateTest.manually_dated_destruction_in(
+        @context,
+        ident: record.uuid
+      )
+
+      # We should end up with one historic record
+
+      expect( result ).to_not be_nil
+      expect( RSpecModelManualDateTest.where( :unique => @unique ).count ).to eq( 1 )
+      expect( RSpecModelManualDateTest.manually_dated_historic.where( :unique => @unique ).count ).to eq( 1 )
+      expect( RSpecModelManualDateTest.manually_dated_contemporary.where( :unique => @unique ).count ).to eq( 0 )
+
+      # For safety/test reliability, sleep to make sure we are beyond the
+      # limits of configured date accuracy.
+
+      sleep( ( 0.1 ** Hoodoo::ActiveRecord::ManuallyDated::SECONDS_DECIMAL_PLACES ) * 2 )
+
+      # We should be able to make a new instance with the unique value now
+
+      another_record = RSpecModelManualDateTest.new( {
+        :data   => Hoodoo::UUID.generate(),
+        :unique => @unique
+      } )
+
+      another_record.save!
+
+      # We should end up with two records; one old UUID historic and one new
+      # UUID contemporary
+
+      expect( another_record ).to_not be_nil
+      expect( another_record.errors.messages ).to be_empty
+      expect( another_record.persisted? ).to eq( true )
+      expect( RSpecModelManualDateTest.where( :unique => @unique ).count ).to eq( 2 )
+      expect( RSpecModelManualDateTest.manually_dated_historic.where( :unique => @unique ).count ).to eq( 1 )
+      expect( RSpecModelManualDateTest.manually_dated_contemporary.where( :unique => @unique ).count ).to eq( 1 )
+      expect( RSpecModelManualDateTest.manually_dated_historic.where( :unique => @unique, :uuid => record.uuid ).count ).to eq( 1 )
+      expect( RSpecModelManualDateTest.manually_dated_contemporary.where( :unique => @unique, :uuid => another_record.uuid ).count ).to eq( 1 )
+    end
+  end
+
   context 'concurrent' do
     before :all do
       DatabaseCleaner.strategy = :truncation
@@ -702,7 +933,7 @@ describe Hoodoo::ActiveRecord::ManuallyDated do
 
         results.each do | result |
           expect( result ).to be_a( RSpecModelManualDateTest )
-          expect( result.errors ).to be_empty
+          expect( result.errors.messages ).to be_empty
           expect( result.persisted? ).to eq( true )
 
           result.reload
@@ -766,7 +997,7 @@ describe Hoodoo::ActiveRecord::ManuallyDated do
         success.reload
 
         expect( success ).to be_a( RSpecModelManualDateTest )
-        expect( success.errors ).to be_empty
+        expect( success.errors.messages ).to be_empty
         expect( success.persisted? ).to eq( true )
         expect( success.effective_end ).to_not eq( @eot )
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hoodoo
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.1
 platform: ruby
 authors:
 - Loyalty New Zealand