hoodoo 2.0.0 → 2.1.1

data/lib/hoodoo/monkey/patch/active_record_manually_dated_finder_additions.rb

@@ -0,0 +1,54 @@
+########################################################################
+# File::    active_record_manually_dated_finder_additions.rb
+# (C)::     Loyalty New Zealand 2017
+#
+# Purpose:: Extend
+#           Hoodoo::ActiveRecord::Finder::ClassMethods#acquire_in! so
+#           that it adds error +generic.contemporary_exists+ to the
+#           provided +context+ if a dated instance is absent.
+# ----------------------------------------------------------------------
+#           01-Nov-2017 (ADH): Created.
+########################################################################
+
+module Hoodoo
+  module Monkey
+    module Patch
+
+      # Extend Hoodoo::ActiveRecord::Finder::ClassMethods#acquire_in! so
+      # that it adds error +generic.contemporary_exists+ to the provided
+      # +context+ if a dated instance is absent.
+      #
+      module ActiveRecordManuallyDatedFinderAdditions
+
+        # Class methods to patch over an ActiveRecord::Base subclass
+        # which includes Hoodoo::ActiveRecord::Finder and
+        # Hoodoo::ActiveRecord::ManuallyDated.
+        #
+        module ClassExtensions
+
+          # See Hoodoo::ActiveRecord::Finder::ClassMethods#acquire_in! for
+          # details. Calls that method then, upon error, checks to see if a
+          # contemporary version of the resource exists and adds error
+          # +generic.contemporary_exists+ to the given +context+ if so.
+          #
+          def acquire_in!( context )
+            result = super( context )
+
+            if result.nil?
+              ident               = context.request.ident
+              contemporary_result = scoped_undated_in( context ).
+                                    manually_dated_contemporary().
+                                    acquire( ident )
+
+              context.response.contemporary_exists( ident ) if contemporary_result.present?
+            end
+
+            return result
+          end
+
+        end
+      end
+
+    end # module Patch
+  end   # module Monkey
+end     # module Hoodoo

data/lib/hoodoo/monkey/patch/datadog_traced_amqp.rb

@@ -8,7 +8,7 @@
 #
 #           See Hoodoo::Monkey::Patch::DatadogTracedAMQP for more.
 # ----------------------------------------------------------------------
-#           22-June-2017 (JRW): Created.
+#           22-Jun-2017 (JRW): Created.
 ########################################################################
 
 module Hoodoo

data/lib/hoodoo/services/services/response.rb

@@ -299,20 +299,81 @@ module Hoodoo; module Services
       return @errors.merge!( errors_object )
     end
 
-    # Set the standard not found error message (generic.not_found), to
-    # be used durning a 'show' call when the requested resource does not
-    # exist.
+    # Add the standard error message '+generic.not_found+' to this response.
+    # Used during a 'show' call when the requested resource does not exist.
     #
-    # +ident+::  The identifier of the resource which was not found
+    # +ident+:: The identifier of the resource which was not found
     #
-    # Example:
+    # Low level example:
     #
     #      return response.not_found( ident ) if resource.nil?
     #
+    # High level example for resource implementations with a +context+
+    # available, through which this method is called automatically:
+    #
+    #   resource = SomeModel.acquire_in!( context )
+    #   return if context.response.halt_processing?
+    #
+    # See also:
+    #
+    # * #contemporary_exists
+    # * Hoodoo::ActiveRecord::Finder::ClassMethods#acquire_in
+    #
     def not_found( ident )
       @errors.add_error( 'generic.not_found', :reference => { :ident => ident } )
     end
 
+    # Add the standard error message '+generic.contemporary_exists+' to this
+    # response. Optionally used during a 'show' call for a historical
+    # dating-aware resource, when an instance does not exist at a requested
+    # historic date/time, but a contemporary version is present.
+    #
+    # +ident+:: The identifier of the resource which was not found
+    #
+    # Example for resource implementations with a +context+ available:
+    #
+    #     resource = SomeModel.acquire_in( context )
+    #
+    #     if resource.nil?
+    #       ident = context.request.ident
+    #       context.response.not_found( ident )
+    #
+    #       # You'd omit "#manually_dated_contemporary" if using automatic
+    #       # dating (but manual dating is recommended over automatic for
+    #       # performance reasons).
+    #       #
+    #       contemporary_resource = SomeModel.
+    #                               scoped_undated_in( context ).
+    #                               manually_dated_contemporary().
+    #                               acquire( ident )
+    #
+    #       # Use of ActiveRecord means some ActiveSupport extensions
+    #       # such as "#present?" will be available.
+    #       #
+    #       context.response.contemporary_exists( ident ) if contemporary_resource.present?
+    #     end
+    #
+    # An even higher level approach through +context+, through which this
+    # method is called automatically:
+    #
+    #   resource = SomeModel.acquire_in!( context )
+    #   return if context.response.halt_processing?
+    #
+    # This frees application authors of the burden of constructing an
+    # appropriately secure and "now-dated" scope for the contemporary resource
+    # lookup.
+    #
+    # See also:
+    #
+    # * #not_found
+    # * Hoodoo::ActiveRecord::Finder::ClassMethods#acquire_in
+    # * Hoodoo::ActiveRecord::Finder::ClassMethods#scoped_undated_in
+    # * Hoodoo::ActiveRecord::ManuallyDated::ClassMethods#manually_dated_contemporary
+    #
+    def contemporary_exists( ident )
+      @errors.add_error( 'generic.contemporary_exists', :reference => { :ident => ident } )
+    end
+
     # Convert the internal response data into something that Rack expects.
     # The return value of this method can be passed back to Rack from Rack
     # middleware or applications. Usually, this is only called directly by

data/lib/hoodoo/version.rb

@@ -12,11 +12,11 @@ module Hoodoo
   # The Hoodoo gem version. If this changes, be sure to re-run
   # <tt>bundle install</tt> or <tt>bundle update</tt>.
   #
-  VERSION = '2.0.0'
+  VERSION = '2.1.1'
 
   # The Hoodoo gem date. If this changes, be sure to re-run
   # <tt>bundle install</tt> or <tt>bundle update</tt>.
   #
-  DATE = '2017-10-13'
+  DATE = '2017-11-03'
 
 end

data/spec/active/active_record/base_spec.rb

@@ -6,11 +6,10 @@ describe Hoodoo::ActiveRecord::Base do
     spec_helper_silence_stdout() do
       tblname = :r_spec_model_base_tests
 
-      ActiveRecord::Migration.create_table( tblname, :id => false ) do | t |
-        t.string( :id, :limit => 32, :null => false )
+      ActiveRecord::Migration.create_table( tblname, :id => :string ) do | t |
       end
 
-      ActiveRecord::Migration.add_index( tblname, :id, :unique => true )
+      ActiveRecord::Migration.change_column( tblname, :id, :string, :limit => 32 )
 
       class RSpecModelBaseTest < Hoodoo::ActiveRecord::Base
       end

data/spec/active/active_record/dated_spec.rb

@@ -5,44 +5,47 @@ describe Hoodoo::ActiveRecord::Dated do
 
   before :all do
     spec_helper_silence_stdout() do
-
-      ActiveRecord::Migration.create_table( :r_spec_model_effective_date_tests, :id => false ) do | t |
-        t.text :id,  :null => false
+      ActiveRecord::Migration.create_table( :r_spec_model_effective_date_tests, :id => :string ) do | t |
         t.text :data
         t.timestamps :null => true
       end
 
-      ActiveRecord::Migration.create_table( :r_spec_model_effective_date_tests_history_entries, :id => false ) do | t |
-        t.text     :id,              :null => false
+      ActiveRecord::Migration.change_column( :r_spec_model_effective_date_tests, :id, :string, :limit => 32 )
+
+      ActiveRecord::Migration.create_table( :r_spec_model_effective_date_tests_history_entries, :id => :string ) do | t |
         t.text     :uuid,            :null => false
         t.text     :data
         t.datetime :effective_start, :null => false
         t.datetime :effective_end,   :null => false
+
         t.timestamps :null => true
       end
 
       class RSpecModelEffectiveDateTest < ActiveRecord::Base
         include Hoodoo::ActiveRecord::Dated
+
         dating_enabled()
       end
 
-      ActiveRecord::Migration.create_table( :r_spec_model_effective_date_test_overrides, :id => false ) do | t |
-        t.text :id,  :null => false
+      ActiveRecord::Migration.create_table( :r_spec_model_effective_date_test_overrides, :id => :string ) do | t |
         t.text :data
         t.timestamps :null => true
       end
 
-      ActiveRecord::Migration.create_table( :r_spec_model_effective_date_history_entries, :id => false ) do | t |
-        t.text     :id,              :null => false
+      ActiveRecord::Migration.change_column( :r_spec_model_effective_date_test_overrides, :id, :string, :limit => 32 )
+
+      ActiveRecord::Migration.create_table( :r_spec_model_effective_date_history_entries, :id => :string ) do | t |
         t.text     :uuid,            :null => false
         t.text     :data
         t.datetime :effective_start, :null => false
         t.datetime :effective_end,   :null => false
+
         t.timestamps :null => true
       end
 
       class RSpecModelEffectiveDateTestOverride < ActiveRecord::Base
         include Hoodoo::ActiveRecord::Dated
+        include Hoodoo::ActiveRecord::Finder
 
         dating_enabled( :history_table_name => :r_spec_model_effective_date_history_entries )
       end
@@ -51,7 +54,16 @@ describe Hoodoo::ActiveRecord::Dated do
 
   shared_examples Hoodoo::ActiveRecord::Dated do
 
-    before( :all ) do
+    before( :each ) do
+      interaction = Hoodoo::Services::Middleware::Interaction.new( {}, nil )
+      interaction.context = Hoodoo::Services::Context.new(
+        Hoodoo::Services::Session.new,
+        interaction.context.request,
+        interaction.context.response,
+        interaction
+      )
+
+      @context = interaction.context
 
       # Create some example data for finding. The data has two different UUIDs
       # which I'll referer to as A and B. The following tables contain the
@@ -169,26 +181,16 @@ describe Hoodoo::ActiveRecord::Dated do
 
     context '#dated' do
       it 'returns counts correctly' do
-        # The contents of the Context are irrelevant aside from the fact that it
-        # needs a request to store the dated_at value.
-        request = Hoodoo::Services::Request.new
-        context = Hoodoo::Services::Context.new( nil, request, nil, nil )
+        @context.request.dated_at = @now - 10.hours
+        expect( model_klass.dated( @context ).count ).to be 0
 
-        context.request.dated_at = @now - 10.hours
-        expect( model_klass.dated( context ).count ).to be 0
-
-        context.request.dated_at = @now
-        expect( model_klass.dated( context ).count ).to be 2
+        @context.request.dated_at = @now
+        expect( model_klass.dated( @context ).count ).to be 2
       end
 
       def test_expectation( time, expected_data )
-        # The contents of the Context are irrelevant aside from the fact that it
-        # needs a request to store the dated_at value.
-        request = Hoodoo::Services::Request.new
-        context = Hoodoo::Services::Context.new( nil, request, nil, nil )
-        context.request.dated_at = time
-
-        expect( model_klass.dated( context ).pluck( :data ) ).to match_array( expected_data )
+        @context.request.dated_at = time
+        expect( model_klass.dated( @context ).pluck( :data ) ).to match_array( expected_data )
       end
 
       it 'returns no records before any were effective' do
@@ -208,27 +210,14 @@ describe Hoodoo::ActiveRecord::Dated do
       end
 
       it 'works with further filtering' do
-
-        # The contents of the Context are irrelevant aside from the fact that it
-        # needs a request to store the dated_at value.
-        request = Hoodoo::Services::Request.new
-        context = Hoodoo::Services::Context.new( nil, request, nil, nil )
-        context.request.dated_at = @now
-
-        expect( model_klass.dated( context ).where( :id => @uuid_a ).pluck( :data ) ).to eq( [ "six" ] )
+        @context.request.dated_at = @now
+        expect( model_klass.dated( @context ).where( :id => @uuid_a ).pluck( :data ) ).to eq( [ "six" ] )
       end
 
       it 'works with dating last' do
-
-        # The contents of the Context are irrelevant aside from the fact that it
-        # needs a request to store the dated_at value.
-        request = Hoodoo::Services::Request.new
-        context = Hoodoo::Services::Context.new( nil, request, nil, nil )
-        context.request.dated_at = @now
-
-        expect( model_klass.where( :id => @uuid_a ).dated( context ).pluck( :data ) ).to eq( [ "six" ] )
+        @context.request.dated_at = @now
+        expect( model_klass.where( :id => @uuid_a ).dated( @context ).pluck( :data ) ).to eq( [ "six" ] )
       end
-
     end
 
     context '#dated_historical_and_current' do
@@ -268,7 +257,171 @@ describe Hoodoo::ActiveRecord::Dated do
       end
     end
 
-  end
+    # These appear in the shared examples to take advantage of the test
+    # data that's set up, but only work when "model_klass" is the
+    # Finder-extended "RSpecModelEffectiveDateTestOverride".
+    #
+    # Hence "next unless..." in each example (using "skip" in a "before"
+    # filter would result in RSpect listing pending tests; they are not
+    # pending at all).
+
+    context 'with Hoodoo::ActiveRecord::Finder support' do
+      context '#scoped_in' do
+        it 'generates appropriate scope' do
+          next unless model_klass == RSpecModelEffectiveDateTestOverride
+
+          expect( Hoodoo::ActiveRecord::Support ).to(
+            receive( :full_scope_for ).once().with(
+              RSpecModelEffectiveDateTestOverride, @context
+            ).and_call_original()
+          )
+
+          sql = RSpecModelEffectiveDateTestOverride.scoped_in( @context ).to_sql
+
+          expect( sql ).to include( "UNION ALL" )
+          expect( sql ).to include( "' AND (\"effective_end\" > '" )
+        end
+
+        it 'generates appropriate undated scope' do
+          next unless model_klass == RSpecModelEffectiveDateTestOverride
+
+          expect( Hoodoo::ActiveRecord::Support ).to(
+            receive( :add_undated_scope_to ).once().with(
+              kind_of( ActiveRecord::Relation ), RSpecModelEffectiveDateTestOverride, @context
+            ).and_call_original()
+          )
+
+          sql = RSpecModelEffectiveDateTestOverride.scoped_undated_in( @context ).to_sql
+
+          expect( sql ).to eq( "SELECT \"r_spec_model_effective_date_test_overrides\".* FROM \"r_spec_model_effective_date_test_overrides\"" )
+        end
+      end
+
+      context '#acquire_in' do
+        context 'with contemporary' do
+          it 'finds the contemporary record' do
+            next unless model_klass == RSpecModelEffectiveDateTestOverride
+
+            @context.request.dated_at            = nil
+            @context.request.uri_path_components = [ @uuid_a ]
+
+            result = RSpecModelEffectiveDateTestOverride.acquire_in!( @context )
+            expect( result ).to_not be_nil
+
+            expect( @context.response.halt_processing? ).to eq( false )
+            expect( result.data                        ).to eq( 'six' )
+          end
+
+          it 'finds a historic record' do
+            next unless model_klass == RSpecModelEffectiveDateTestOverride
+
+            @context.request.dated_at            = @now - 4.hours
+            @context.request.uri_path_components = [ @uuid_a ]
+
+            result = RSpecModelEffectiveDateTestOverride.acquire_in!( @context )
+            expect( result ).to_not be_nil
+
+            expect( @context.response.halt_processing? ).to eq( false )
+            expect( result.data                        ).to eq( 'one' )
+          end
+
+          it 'indicates correctly that a contemporary exists during a far-backdated lookup' do
+            next unless model_klass == RSpecModelEffectiveDateTestOverride
+
+            @context.request.dated_at            = @now - 1.year
+            @context.request.uri_path_components = [ @uuid_a ]
+
+            result = RSpecModelEffectiveDateTestOverride.acquire_in!( @context )
+            expect( result ).to be_nil
+
+            expect( @context.response.halt_processing?    ).to eq( true )
+            expect( @context.response.errors.errors.count ).to eq( 2    )
+
+            expect( @context.response.errors.errors[ 0 ][ 'code'      ] ).to eq( 'generic.not_found' )
+            expect( @context.response.errors.errors[ 1 ][ 'code'      ] ).to eq( 'generic.contemporary_exists' )
+            expect( @context.response.errors.errors[ 0 ][ 'reference' ] ).to eq( @uuid_a )
+            expect( @context.response.errors.errors[ 1 ][ 'reference' ] ).to eq( @uuid_a )
+          end
+        end
+
+        context 'with a UUID that matches no existing record' do
+          it 'indicates correctly that no record exists and does not say a contemporary is present' do
+            next unless model_klass == RSpecModelEffectiveDateTestOverride
+
+            alt_uuid                             = Hoodoo::UUID.generate
+            @context.request.dated_at            = @now - 5.seconds
+            @context.request.uri_path_components = [ alt_uuid ]
+
+            result = RSpecModelEffectiveDateTestOverride.acquire_in!( @context )
+            expect( result ).to be_nil
+
+            expect( @context.response.halt_processing?    ).to eq( true )
+            expect( @context.response.errors.errors.count ).to eq( 1    )
+
+            expect( @context.response.errors.errors[ 0 ][ 'code'      ] ).to eq( 'generic.not_found' )
+            expect( @context.response.errors.errors[ 0 ][ 'reference' ] ).to eq( alt_uuid )
+          end
+        end
+
+        context 'without contemporary' do
+          before( :each ) do
+            if model_klass == RSpecModelEffectiveDateTestOverride
+              record = RSpecModelEffectiveDateTestOverride.find( @uuid_a )
+              record.destroy!
+
+              sleep( 0.1 ) # Be sure that there's nothing left at "now", within timer resolution
+            end
+          end
+
+          it 'finds no contemporary record' do
+            next unless model_klass == RSpecModelEffectiveDateTestOverride
+
+            @context.request.dated_at            = nil
+            @context.request.uri_path_components = [ @uuid_a ]
+
+            result = RSpecModelEffectiveDateTestOverride.acquire_in!( @context )
+            expect( result ).to be_nil
+
+            expect( @context.response.halt_processing?    ).to eq( true )
+            expect( @context.response.errors.errors.count ).to eq( 1    )
+
+            expect( @context.response.errors.errors[ 0 ][ 'code'      ] ).to eq( 'generic.not_found' )
+            expect( @context.response.errors.errors[ 0 ][ 'reference' ] ).to eq( @uuid_a )
+          end
+
+          it 'finds a historic record' do
+            next unless model_klass == RSpecModelEffectiveDateTestOverride
+
+            @context.request.dated_at            = @now - 4.hours
+            @context.request.uri_path_components = [ @uuid_a ]
+
+            result = RSpecModelEffectiveDateTestOverride.acquire_in!( @context )
+            expect( result ).to_not be_nil
+
+            expect( @context.response.halt_processing? ).to eq( false )
+            expect( result.data                        ).to eq( 'one' )
+          end
+
+          it 'indicates correctly that no contemporary exists during a far-backdated lookup' do
+            next unless model_klass == RSpecModelEffectiveDateTestOverride
+
+            @context.request.dated_at            = @now - 1.year
+            @context.request.uri_path_components = [ @uuid_a ]
+
+            result = RSpecModelEffectiveDateTestOverride.acquire_in!( @context )
+            expect( result ).to be_nil
+
+            expect( @context.response.halt_processing?    ).to eq( true )
+            expect( @context.response.errors.errors.count ).to eq( 1    )
+
+            expect( @context.response.errors.errors[ 0 ][ 'code'      ] ).to eq( 'generic.not_found' )
+            expect( @context.response.errors.errors[ 0 ][ 'reference' ] ).to eq( @uuid_a )
+          end
+        end
+      end
+    end
+
+  end # 'shared_examples Hoodoo::ActiveRecord::Dated do'
 
   context "using default effective dating config" do