hoodoo 1.19.0 → 2.0.0

data/lib/hoodoo/services/discovery/discoverers/by_drb/by_drb.rb

@@ -63,7 +63,7 @@ module Hoodoo
           # +version+::  Passed to #discover_remote.
           # +options+::  Options hash as described below.
           #
-          # Options keys are currently all required:
+          # Options keys are:
           #
           # +host+:: Host name as a string for location of service endpoint,
           #          over HTTP (usually, local development is assumed).
@@ -72,20 +72,25 @@ module Hoodoo
           #
           # +path+:: Path on the above host and port of service endpoint.
           #
+          # If any are missing or +nil+, remote announcement is aborted and
+          # the return value is correspondingly +nil+.
+          #
           def announce_remote( resource, version, options = {} )
 
             host = options[ :host ]
             port = options[ :port ]
             path = options[ :path ]
 
-            endpoint_uri_string = "http://#{ host }:#{ port }#{ path }"
+            endpoint_uri_string = unless host.nil? || port.nil? || path.nil?
+              "http://#{ host }:#{ port }#{ path }"
+            end
 
-            # Announce our local services if we managed to find the host and port,
-            # but no point otherwise; the values could be anything. In a 'guard'
-            # based environment, first-run determines host and port but subsequent
-            # runs do not - yet it stays the same, so it works out OK there.
+            # Announce our local services only if we have an endpoint URI. In a
+            # 'guard' based environment, first-run determines host and port but
+            # subsequent runs do not - yet it stays the same, so it works out
+            # OK there.
             #
-            unless host.nil? || port.nil? || discover_remote( resource, version )
+            unless endpoint_uri_string.nil? || discover_remote( resource, version )
               drb_service().add( resource, version, endpoint_uri_string )
             end
 
@@ -157,7 +162,7 @@ module Hoodoo
             rescue DRb::DRbConnError
               if start_on_localhost_if_not_already_running
                 script_path = File.join( File.dirname( __FILE__ ), 'drb_server_start.rb' )
-                command     = "bundle exec ruby '#{ script_path }'"
+                command     = "#{ defined?( Bundler ) ? 'bundle exec ' : '' }ruby '#{ script_path }'"
                 command    << " --port #{ @drb_port }" unless @drb_port.nil? || @drb_port.empty?
 
                 Process.detach( spawn( command ) )

data/lib/hoodoo/services/middleware/exception_reporting/reporters/airbrake_reporter.rb

@@ -27,7 +27,8 @@ module Hoodoo; module Services
       #     require 'airbrake'
       #
       #     Airbrake.configure do | config |
-      #       config.api_key = 'YOUR_AIRBRAKE_API_KEY'
+      #       config.project_key = 'YOUR_AIRBRAKE_PROJECT_KEY'
+      #       config.project_id  = 'YOUR_AIRBRAKE_PROJECT_ID'
       #     end
       #
       #     Hoodoo::Services::Middleware::ExceptionReporting.add(
@@ -57,7 +58,11 @@ module Hoodoo; module Services
           opts = { :backtrace => Kernel.caller() }
           opts[ :rack_env ] = env unless env.nil?
 
-          Airbrake.notify_or_ignore( e, opts )
+          # Since an ExceptionReporter is already a "slow communicatory",
+          # Hoodoo is using threads for behaviour; we don't need the async
+          # Airbrake mechanism to waste resources doing the same.
+          #
+          Airbrake.notify_sync( e, opts )
         end
 
         # Report an exception for errors that occur within a fully handled Rack
@@ -77,7 +82,7 @@ module Hoodoo; module Services
             :session          => user_data_for( context ) || 'unknown'
           }
 
-          Airbrake.notify_or_ignore( e, opts )
+          Airbrake.notify_sync( e, opts )
         end
       end
 

data/lib/hoodoo/services/middleware/interaction.rb

@@ -24,7 +24,7 @@ module Hoodoo; module Services; class Middleware
       #
       attr_reader :owning_middleware_instance
 
-      # The inbound Rack request a Rack::Request instance.
+      # The inbound Rack request; a <tt>Rack::Request</tt> instance.
       #
       attr_reader :rack_request
 

data/lib/hoodoo/services/middleware/middleware.rb

@@ -12,6 +12,7 @@
 ########################################################################
 
 require 'set'
+require 'cgi'
 require 'uri'
 require 'json'
 require 'benchmark'
@@ -186,6 +187,15 @@ module Hoodoo; module Services
       nil
     }
 
+    # A validation Proc for FRAMEWORK_QUERY_DATA - see that for details. This
+    # one ensures that the value is a valid UUID and evaluates to that UUID
+    # string if so.
+    #
+    FRAMEWORK_QUERY_VALUE_UUID_PROC = -> ( value ) {
+      value = Hoodoo::UUID.valid?( value ) && value
+      value || nil # => 'value' if 'value' is truthy, 'nil' if 'value' falsy
+    }
+
     # Out-of-box search and filter query keys. Interfaces can override the
     # support for these inside the Hoodoo::Services::Interface.to_list block
     # using Hoodoo::Services::Interface::ToListDSL.do_not_search and
@@ -216,6 +226,7 @@ module Hoodoo; module Services
     FRAMEWORK_QUERY_DATA = {
       'created_after'  => FRAMEWORK_QUERY_VALUE_DATE_PROC,
       'created_before' => FRAMEWORK_QUERY_VALUE_DATE_PROC,
+      'created_by'     => FRAMEWORK_QUERY_VALUE_UUID_PROC
     }
 
     # Utility - returns the execution environment as a Rails-like environment
@@ -478,7 +489,6 @@ module Hoodoo; module Services
       # implementation   Hoodoo::Services::Implementation subclass *instance* to
       #                  use on match
       #
-      #
       @@services = service_container.component_interfaces.map do | interface |
 
         if interface.nil? || interface.endpoint.nil? || interface.implementation.nil?
@@ -620,10 +630,10 @@ module Hoodoo; module Services
     #
     # +version+::     Required implemented version for the endpoint. Integer.
     #
-    # +interaction+:: The Hoodoo::Services::Interaction instance describing
-    #                 the inbound call, the processing of which is leading to
-    #                 a request for an inter-resource call by an endpoint
-    #                 implementation.
+    # +interaction+:: The Hoodoo::Services::Middleware::Interaction instance
+    #                 describing the inbound call, the processing of which is
+    #                 leading to a request for an inter-resource call by an
+    #                 endpoint implementation.
     #
     def inter_resource_endpoint_for( resource, version, interaction )
       resource = resource.to_sym
@@ -720,11 +730,12 @@ module Hoodoo; module Services
     #
     # Named parameters are as follows:
     #
-    # +source_interaction+:: A Hoodoo::Services::Interaction instance for the
-    #                        inbound call which is being processed right now
-    #                        by some resource endpoint implementation and this
-    #                        implementation is now making an inter-resource
-    #                        call as part of its processing;
+    # +source_interaction+:: A Hoodoo::Services::Middleware::Interaction
+    #                        instance for the inbound call which is being
+    #                        processed right now by some resource endpoint
+    #                        implementation and this implementation is now
+    #                        making an inter-resource call as part of its
+    #                        processing;
     #
     # +discovery_result+::   A Hoodoo::Services::Discovery::ForLocal instance
     #                        describing the target of the inter-resource call;
@@ -991,13 +1002,13 @@ module Hoodoo; module Services
 
     # Make an "inbound" call log based on the given interaction.
     #
-    # +interaction+:: Hoodoo::Services::Interaction describing the inbound
-    #                 request. The +interaction_id+, +rack_request+ and
-    #                 +session+ data is used (the latter being optional).
-    #                 If +target_interface+ and +requested_action+ are
-    #                 available, body data _might_ be logged according to
-    #                 secure log settings in the interface; if these
-    #                 values are unset, body data is _not_ logged.
+    # +interaction+:: Hoodoo::Services::Middleware::Interaction describing the
+    #                 inbound request. The +interaction_id+, +rack_request+ and
+    #                 +session+ data is used (the latter being optional). If
+    #                 +target_interface+ and +requested_action+ are available,
+    #                 body data _might_ be logged according to secure log
+    #                 settings in the interface; if these values are unset,
+    #                 body data is _not_ logged.
     #
     def monkey_log_inbound_request( interaction )
 
@@ -1181,12 +1192,12 @@ module Hoodoo; module Services
     # Build common log information for the 'data' part of a payload based
     # on the given interaction. Returned as a Hash with Symbol keys.
     #
-    # +interaction+:: Hoodoo::Services::Interaction describing a request.
-    #                 A +context+ and +interaction_id+ are expected. The
-    #                 +target_interface+ and +requested_action+ are optional
-    #                 and if present result in a <tt>:target</tt> entry in
-    #                 the returned Hash. The +context.session+ value if
-    #                 present will be included in a <tt>:session</tt> entry;
+    # +interaction+:: Hoodoo::Services::Middleware::Interaction describing a
+    #                 request. A +context+ and +interaction_id+ are expected.
+    #                 The +target_interface+ and +requested_action+ are
+    #                 optional and if present result in a <tt>:target</tt>
+    #                 entry in the returned Hash. The +context.session+ value
+    #                 if present will be included in a <tt>:session</tt> entry;
     #                 if verbose logging is enabled this will be quoted in
     #                 full, else only identity-related parts are recorded.
     #
@@ -1577,8 +1588,8 @@ module Hoodoo; module Services
           end
         end
 
-        host = @@recorded_host if host.nil? && defined?( @@recorded_host )
-        port = @@recorded_port if port.nil? && defined?( @@recorded_port )
+        host ||= @@recorded_host if defined?( @@recorded_host )
+        port ||= @@recorded_port if defined?( @@recorded_port )
 
         # Under test, ensure a simulation of an available host and port is
         # always available for discovery-related tests.
@@ -1588,23 +1599,23 @@ module Hoodoo; module Services
           port ||= '9292'
         end
 
-        # Announce the resource endpoints unless we are still missing a host
-        # or port. Implication is 'racksh'.
+        # Announce the resource endpoints. We might not be able to annouce
+        # the remote availability of this endpoint if the host/port are not
+        # determined; but that might just be because we are running under
+        # "racksh" and we wouldn't want to announce remotely anyway.
 
-        unless host.nil? || port.nil?
-          services.each do | service |
-            interface = service.interface_class
+        services.each do | service |
+          interface = service.interface_class
 
-            @discoverer.announce(
-              interface.resource,
-              interface.version,
-              {
-                :host => host,
-                :port => port,
-                :path => service.base_path
-              }
-            )
-          end
+          @discoverer.announce(
+            interface.resource,
+            interface.version,
+            {
+              :host => host,
+              :port => port,
+              :path => service.base_path
+            }
+          )
         end
       end
     end
@@ -1752,7 +1763,7 @@ module Hoodoo; module Services
       # We try the custom routing path first, then the de facto path, then
       # give up if neither match.
 
-      uri_path = CGI.unescape( interaction.rack_request.path() )
+      uri_path = ::CGI.unescape( interaction.rack_request.path() )
 
       selected_path_data = nil
       selected_services  = @@services.select do | service_data |

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 = '1.19.0'
+  VERSION = '2.0.0'
 
   # The Hoodoo gem date. If this changes, be sure to re-run
   # <tt>bundle install</tt> or <tt>bundle update</tt>.
   #
-  DATE = '2017-08-17'
+  DATE = '2017-10-13'
 
 end

data/spec/active/active_record/creator_spec.rb

@@ -8,7 +8,7 @@ describe Hoodoo::ActiveRecord::Creator do
         t.text :code
         t.text :field_one
 
-        t.timestamps
+        t.timestamps :null => true
       end
     end
 

data/spec/active/active_record/dated_spec.rb

@@ -9,7 +9,7 @@ describe Hoodoo::ActiveRecord::Dated do
       ActiveRecord::Migration.create_table( :r_spec_model_effective_date_tests, :id => false ) do | t |
         t.text :id,  :null => false
         t.text :data
-        t.timestamps
+        t.timestamps :null => true
       end
 
       ActiveRecord::Migration.create_table( :r_spec_model_effective_date_tests_history_entries, :id => false ) do | t |
@@ -18,7 +18,7 @@ describe Hoodoo::ActiveRecord::Dated do
         t.text     :data
         t.datetime :effective_start, :null => false
         t.datetime :effective_end,   :null => false
-        t.timestamps
+        t.timestamps :null => true
       end
 
       class RSpecModelEffectiveDateTest < ActiveRecord::Base
@@ -29,7 +29,7 @@ describe Hoodoo::ActiveRecord::Dated do
       ActiveRecord::Migration.create_table( :r_spec_model_effective_date_test_overrides, :id => false ) do | t |
         t.text :id,  :null => false
         t.text :data
-        t.timestamps
+        t.timestamps :null => true
       end
 
       ActiveRecord::Migration.create_table( :r_spec_model_effective_date_history_entries, :id => false ) do | t |
@@ -38,7 +38,7 @@ describe Hoodoo::ActiveRecord::Dated do
         t.text     :data
         t.datetime :effective_start, :null => false
         t.datetime :effective_end,   :null => false
-        t.timestamps
+        t.timestamps :null => true
       end
 
       class RSpecModelEffectiveDateTestOverride < ActiveRecord::Base
@@ -299,7 +299,7 @@ describe Hoodoo::ActiveRecord::Dated do
   context "SQL and column selections" do
     before :each do
       @now      = Time.now.utc
-      @safe_now = RSpecModelEffectiveDateTestOverride.sanitize( @now )
+      @safe_now = RSpecModelEffectiveDateTestOverride.connection.quoted_date( @now )
 
       request   = Hoodoo::Services::Request.new
       @context  = Hoodoo::Services::Context.new( nil, request, nil, nil )
@@ -309,8 +309,8 @@ describe Hoodoo::ActiveRecord::Dated do
 
     def run_other_expectations( sql )
       expect( sql ).to include( "from r_spec_model_effective_date_history_entries" )
-      expect( sql ).to include( "\"effective_start\" <= #{ @safe_now }" )
-      expect( sql ).to include( "\"effective_end\" > #{ @safe_now }" )
+      expect( sql ).to include( "\"effective_start\" <= '#{ @safe_now }'" )
+      expect( sql ).to include( "\"effective_end\" > '#{ @safe_now }'" )
       expect( sql ).to include( "\"effective_end\" is null" )
     end
 

data/spec/active/active_record/finder_spec.rb

@@ -1,7 +1,14 @@
 require 'spec_helper'
 require 'active_record'
 
-describe Hoodoo::ActiveRecord::Finder do
+# The "counting" tests must run first and in-order internally, else e.g. an
+# ANALYZE might happen before the pre-ANALYZE test, breaking the results.
+# Other tests that create objects in the table can cause the estimated count
+# to shift away from initial expectations too, so this test is run early.
+# All other tests are wrapped in a giant context that allows for random
+# ordering to be preserved there.
+#
+describe Hoodoo::ActiveRecord::Finder, :order => :defined do
   before :all do
     spec_helper_silence_stdout() do
       ActiveRecord::Migration.create_table( :r_spec_model_finder_tests, :id => false ) do | t |
@@ -12,7 +19,8 @@ describe Hoodoo::ActiveRecord::Finder do
         t.text :field_two
         t.text :field_three
 
-        t.timestamps
+        t.timestamps :null => true
+        t.text :created_by
       end
     end
 
@@ -79,7 +87,8 @@ describe Hoodoo::ActiveRecord::Finder do
         :wild_field_one   => sh.ciaw_match_generic( 'field_one '),
         :field_two        => sh.cs_match_csv(),
         'field_three'     => sh.cs_match_array(),
-        'created_after'   => sh.cs_gte( 'updated_at' )
+        'created_after'   => sh.cs_gte( 'updated_at' ), # Deliberate framework override
+        'created_by'      => sh.ci_match_generic( 'code' )      # Deliberate framework override
       }
 
       search_with( search_and_filter_map )
@@ -118,7 +127,9 @@ describe Hoodoo::ActiveRecord::Finder do
   end
 
   before :each do
-    @tn = Time.now.round()
+    @tn  = Time.now.round()
+    @cb1 = Hoodoo::UUID.generate()
+    @cb2 = Hoodoo::UUID.generate()
 
     @a = RSpecModelFinderTest.new
     @a.id = "one"
@@ -128,6 +139,7 @@ describe Hoodoo::ActiveRecord::Finder do
     @a.field_three = 'three a'
     @a.created_at = @tn - 1.year
     @a.updated_at = @tn - 1.month
+    @a.created_by = @cb1
     @a.save!
     @id = @a.id
 
@@ -140,6 +152,7 @@ describe Hoodoo::ActiveRecord::Finder do
     @b.field_three = 'three b'
     @b.created_at = @tn - 1.month
     @b.updated_at = @tn - 1.week
+    @b.created_by = @cb1
     @b.save!
     @uuid = @b.uuid
 
@@ -151,6 +164,7 @@ describe Hoodoo::ActiveRecord::Finder do
     @c.field_three = 'three c'
     @c.created_at = @tn
     @c.updated_at = @tn + 1.day
+    @c.created_by = @cb2
     @c.save!
     @code = @c.code
 
@@ -191,700 +205,692 @@ describe Hoodoo::ActiveRecord::Finder do
 
   # ==========================================================================
 
-  context '#scoped_in' do
-    before :each do
+  context "(ordered)" do
+    context 'counting' do
+      it 'lists with a normal count' do
+        finder = RSpecModelFinderTest.list( @list_params )
 
-      # Get a good-enough-for-test interaction which has a context
-      # that contains a Session we can modify.
+        expect( finder ).to receive( :dataset_size ).at_least( :once ).and_call_original
+        expect( finder ).to receive( :count        ).at_least( :once ).and_call_original
 
-      @interaction = Hoodoo::Services::Middleware::Interaction.new( {}, nil )
-      @interaction.context = Hoodoo::Services::Context.new(
-        Hoodoo::Services::Session.new,
-        @interaction.context.request,
-        @interaction.context.response,
-        @interaction
-      )
+        expect( finder ).to_not receive( :estimated_dataset_size )
+        expect( finder ).to_not receive( :estimated_count        )
 
-      @context = @interaction.context
-      @session = @interaction.context.session
-    end
+        result = finder.dataset_size()
 
-    # If security scoping works _and_ we know that it called #full_scope_for
-    # in the "internal"-ish support API, then we consider that good enough
-    # to prove that it's calling the scope engine and that engine has its
-    # own comprehensive test coverage in suport_spec.rb.
-    #
-    it 'generates appropriate scope' do
-      @session.scoping = { :authorised_uuids => [ 'uuid 1', 'uuid 2' ], :authorised_code => 'code 1' }
+        expect( result ).to_not be_nil
+      end
 
-      expect( Hoodoo::ActiveRecord::Support ).to(
-        receive( :full_scope_for ).once().with(
-          RSpecModelFinderTest, @context
-        ).and_call_original()
-      )
+      it 'lists with an estimated count' do
+        finder = RSpecModelFinderTest.list( @list_params )
 
-      sql = RSpecModelFinderTest.scoped_in( @context ).to_sql
+        expect( finder ).to_not receive( :dataset_size )
 
-      expect( sql ).to eq( "SELECT \"r_spec_model_finder_tests\".* " \
-                           "FROM \"r_spec_model_finder_tests\" "     \
-                           "WHERE "                                  \
-                             "\"r_spec_model_finder_tests\".\"uuid\" IN ('uuid 1', 'uuid 2') AND " \
-                             "\"r_spec_model_finder_tests\".\"code\" = 'code 1'" )
-    end
-  end
+        expect( finder ).to receive( :estimated_dataset_size ).at_least( :once ).and_call_original
+        expect( finder ).to receive( :estimated_count        ).at_least( :once ).and_call_original
+        expect( finder ).to receive( :count                  ).at_least( :once ).and_call_original
 
-  # ==========================================================================
-
-  context 'acquisition scope and overrides' do
-    def expect_sql( sql, id_attr_name )
-      expect( sql ).to eq( "SELECT \"r_spec_model_finder_tests\".* " \
-                           "FROM \"r_spec_model_finder_tests\" "     \
-                           "WHERE ("                                 \
-                             "("                                     \
-                               "\"r_spec_model_finder_tests\".\"#{ id_attr_name }\" = '#{ @id }' OR " \
-                               "\"r_spec_model_finder_tests\".\"uuid\" = '#{ @id }'"                  \
-                             ") OR "                                               \
-                             "\"r_spec_model_finder_tests\".\"code\" = '#{ @id }'" \
-                           ")" )
-    end
+        result = finder.estimated_dataset_size
 
-    context '#acquisition_scope' do
-      it 'SQL generation is as expected' do
-        sql = RSpecModelFinderTest.acquisition_scope( @id ).to_sql()
-        expect_sql( sql, 'id' )
+        expect( result ).to_not be_nil
       end
-    end
 
-    context '#acquire_with_id_substitute' do
-      before :each do
-        @alt_attr_name = 'foo'
-        RSpecModelFinderTest.acquire_with_id_substitute( @alt_attr_name )
-      end
+      context 'RDoc-recommended PostgreSQL migration example' do
+        before :each do
+          ActiveRecord::Base.connection.execute <<-SQL
+            CREATE FUNCTION estimated_count(query text) RETURNS integer AS
+            $func$
+            DECLARE
+                rec  record;
+                rows integer;
+            BEGIN
+                FOR rec IN EXECUTE 'EXPLAIN ' || query LOOP
+                    rows := substring(rec."QUERY PLAN" FROM ' rows=([[:digit:]]+)');
+                    EXIT WHEN rows IS NOT NULL;
+                END LOOP;
+
+                RETURN rows;
+            END
+            $func$ LANGUAGE plpgsql;
+          SQL
+
+          counter = Proc.new do | sql |
+            begin
+              ActiveRecord::Base.connection.execute(
+                "SELECT estimated_count('#{ sql}')"
+              ).first[ 'estimated_count' ].to_i
+            rescue
+              nil
+            end
+          end
 
-      after :each do
-        RSpecModelFinderTest.acquire_with_id_substitute( 'id' )
-      end
+          RSpecModelFinderTest.estimate_counts_with( counter )
 
-      it 'SQL generation is as expected' do
-        sql = RSpecModelFinderTest.acquisition_scope( @id ).to_sql()
-        expect_sql( sql, @alt_attr_name )
-      end
-    end
-  end
+          # Tests start by ensuring the database knows about the current
+          # object count.
+          #
+          ActiveRecord::Base.connection.execute( 'ANALYZE' )
+        end
 
-  # ==========================================================================
+        after :each do
+          ActiveRecord::Base.connection.execute "DROP FUNCTION estimated_count(query text);"
+          RSpecModelFinderTest.estimate_counts_with( nil )
+        end
 
-  context '#acquire' do
-    it 'finds from the class' do
-      found = RSpecModelFinderTest.acquire( @id )
-      expect( found ).to eq(@a)
+        context 'estimate' do
+          before :each do
+            @initial_count = RSpecModelFinderTest.count
 
-      found = RSpecModelFinderTest.acquire( @uuid )
-      expect( found ).to eq(@b)
+            # The outer 'before' code ensures an accurate initial count of 3,
+            # but we're going add in a few more unestimated items.
+            #
+            @uncounted1 = RSpecModelFinderTest.new.save!
+            @uncounted2 = RSpecModelFinderTest.new.save!
+            @uncounted3 = RSpecModelFinderTest.new.save!
 
-      found = RSpecModelFinderTest.acquire( @code )
-      expect( found ).to eq(@c)
-    end
+            @subsequent_accurate_count = RSpecModelFinderTest.count
+          end
 
-    it 'finds with a chain' do
-      finder = RSpecModelFinderTest.where( :field_one => 'group 1' )
+          it 'may be initially inaccurate' do
+            finder = RSpecModelFinderTest.list( @list_params )
+            result = finder.estimated_dataset_size
+            expect( result ).to eq( @initial_count ).or( eq( @subsequent_accurate_count ) )
+          end
 
-      found = finder.acquire( @id )
-      expect( found ).to eq(@a)
+          # The outer 'before' code kind of already tests this anyway since if
+          # the analyze call therein didn't work, prerequisites in the tests
+          # would be wrong and other tests would fail. It's useful to
+          # double-check something this important though.
+          #
+          it 'is accurate after ANALYZE' do
+            ActiveRecord::Base.connection.execute( 'ANALYZE' )
 
-      found = finder.acquire( @uuid )
-      expect( found ).to eq(@b)
+            finder = RSpecModelFinderTest.list( @list_params )
+            result = finder.estimated_dataset_size
+            expect( result ).to eq( @subsequent_accurate_count )
+          end
 
-      found = finder.acquire( @code )
-      expect( found ).to eq(nil) # Not in 'group 1'
+          it 'is "nil" if the Proc evaluates thus' do
+            RSpecModelFinderTest.estimate_counts_with( Proc.new() { | sql | nil } )
+            finder = RSpecModelFinderTest.list( @list_params )
+            result = finder.estimated_dataset_size
+            expect( result ).to be_nil
+          end
+        end
+      end
     end
+  end
 
-    # Early versions of the 'acquire'-backed methods always inadvertently
-    # performed two database calls, via a count then a true find. This was
-    # refactored to only make one call per attribute, but that in turn can
-    # be much improved via the AREL table to compose a single query that
-    # uses "OR" to get the database to check each attribute in order. Thus
-    # every test below expects exactly one database call only.
-    #
-    context 'only makes one database call when' do
+  # ==========================================================================
 
-      it 'finding on the first attribute' do
-        count = spec_helper_count_database_calls_in do
-          found = RSpecModelFinderTest.acquire( @id )
-          expect( found ).to eq(@a)
-        end
+  context "(randomised)", :order => :random do
+    context '#scoped_in' do
+      before :each do
 
-        expect( count ).to eq( 1 )
-      end
+        # Get a good-enough-for-test interaction which has a context
+        # that contains a Session we can modify.
 
-      it 'finding on the second attribute' do
-        count = spec_helper_count_database_calls_in do
-          found = RSpecModelFinderTest.acquire( @uuid )
-          expect( found ).to eq(@b)
-        end
+        @interaction = Hoodoo::Services::Middleware::Interaction.new( {}, nil )
+        @interaction.context = Hoodoo::Services::Context.new(
+          Hoodoo::Services::Session.new,
+          @interaction.context.request,
+          @interaction.context.response,
+          @interaction
+        )
 
-        expect( count ).to eq( 1 )
+        @context = @interaction.context
+        @session = @interaction.context.session
       end
 
-      it 'finding on the third attribute' do
-        count = spec_helper_count_database_calls_in do
-          found = RSpecModelFinderTest.acquire( @code )
-          expect( found ).to eq(@c)
-        end
+      # If security scoping works _and_ we know that it called #full_scope_for
+      # in the "internal"-ish support API, then we consider that good enough
+      # to prove that it's calling the scope engine and that engine has its
+      # own comprehensive test coverage in suport_spec.rb.
+      #
+      it 'generates appropriate scope' do
+        @session.scoping = { :authorised_uuids => [ 'uuid 1', 'uuid 2' ], :authorised_code => 'code 1' }
+
+        expect( Hoodoo::ActiveRecord::Support ).to(
+          receive( :full_scope_for ).once().with(
+            RSpecModelFinderTest, @context
+          ).and_call_original()
+        )
+
+        sql = RSpecModelFinderTest.scoped_in( @context ).to_sql
+
+        expect( sql ).to eq( "SELECT \"r_spec_model_finder_tests\".* " \
+                             "FROM \"r_spec_model_finder_tests\" "     \
+                             "WHERE "                                  \
+                               "\"r_spec_model_finder_tests\".\"uuid\" IN ('uuid 1', 'uuid 2') AND " \
+                               "\"r_spec_model_finder_tests\".\"code\" = 'code 1'" )
+      end
+    end
 
-        expect( count ).to eq( 1 )
+    # ========================================================================
+
+    context 'acquisition scope and overrides' do
+      def expect_sql( sql, id_attr_name )
+        expect( sql ).to eq( "SELECT \"r_spec_model_finder_tests\".* " \
+                             "FROM \"r_spec_model_finder_tests\" "     \
+                             "WHERE ("                                 \
+                               "("                                     \
+                                 "\"r_spec_model_finder_tests\".\"#{ id_attr_name }\" = '#{ @id }' OR " \
+                                 "\"r_spec_model_finder_tests\".\"uuid\" = '#{ @id }'"                  \
+                               ") OR "                                               \
+                               "\"r_spec_model_finder_tests\".\"code\" = '#{ @id }'" \
+                             ")" )
       end
 
-      it 'checking all three attributes but finding nothing' do
-        count = spec_helper_count_database_calls_in do
-          found = RSpecModelFinderTest.acquire( Hoodoo::UUID.generate )
-          expect( found ).to be_nil
+      context '#acquisition_scope' do
+        it 'SQL generation is as expected' do
+          sql = RSpecModelFinderTest.acquisition_scope( @id ).to_sql()
+          expect_sql( sql, 'id' )
         end
-
-        expect( count ).to eq( 1 )
       end
-    end
-  end
 
-  # ==========================================================================
+      context '#acquire_with_id_substitute' do
+        before :each do
+          @alt_attr_name = 'foo'
+          RSpecModelFinderTest.acquire_with_id_substitute( @alt_attr_name )
+        end
 
-  context '#acquire_in' do
-    before :each do
-      @scoped_1 = RSpecModelFinderTest.new
-      @scoped_1.id        = 'id 1'
-      @scoped_1.uuid      = 'uuid 1'
-      @scoped_1.code      = 'code 1'
-      @scoped_1.field_one = 'scoped 1'
-      @scoped_1.save!
-
-      @scoped_2 = RSpecModelFinderTest.new
-      @scoped_2.id        = 'id 2'
-      @scoped_2.uuid      = 'uuid 1'
-      @scoped_2.code      = 'code 2'
-      @scoped_2.field_one = 'scoped 2'
-      @scoped_2.save!
-
-      @scoped_3 = RSpecModelFinderTest.new
-      @scoped_3.id        = 'id 3'
-      @scoped_3.uuid      = 'uuid 2'
-      @scoped_3.code      = 'code 2'
-      @scoped_3.field_one = 'scoped 3'
-      @scoped_3.save!
-
-      # Get a good-enough-for-test interaction which has a context
-      # that contains a Session we can modify.
-
-      @interaction = Hoodoo::Services::Middleware::Interaction.new( {}, nil )
-      @interaction.context = Hoodoo::Services::Context.new(
-        Hoodoo::Services::Session.new,
-        @interaction.context.request,
-        @interaction.context.response,
-        @interaction
-      )
+        after :each do
+          RSpecModelFinderTest.acquire_with_id_substitute( 'id' )
+        end
 
-      @context = @interaction.context
-      @session = @interaction.context.session
+        it 'SQL generation is as expected' do
+          sql = RSpecModelFinderTest.acquisition_scope( @id ).to_sql()
+          expect_sql( sql, @alt_attr_name )
+        end
+      end
     end
 
-    it 'knowns how to acquire' do
-
-      # Note the corresponding 'acquire_with' used Symbols and had a
-      # duplicated entry - we expect Strings and no duplicates here.
-      #
-      expect( RSpecModelFinderTest.acquired_with() ).to eq( [ 'uuid', 'code' ] )
-
-    end
+    # ========================================================================
 
-    it 'finds with secure scopes from the class' do
-      @session.scoping = { :authorised_uuids => [ 'uuid 1' ], :authorised_code => 'code 1' }
+    context '#acquire' do
+      it 'finds from the class' do
+        found = RSpecModelFinderTest.acquire( @id )
+        expect( found ).to eq(@a)
 
-      @context.request.uri_path_components = [ @scoped_1.id ]
-      found = RSpecModelFinderTest.acquire_in( @context )
-      expect( found ).to eq( @scoped_1 )
+        found = RSpecModelFinderTest.acquire( @uuid )
+        expect( found ).to eq(@b)
 
-      @context.request.uri_path_components = [ @scoped_2.id ]
-      found = RSpecModelFinderTest.acquire_in( @context )
-      expect( found ).to be_nil
+        found = RSpecModelFinderTest.acquire( @code )
+        expect( found ).to eq(@c)
+      end
 
-      @context.request.uri_path_components = [ @scoped_3.id ]
-      found = RSpecModelFinderTest.acquire_in( @context )
-      expect( found ).to be_nil
+      it 'finds with a chain' do
+        finder = RSpecModelFinderTest.where( :field_one => 'group 1' )
 
-      @session.scoping.authorised_code = 'code 2'
+        found = finder.acquire( @id )
+        expect( found ).to eq(@a)
 
-      @context.request.uri_path_components = [ @scoped_1.id ]
-      found = RSpecModelFinderTest.acquire_in( @context )
-      expect( found ).to be_nil
+        found = finder.acquire( @uuid )
+        expect( found ).to eq(@b)
 
-      @context.request.uri_path_components = [ @scoped_2.id ]
-      found = RSpecModelFinderTest.acquire_in( @context )
-      expect( found ).to eq( @scoped_2 )
+        found = finder.acquire( @code )
+        expect( found ).to eq(nil) # Not in 'group 1'
+      end
 
-      @context.request.uri_path_components = [ @scoped_3.id ]
-      found = RSpecModelFinderTest.acquire_in( @context )
-      expect( found ).to be_nil
+      # Early versions of the 'acquire'-backed methods always inadvertently
+      # performed two database calls, via a count then a true find. This was
+      # refactored to only make one call per attribute, but that in turn can
+      # be much improved via the AREL table to compose a single query that
+      # uses "OR" to get the database to check each attribute in order. Thus
+      # every test below expects exactly one database call only.
+      #
+      context 'only makes one database call when' do
 
-      @session.scoping.authorised_uuids = [ 'uuid 2' ]
+        it 'finding on the first attribute' do
+          count = spec_helper_count_database_calls_in do
+            found = RSpecModelFinderTest.acquire( @id )
+            expect( found ).to eq(@a)
+          end
 
-      @context.request.uri_path_components = [ @scoped_1.id ]
-      found = RSpecModelFinderTest.acquire_in( @context )
-      expect( found ).to be_nil
+          expect( count ).to eq( 1 )
+        end
 
-      @context.request.uri_path_components = [ @scoped_2.id ]
-      found = RSpecModelFinderTest.acquire_in( @context )
-      expect( found ).to be_nil
+        it 'finding on the second attribute' do
+          count = spec_helper_count_database_calls_in do
+            found = RSpecModelFinderTest.acquire( @uuid )
+            expect( found ).to eq(@b)
+          end
 
-      @context.request.uri_path_components = [ @scoped_3.id ]
-      found = RSpecModelFinderTest.acquire_in( @context )
-      expect( found ).to eq( @scoped_3 )
+          expect( count ).to eq( 1 )
+        end
 
-      @session.scoping.authorised_uuids = [ 'uuid 1', 'uuid 2' ]
+        it 'finding on the third attribute' do
+          count = spec_helper_count_database_calls_in do
+            found = RSpecModelFinderTest.acquire( @code )
+            expect( found ).to eq(@c)
+          end
 
-      @context.request.uri_path_components = [ @scoped_1.id ]
-      found = RSpecModelFinderTest.acquire_in( @context )
-      expect( found ).to be_nil
+          expect( count ).to eq( 1 )
+        end
 
-      @context.request.uri_path_components = [ @scoped_2.id ]
-      found = RSpecModelFinderTest.acquire_in( @context )
-      expect( found ).to eq( @scoped_2 )
+        it 'checking all three attributes but finding nothing' do
+          count = spec_helper_count_database_calls_in do
+            found = RSpecModelFinderTest.acquire( Hoodoo::UUID.generate )
+            expect( found ).to be_nil
+          end
 
-      @context.request.uri_path_components = [ @scoped_3.id ]
-      found = RSpecModelFinderTest.acquire_in( @context )
-      expect( found ).to eq( @scoped_3 )
+          expect( count ).to eq( 1 )
+        end
+      end
     end
 
-    it 'finds with secure scopes with a chain' do
-      @session.scoping = { :authorised_uuids => [ 'uuid 1' ], :authorised_code => 'code 1' }
+    # ========================================================================
 
-      @context.request.uri_path_components = [ @scoped_1.id ]
-      found = RSpecModelFinderTest.where( :field_one => @scoped_1.field_one ).acquire_in( @context )
-      expect( found ).to eq( @scoped_1 )
+    context '#acquire_in' do
+      before :each do
+        @scoped_1 = RSpecModelFinderTest.new
+        @scoped_1.id        = 'id 1'
+        @scoped_1.uuid      = 'uuid 1'
+        @scoped_1.code      = 'code 1'
+        @scoped_1.field_one = 'scoped 1'
+        @scoped_1.save!
+
+        @scoped_2 = RSpecModelFinderTest.new
+        @scoped_2.id        = 'id 2'
+        @scoped_2.uuid      = 'uuid 1'
+        @scoped_2.code      = 'code 2'
+        @scoped_2.field_one = 'scoped 2'
+        @scoped_2.save!
+
+        @scoped_3 = RSpecModelFinderTest.new
+        @scoped_3.id        = 'id 3'
+        @scoped_3.uuid      = 'uuid 2'
+        @scoped_3.code      = 'code 2'
+        @scoped_3.field_one = 'scoped 3'
+        @scoped_3.save!
+
+        # Get a good-enough-for-test interaction which has a context
+        # that contains a Session we can modify.
+
+        @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
+        @session = @interaction.context.session
+      end
 
-      @context.request.uri_path_components = [ @scoped_1.id ]
-      found = RSpecModelFinderTest.where( :field_one => @scoped_1.field_one + '!' ).acquire_in( @context )
-      expect( found ).to be_nil
+      it 'knowns how to acquire' do
 
-      @context.request.uri_path_components = [ @scoped_2.id ]
-      found = RSpecModelFinderTest.where( :field_one => @scoped_2.field_one ).acquire_in( @context )
-      expect( found ).to be_nil
+        # Note the corresponding 'acquire_with' used Symbols and had a
+        # duplicated entry - we expect Strings and no duplicates here.
+        #
+        expect( RSpecModelFinderTest.acquired_with() ).to eq( [ 'uuid', 'code' ] )
 
-      @context.request.uri_path_components = [ @scoped_3.id ]
-      found = RSpecModelFinderTest.where( :field_one => @scoped_3.field_one ).acquire_in( @context )
-      expect( found ).to be_nil
+      end
 
-      @session.scoping.authorised_uuids = [ 'uuid 1', 'uuid 2' ]
-      @session.scoping.authorised_code  = 'code 2'
+      it 'finds with secure scopes from the class' do
+        @session.scoping = { :authorised_uuids => [ 'uuid 1' ], :authorised_code => 'code 1' }
 
-      @context.request.uri_path_components = [ @scoped_1.id ]
-      found = RSpecModelFinderTest.where( :field_one => @scoped_1.field_one ).acquire_in( @context )
-      expect( found ).to be_nil
+        @context.request.uri_path_components = [ @scoped_1.id ]
+        found = RSpecModelFinderTest.acquire_in( @context )
+        expect( found ).to eq( @scoped_1 )
 
-      @context.request.uri_path_components = [ @scoped_2.id ]
-      found = RSpecModelFinderTest.where( :field_one => @scoped_2.field_one ).acquire_in( @context )
-      expect( found ).to eq( @scoped_2 )
+        @context.request.uri_path_components = [ @scoped_2.id ]
+        found = RSpecModelFinderTest.acquire_in( @context )
+        expect( found ).to be_nil
 
-      @context.request.uri_path_components = [ @scoped_3.id ]
-      found = RSpecModelFinderTest.where( :field_one => @scoped_3.field_one ).acquire_in( @context )
-      expect( found ).to eq( @scoped_3 )
+        @context.request.uri_path_components = [ @scoped_3.id ]
+        found = RSpecModelFinderTest.acquire_in( @context )
+        expect( found ).to be_nil
 
-      @context.request.uri_path_components = [ @scoped_3.id ]
-      found = RSpecModelFinderTest.where( :field_one => @scoped_3.field_one + '!' ).acquire_in( @context )
-      expect( found ).to be_nil
-    end
-  end
+        @session.scoping.authorised_code = 'code 2'
 
-  # ==========================================================================
+        @context.request.uri_path_components = [ @scoped_1.id ]
+        found = RSpecModelFinderTest.acquire_in( @context )
+        expect( found ).to be_nil
 
-  context '#list' do
-    it 'lists with pages, offsets and counts' do
-      expect_any_instance_of( RSpecModelFinderTest ).to_not receive( :estimated_dataset_size )
+        @context.request.uri_path_components = [ @scoped_2.id ]
+        found = RSpecModelFinderTest.acquire_in( @context )
+        expect( found ).to eq( @scoped_2 )
 
-      @list_params.offset = 1 # 0 is first record
-      @list_params.limit  = 1
+        @context.request.uri_path_components = [ @scoped_3.id ]
+        found = RSpecModelFinderTest.acquire_in( @context )
+        expect( found ).to be_nil
 
-      finder = RSpecModelFinderTest.order( :field_three => :asc ).list( @list_params )
-      expect( finder ).to eq([@b])
-      expect( finder.dataset_size).to eq(3)
+        @session.scoping.authorised_uuids = [ 'uuid 2' ]
 
-      @list_params.offset = 1
-      @list_params.limit  = 2
+        @context.request.uri_path_components = [ @scoped_1.id ]
+        found = RSpecModelFinderTest.acquire_in( @context )
+        expect( found ).to be_nil
 
-      finder = RSpecModelFinderTest.order( :field_three => :asc ).list( @list_params )
-      expect( finder ).to eq([@b, @c])
-      expect( finder.dataset_size).to eq(3)
-    end
-  end
+        @context.request.uri_path_components = [ @scoped_2.id ]
+        found = RSpecModelFinderTest.acquire_in( @context )
+        expect( found ).to be_nil
 
-  # ==========================================================================
+        @context.request.uri_path_components = [ @scoped_3.id ]
+        found = RSpecModelFinderTest.acquire_in( @context )
+        expect( found ).to eq( @scoped_3 )
 
-  context 'counting' do
-    it 'lists with a normal count' do
-      finder = RSpecModelFinderTest.list( @list_params )
+        @session.scoping.authorised_uuids = [ 'uuid 1', 'uuid 2' ]
 
-      expect( finder ).to receive( :dataset_size ).at_least( :once ).and_call_original
-      expect( finder ).to receive( :count        ).at_least( :once ).and_call_original
+        @context.request.uri_path_components = [ @scoped_1.id ]
+        found = RSpecModelFinderTest.acquire_in( @context )
+        expect( found ).to be_nil
 
-      expect( finder ).to_not receive( :estimated_dataset_size )
-      expect( finder ).to_not receive( :estimated_count        )
+        @context.request.uri_path_components = [ @scoped_2.id ]
+        found = RSpecModelFinderTest.acquire_in( @context )
+        expect( found ).to eq( @scoped_2 )
 
-      result = finder.dataset_size()
+        @context.request.uri_path_components = [ @scoped_3.id ]
+        found = RSpecModelFinderTest.acquire_in( @context )
+        expect( found ).to eq( @scoped_3 )
+      end
 
-      expect( result ).to_not be_nil
-    end
+      it 'finds with secure scopes with a chain' do
+        @session.scoping = { :authorised_uuids => [ 'uuid 1' ], :authorised_code => 'code 1' }
 
-    it 'lists with an estimated count' do
-      finder = RSpecModelFinderTest.list( @list_params )
+        @context.request.uri_path_components = [ @scoped_1.id ]
+        found = RSpecModelFinderTest.where( :field_one => @scoped_1.field_one ).acquire_in( @context )
+        expect( found ).to eq( @scoped_1 )
 
-      expect( finder ).to_not receive( :dataset_size )
+        @context.request.uri_path_components = [ @scoped_1.id ]
+        found = RSpecModelFinderTest.where( :field_one => @scoped_1.field_one + '!' ).acquire_in( @context )
+        expect( found ).to be_nil
 
-      expect( finder ).to receive( :estimated_dataset_size ).at_least( :once ).and_call_original
-      expect( finder ).to receive( :estimated_count        ).at_least( :once ).and_call_original
-      expect( finder ).to receive( :count                  ).at_least( :once ).and_call_original
+        @context.request.uri_path_components = [ @scoped_2.id ]
+        found = RSpecModelFinderTest.where( :field_one => @scoped_2.field_one ).acquire_in( @context )
+        expect( found ).to be_nil
 
-      result = finder.estimated_dataset_size
+        @context.request.uri_path_components = [ @scoped_3.id ]
+        found = RSpecModelFinderTest.where( :field_one => @scoped_3.field_one ).acquire_in( @context )
+        expect( found ).to be_nil
 
-      expect( result ).to_not be_nil
-    end
+        @session.scoping.authorised_uuids = [ 'uuid 1', 'uuid 2' ]
+        @session.scoping.authorised_code  = 'code 2'
 
-    context 'RDoc-recommended PostgreSQL migration example' do
-      before :each do
-        ActiveRecord::Base.connection.execute <<-SQL
-          CREATE FUNCTION estimated_count(query text) RETURNS integer AS
-          $func$
-          DECLARE
-              rec  record;
-              rows integer;
-          BEGIN
-              FOR rec IN EXECUTE 'EXPLAIN ' || query LOOP
-                  rows := substring(rec."QUERY PLAN" FROM ' rows=([[:digit:]]+)');
-                  EXIT WHEN rows IS NOT NULL;
-              END LOOP;
-
-              RETURN rows;
-          END
-          $func$ LANGUAGE plpgsql;
-        SQL
-
-        counter = Proc.new do | sql |
-          begin
-            ActiveRecord::Base.connection.execute(
-              "SELECT estimated_count('#{ sql}')"
-            ).first[ 'estimated_count' ].to_i
-          rescue
-            nil
-          end
-        end
+        @context.request.uri_path_components = [ @scoped_1.id ]
+        found = RSpecModelFinderTest.where( :field_one => @scoped_1.field_one ).acquire_in( @context )
+        expect( found ).to be_nil
 
-        RSpecModelFinderTest.estimate_counts_with( counter )
+        @context.request.uri_path_components = [ @scoped_2.id ]
+        found = RSpecModelFinderTest.where( :field_one => @scoped_2.field_one ).acquire_in( @context )
+        expect( found ).to eq( @scoped_2 )
 
-        # Tests start by ensuring the database knows about the current object count.
-        #
-        ActiveRecord::Base.connection.execute( 'ANALYZE' )
-      end
+        @context.request.uri_path_components = [ @scoped_3.id ]
+        found = RSpecModelFinderTest.where( :field_one => @scoped_3.field_one ).acquire_in( @context )
+        expect( found ).to eq( @scoped_3 )
 
-      after :each do
-        ActiveRecord::Base.connection.execute "DROP FUNCTION estimated_count(query text);"
-        RSpecModelFinderTest.estimate_counts_with( nil )
+        @context.request.uri_path_components = [ @scoped_3.id ]
+        found = RSpecModelFinderTest.where( :field_one => @scoped_3.field_one + '!' ).acquire_in( @context )
+        expect( found ).to be_nil
       end
+    end
 
-      # These must run in order else e.g. the ANALYZE might happen before the
-      # pre-ANALYZE test, breaking the results.
-      #
-      context 'estimate', :order => :defined do
-        before :each do
-          @initial_count = RSpecModelFinderTest.count
-
-          # The outer 'before' code ensures an accurate initial count of 3,
-          # but we're going add in a few more unestimated items.
-          #
-          @uncounted1 = RSpecModelFinderTest.new.save!
-          @uncounted2 = RSpecModelFinderTest.new.save!
-          @uncounted3 = RSpecModelFinderTest.new.save!
+    # ========================================================================
 
-          @subsequent_accurate_count = RSpecModelFinderTest.count
-        end
+    context '#list' do
+      it 'lists with pages, offsets and counts' do
+        expect_any_instance_of( RSpecModelFinderTest ).to_not receive( :estimated_dataset_size )
 
-        it 'may be initially inaccurate' do
-          finder = RSpecModelFinderTest.list( @list_params )
-          result = finder.estimated_dataset_size
-          expect( result ).to eq( @initial_count ).or( eq( @subsequent_accurate_count ) )
-        end
+        @list_params.offset = 1 # 0 is first record
+        @list_params.limit  = 1
 
-        # The outer 'before' code kind of already tests this anyway since if
-        # the analyze call therein didn't work, prerequisites in the tests
-        # would be wrong and other tests would fail. It's useful to
-        # double-check something this important though.
-        #
-        it 'is accurate after ANALYZE' do
-          ActiveRecord::Base.connection.execute( 'ANALYZE' )
+        finder = RSpecModelFinderTest.order( :field_three => :asc ).list( @list_params )
+        expect( finder ).to eq([@b])
+        expect( finder.dataset_size).to eq(3)
 
-          finder = RSpecModelFinderTest.list( @list_params )
-          result = finder.estimated_dataset_size
-          expect( result ).to eq( @subsequent_accurate_count )
-        end
+        @list_params.offset = 1
+        @list_params.limit  = 2
 
-        it 'is "nil" if the Proc evaluates thus' do
-          RSpecModelFinderTest.estimate_counts_with( Proc.new() { | sql | nil } )
-          finder = RSpecModelFinderTest.list( @list_params )
-          result = finder.estimated_dataset_size
-          expect( result ).to be_nil
-        end
+        finder = RSpecModelFinderTest.order( :field_three => :asc ).list( @list_params )
+        expect( finder ).to eq([@b, @c])
+        expect( finder.dataset_size).to eq(3)
       end
     end
-  end
 
-  # ==========================================================================
+    # ========================================================================
 
-  context 'search' do
-    it 'searches without chain' do
-      @list_params.search_data = {
-        'field_one' => 'group 1'
-      }
+    context 'search' do
+      it 'searches without chain' do
+        @list_params.search_data = {
+          'field_one' => 'group 1'
+        }
 
-      finder = RSpecModelFinderTest.list( @list_params )
-      expect( finder ).to eq([@b, @a])
+        finder = RSpecModelFinderTest.list( @list_params )
+        expect( finder ).to eq([@b, @a])
 
-      @list_params.search_data = {
-        'field_one' => 'group 2'
-      }
+        @list_params.search_data = {
+          'field_one' => 'group 2'
+        }
 
-      finder = RSpecModelFinderTest.list( @list_params )
-      expect( finder ).to eq([@c])
+        finder = RSpecModelFinderTest.list( @list_params )
+        expect( finder ).to eq([@c])
 
-      @list_params.search_data = {
-        'field_two' => 'TWO_A'
-      }
+        @list_params.search_data = {
+          'field_two' => 'TWO_A'
+        }
 
-      finder = RSpecModelFinderTest.list( @list_params )
-      expect( finder ).to eq([@a])
+        finder = RSpecModelFinderTest.list( @list_params )
+        expect( finder ).to eq([@a])
 
-      @list_params.search_data = {
-        'field_three' => [ 'three a', 'three c' ]
-      }
+        @list_params.search_data = {
+          'field_three' => [ 'three a', 'three c' ]
+        }
 
-      finder = RSpecModelFinderTest.list( @list_params )
-      expect( finder ).to eq([@c, @a])
+        finder = RSpecModelFinderTest.list( @list_params )
+        expect( finder ).to eq([@c, @a])
 
-      @list_params.search_data = {
-        'field_two' => 'two c',
-        'field_three' => [ 'three a', 'three c' ]
-      }
+        @list_params.search_data = {
+          'field_two' => 'two c',
+          'field_three' => [ 'three a', 'three c' ]
+        }
 
-      finder = RSpecModelFinderTest.list( @list_params )
-      expect( finder ).to eq([@c])
+        finder = RSpecModelFinderTest.list( @list_params )
+        expect( finder ).to eq([@c])
 
-      @list_params.search_data = {
-        'created_after' => @tn - 1.month
-      }
+        @list_params.search_data = {
+          'created_after' => @tn - 1.month
+        }
 
-      finder = RSpecModelFinderTest.list( @list_params )
-      expect( finder ).to eq([@c])
+        finder = RSpecModelFinderTest.list( @list_params )
+        expect( finder ).to eq([@c])
 
-      @list_params.search_data = {
-        'created_before' => @tn - 1.month
-      }
+        @list_params.search_data = {
+          'created_before' => @tn - 1.month
+        }
 
-      finder = RSpecModelFinderTest.list( @list_params )
-      expect( finder ).to eq([@a])
+        finder = RSpecModelFinderTest.list( @list_params )
+        expect( finder ).to eq([@a])
 
-      @list_params.search_data = {
-        'created_before' => @tn - 1.month + 1.day
-      }
-
-      finder = RSpecModelFinderTest.list( @list_params )
-      expect( finder ).to eq([@b, @a])
-    end
+        @list_params.search_data = {
+          'created_before' => @tn - 1.month + 1.day
+        }
 
-    it 'searches with chain' do
-      constraint = RSpecModelFinderTest.where( :field_one => 'group 1' )
+        finder = RSpecModelFinderTest.list( @list_params )
+        expect( finder ).to eq([@b, @a])
 
-      @list_params.search_data = {
-        'field_one' => 'group 1'
-      }
+        @list_params.search_data = {
+          'created_by' => @cb1
+        }
 
-      finder = constraint.list( @list_params )
-      expect( finder ).to eq([@b, @a])
+        finder = RSpecModelFinderTest.list( @list_params )
+        expect( finder ).to eq([@b, @a])
 
-      @list_params.search_data = {
-        'field_one' => 'group 2'
-      }
+        @list_params.search_data = {
+          'created_by' => @cb2
+        }
 
-      finder = constraint.list( @list_params )
-      expect( finder ).to eq([])
+        finder = RSpecModelFinderTest.list( @list_params )
+        expect( finder ).to eq([@c])
+      end
 
-      @list_params.search_data = {
-        'field_two' => 'TWO_A'
-      }
+      it 'searches with chain' do
+        constraint = RSpecModelFinderTest.where( :field_one => 'group 1' )
 
-      finder = constraint.list( @list_params )
-      expect( finder ).to eq([@a])
+        @list_params.search_data = {
+          'field_one' => 'group 1'
+        }
 
-      @list_params.search_data = {
-        'field_three' => [ 'three a', 'three c' ]
-      }
+        finder = constraint.list( @list_params )
+        expect( finder ).to eq([@b, @a])
 
-      finder = constraint.list( @list_params )
-      expect( finder ).to eq([@a])
+        @list_params.search_data = {
+          'field_one' => 'group 2'
+        }
 
-      @list_params.search_data = {
-        'field_two' => 'two c',
-        'field_three' => [ 'three a', 'three c' ]
-      }
+        finder = constraint.list( @list_params )
+        expect( finder ).to eq([])
 
-      finder = constraint.list( @list_params )
-      expect( finder ).to eq([])
+        @list_params.search_data = {
+          'field_two' => 'TWO_A'
+        }
 
-      @list_params.search_data = {
-        'created_after' => @tn - 1.month
-      }
+        finder = constraint.list( @list_params )
+        expect( finder ).to eq([@a])
 
-      finder = constraint.list( @list_params )
-      expect( finder ).to eq([])
+        @list_params.search_data = {
+          'field_three' => [ 'three a', 'three c' ]
+        }
 
-      @list_params.search_data = {
-        'created_before' => @tn - 1.month
-      }
+        finder = constraint.list( @list_params )
+        expect( finder ).to eq([@a])
 
-      finder = constraint.list( @list_params )
-      expect( finder ).to eq([@a])
+        @list_params.search_data = {
+          'field_two' => 'two c',
+          'field_three' => [ 'three a', 'three c' ]
+        }
 
-      @list_params.search_data = {
-        'created_before' => @tn - 1.month + 1.day
-      }
+        finder = constraint.list( @list_params )
+        expect( finder ).to eq([])
 
-      finder = constraint.list( @list_params )
-      expect( finder ).to eq([@b, @a])
-    end
-  end
+        @list_params.search_data = {
+          'created_after' => @tn - 1.month
+        }
 
-  # ==========================================================================
+        finder = constraint.list( @list_params )
+        expect( finder ).to eq([])
 
-  context 'helper-based search' do
-    it 'finds by mapped code' do
-      @list_params.search_data = {
-        'mapped_code' => @code
-      }
+        @list_params.search_data = {
+          'created_before' => @tn - 1.month
+        }
 
-      finder = RSpecModelFinderTestWithHelpers.list( @list_params )
-      expect( finder ).to eq( [ @c_wh ] )
-    end
+        finder = constraint.list( @list_params )
+        expect( finder ).to eq([@a])
 
-    it 'finds by mapped field-one' do
-      @list_params.search_data = {
-        'mapped_field_one' => :'grOUp 1'
-      }
+        @list_params.search_data = {
+          'created_before' => @tn - 1.month + 1.day
+        }
 
-      finder = RSpecModelFinderTestWithHelpers.list( @list_params )
-      expect( finder ).to eq( [ @b_wh, @a_wh ] )
-    end
+        finder = constraint.list( @list_params )
+        expect( finder ).to eq([@b, @a])
 
-    it 'finds by mapped, wildcard field-one' do
-      @list_params.search_data = {
-        'wild_field_one' => :'oUP '
-      }
+        @list_params.search_data = {
+          'created_by' => @cb1
+        }
 
-      finder = RSpecModelFinderTestWithHelpers.list( @list_params )
-      expect( finder ).to eq( [ @c_wh, @b_wh, @a_wh ] )
+        finder = constraint.list( @list_params )
+        expect( finder ).to eq([@b, @a])
 
-      @list_params.search_data = {
-        'wild_field_one' => :'o!p '
-      }
+        @list_params.search_data = {
+          'created_by' => @cb2
+        }
 
-      finder = RSpecModelFinderTestWithHelpers.list( @list_params )
-      expect( finder ).to eq( [] )
+        finder = constraint.list( @list_params )
+        expect( finder ).to eq([])
+      end
     end
 
-    it 'finds by comma-separated list' do
-      @list_params.search_data = {
-        'field_two' => 'two a,something else,two c,more'
-      }
+    # ========================================================================
 
-      finder = RSpecModelFinderTestWithHelpers.list( @list_params )
-      expect( finder ).to eq( [ @c_wh, @a_wh ] )
-    end
+    context 'helper-based search' do
+      it 'finds by mapped code' do
+        @list_params.search_data = {
+          'mapped_code' => @code
+        }
 
-    it 'finds by Array' do
-      @list_params.search_data = {
-        'field_three' => [ 'hello', :'three b', 'three c', :there ]
-      }
+        finder = RSpecModelFinderTestWithHelpers.list( @list_params )
+        expect( finder ).to eq( [ @c_wh ] )
+      end
 
-      finder = RSpecModelFinderTestWithHelpers.list( @list_params )
-      expect( finder ).to eq( [ @c_wh, @b_wh ] )
-    end
+      it 'finds by mapped field-one' do
+        @list_params.search_data = {
+          'mapped_field_one' => :'grOUp 1'
+        }
 
-    it 'finds with framework override' do
-      @list_params.search_data = {
-        'created_after' => @tn - 1.week
-      }
+        finder = RSpecModelFinderTestWithHelpers.list( @list_params )
+        expect( finder ).to eq( [ @b_wh, @a_wh ] )
+      end
 
-      finder = RSpecModelFinderTestWithHelpers.list( @list_params )
-      expect( finder ).to eq( [ @c_wh, @b_wh ] )
+      it 'finds by mapped, wildcard field-one' do
+        @list_params.search_data = {
+          'wild_field_one' => :'oUP '
+        }
 
-      @list_params.search_data = {
-        'created_after' => @tn + 1.day
-      }
+        finder = RSpecModelFinderTestWithHelpers.list( @list_params )
+        expect( finder ).to eq( [ @c_wh, @b_wh, @a_wh ] )
 
-      finder = RSpecModelFinderTestWithHelpers.list( @list_params )
-      expect( finder ).to eq( [ @c_wh ] )
-    end
-  end
+        @list_params.search_data = {
+          'wild_field_one' => :'o!p '
+        }
 
-  # ==========================================================================
+        finder = RSpecModelFinderTestWithHelpers.list( @list_params )
+        expect( finder ).to eq( [] )
+      end
 
-  context 'pure framework search' do
-    it 'on created_after' do
-      @list_params.search_data = {
-        'created_after' => @tn - 1.month
-      }
+      it 'finds by comma-separated list' do
+        @list_params.search_data = {
+          'field_two' => 'two a,something else,two c,more'
+        }
 
-      finder = RSpecModelFinderWithoutSearchOrFilterTest.list( @list_params )
-      expect( finder ).to eq( [ @c_wosf ] )
-    end
+        finder = RSpecModelFinderTestWithHelpers.list( @list_params )
+        expect( finder ).to eq( [ @c_wh, @a_wh ] )
+      end
 
-    it 'on created_before' do
-      @list_params.search_data = {
-        'created_before' => @tn - 1.month
-      }
+      it 'finds by Array' do
+        @list_params.search_data = {
+          'field_three' => [ 'hello', :'three b', 'three c', :there ]
+        }
 
-      finder = RSpecModelFinderWithoutSearchOrFilterTest.list( @list_params )
-      expect( finder ).to eq( [ @a_wosf ] )
-    end
-  end
+        finder = RSpecModelFinderTestWithHelpers.list( @list_params )
+        expect( finder ).to eq( [ @c_wh, @b_wh ] )
+      end
 
-  # ==========================================================================
+      it 'finds with framework override (to same column)' do
+        @list_params.search_data = {
+          'created_after' => @tn - 1.week
+        }
+
+        finder = RSpecModelFinderTestWithHelpers.list( @list_params )
+        expect( finder ).to eq( [ @c_wh, @b_wh ] )
 
-  context 'as a Hoodoo::ActiveRecord::Base subclass and sub-subclass' do # (instead of explicitly including the Finder module)
-    context 'custom search' do
-      it 'on mapped_code' do
         @list_params.search_data = {
-          'mapped_code' => @code
+          'created_after' => @tn + 1.day
         }
 
-        finder = RSpecModelFinderSubclassTest.list( @list_params )
-        expect( finder ).to eq( [ @c_sc ] )
+        finder = RSpecModelFinderTestWithHelpers.list( @list_params )
+        expect( finder ).to eq( [ @c_wh ] )
+      end
 
-        finder = RSpecModelFinderSubclassATest.list( @list_params )
-        expect( finder ).to eq( [ @c_sc_a ] )
+      it 'finds by framework override (to different column)' do
+        @list_params.search_data = {
+          'created_by' => 'b' # Maps to 'code' field, case insensitive
+        }
 
-        finder = RSpecModelFinderSubclassBTest.list( @list_params )
-        expect( finder ).to eq( [ @c_sc_b ] )
+        finder = RSpecModelFinderTestWithHelpers.list( @list_params )
+        expect( finder ).to eq( [ @b_wh ] )
       end
     end
 
+    # ========================================================================
+
     context 'pure framework search' do
       it 'on created_after' do
         @list_params.search_data = {
           'created_after' => @tn - 1.month
         }
 
-        finder = RSpecModelFinderSubclassWithoutSearchOrFilterTest.list( @list_params )
-        expect( finder ).to eq( [ @c_sc_wosf ] )
-
-        finder = RSpecModelFinderSubclassWithoutSearchOrFilterATest.list( @list_params )
-        expect( finder ).to eq( [ @c_sc_wosf_a ] )
-
-        finder = RSpecModelFinderSubclassWithoutSearchOrFilterBTest.list( @list_params )
-        expect( finder ).to eq( [ @c_sc_wosf_b ] )
+        finder = RSpecModelFinderWithoutSearchOrFilterTest.list( @list_params )
+        expect( finder ).to eq( [ @c_wosf ] )
       end
 
       it 'on created_before' do
@@ -892,279 +898,316 @@ describe Hoodoo::ActiveRecord::Finder do
           'created_before' => @tn - 1.month
         }
 
-        finder = RSpecModelFinderSubclassWithoutSearchOrFilterTest.list( @list_params )
-        expect( finder ).to eq( [ @a_sc_wosf ] )
+        finder = RSpecModelFinderWithoutSearchOrFilterTest.list( @list_params )
+        expect( finder ).to eq( [ @a_wosf ] )
+      end
 
-        finder = RSpecModelFinderSubclassWithoutSearchOrFilterATest.list( @list_params )
-        expect( finder ).to eq( [ @a_sc_wosf_a ] )
+      it 'on created_by' do
+        @list_params.search_data = {
+          'created_by' => @cb1
+        }
 
-        finder = RSpecModelFinderSubclassWithoutSearchOrFilterBTest.list( @list_params )
-        expect( finder ).to eq( [ @a_sc_wosf_b ] )
+        finder = RSpecModelFinderWithoutSearchOrFilterTest.list( @list_params )
+        expect( finder ).to eq( [ @b_wosf, @a_wosf ] )
       end
     end
-  end
 
-  # ==========================================================================
+    # ========================================================================
 
-  context 'filter' do
-    it 'filters without chain' do
-      @list_params.filter_data = {
-        'field_two' => 'two a'
-      }
+    context 'as a Hoodoo::ActiveRecord::Base subclass and sub-subclass' do # (instead of explicitly including the Finder module)
+      context 'custom search' do
+        it 'on mapped_code' do
+          @list_params.search_data = {
+            'mapped_code' => @code
+          }
 
-      finder = RSpecModelFinderTest.list( @list_params )
-      expect( finder ).to eq([@c, @b])
+          finder = RSpecModelFinderSubclassTest.list( @list_params )
+          expect( finder ).to eq( [ @c_sc ] )
 
-      @list_params.filter_data = {
-        'field_three' => 'three c'
-      }
+          finder = RSpecModelFinderSubclassATest.list( @list_params )
+          expect( finder ).to eq( [ @c_sc_a ] )
 
-      finder = RSpecModelFinderTest.list( @list_params )
-      expect( finder ).to eq([@b, @a])
+          finder = RSpecModelFinderSubclassBTest.list( @list_params )
+          expect( finder ).to eq( [ @c_sc_b ] )
+        end
+      end
 
-      @list_params.filter_data = {
-        'field_one' => [ 'group 1', 'group 2' ]
-      }
+      context 'pure framework search' do
+        it 'on created_after' do
+          @list_params.search_data = {
+            'created_after' => @tn - 1.month
+          }
 
-      finder = RSpecModelFinderTest.list( @list_params )
-      expect( finder ).to eq([])
+          finder = RSpecModelFinderSubclassWithoutSearchOrFilterTest.list( @list_params )
+          expect( finder ).to eq( [ @c_sc_wosf ] )
 
-      @list_params.filter_data = {
-        'field_one' => [ 'group 2' ]
-      }
+          finder = RSpecModelFinderSubclassWithoutSearchOrFilterATest.list( @list_params )
+          expect( finder ).to eq( [ @c_sc_wosf_a ] )
 
-      finder = RSpecModelFinderTest.list( @list_params )
-      expect( finder ).to eq([@b, @a])
+          finder = RSpecModelFinderSubclassWithoutSearchOrFilterBTest.list( @list_params )
+          expect( finder ).to eq( [ @c_sc_wosf_b ] )
+        end
 
-      @list_params.filter_data = {
-        'field_one' => [ 'group 2' ],
-        'field_three' => 'three a'
-      }
+        it 'on created_before' do
+          @list_params.search_data = {
+            'created_before' => @tn - 1.month
+          }
 
-      finder = RSpecModelFinderTest.list( @list_params )
-      expect( finder ).to eq([@b])
+          finder = RSpecModelFinderSubclassWithoutSearchOrFilterTest.list( @list_params )
+          expect( finder ).to eq( [ @a_sc_wosf ] )
 
-      @list_params.filter_data = {
-        'created_after' => @tn - 1.month
-      }
+          finder = RSpecModelFinderSubclassWithoutSearchOrFilterATest.list( @list_params )
+          expect( finder ).to eq( [ @a_sc_wosf_a ] )
 
-      finder = RSpecModelFinderTest.list( @list_params )
-      expect( finder ).to eq([@b, @a])
+          finder = RSpecModelFinderSubclassWithoutSearchOrFilterBTest.list( @list_params )
+          expect( finder ).to eq( [ @a_sc_wosf_b ] )
+        end
+      end
+    end
 
-      @list_params.filter_data = {
-        'created_before' => @tn - 1.month
-      }
+    # ========================================================================
 
-      finder = RSpecModelFinderTest.list( @list_params )
-      expect( finder ).to eq([@c, @b])
+    context 'filter' do
+      it 'filters without chain' do
+        @list_params.filter_data = {
+          'field_two' => 'two a'
+        }
 
-      @list_params.filter_data = {
-        'created_before' => @tn - 1.month + 1.day
-      }
+        finder = RSpecModelFinderTest.list( @list_params )
+        expect( finder ).to eq([@c, @b])
 
-      finder = RSpecModelFinderTest.list( @list_params )
-      expect( finder ).to eq([@c])
-    end
+        @list_params.filter_data = {
+          'field_three' => 'three c'
+        }
 
-    it 'filters with chain' do
+        finder = RSpecModelFinderTest.list( @list_params )
+        expect( finder ).to eq([@b, @a])
 
-      # Remember, the constraint is *inclusive* unlike all the
-      # subsequent filters which *exclude*.
+        @list_params.filter_data = {
+          'field_one' => [ 'group 1', 'group 2' ]
+        }
 
-      constraint = RSpecModelFinderTest.where( :field_one => 'group 2' )
+        finder = RSpecModelFinderTest.list( @list_params )
+        expect( finder ).to eq([])
 
-      @list_params.filter_data = {
-        'field_two' => 'two a'
-      }
+        @list_params.filter_data = {
+          'field_one' => [ 'group 2' ]
+        }
 
-      finder = constraint.list( @list_params )
-      expect( finder ).to eq([@c])
+        finder = RSpecModelFinderTest.list( @list_params )
+        expect( finder ).to eq([@b, @a])
 
-      @list_params.filter_data = {
-        'field_three' => 'three c'
-      }
+        @list_params.filter_data = {
+          'field_one' => [ 'group 2' ],
+          'field_three' => 'three a'
+        }
 
-      finder = constraint.list( @list_params )
-      expect( finder ).to eq([])
+        finder = RSpecModelFinderTest.list( @list_params )
+        expect( finder ).to eq([@b])
 
-      @list_params.filter_data = {
-        'field_one' => [ 'group 1', 'group 2' ]
-      }
+        @list_params.filter_data = {
+          'created_after' => @tn - 1.month
+        }
 
-      finder = constraint.list( @list_params )
-      expect( finder ).to eq([])
+        finder = RSpecModelFinderTest.list( @list_params )
+        expect( finder ).to eq([@b, @a])
 
-      @list_params.filter_data = {
-        'field_one' => [ 'group 2' ]
-      }
+        @list_params.filter_data = {
+          'created_before' => @tn - 1.month
+        }
 
-      finder = constraint.list( @list_params )
-      expect( finder ).to eq([])
+        finder = RSpecModelFinderTest.list( @list_params )
+        expect( finder ).to eq([@c, @b])
 
-      @list_params.filter_data = {
-        'field_one' => [ 'group 2' ],
-        'field_three' => 'three a'
-      }
+        @list_params.filter_data = {
+          'created_before' => @tn - 1.month + 1.day
+        }
 
-      finder = constraint.list( @list_params )
-      expect( finder ).to eq([])
+        finder = RSpecModelFinderTest.list( @list_params )
+        expect( finder ).to eq([@c])
 
-      @list_params.filter_data = {
-        'created_after' => @tn - 1.month
-      }
+        @list_params.filter_data = {
+          'created_by' => @cb1
+        }
 
-      finder = constraint.list( @list_params )
-      expect( finder ).to eq([])
+        finder = RSpecModelFinderTest.list( @list_params )
+        expect( finder ).to eq([@c])
 
-      @list_params.filter_data = {
-        'created_before' => @tn - 1.month
-      }
+        @list_params.filter_data = {
+          'created_by' => @cb2
+        }
 
-      finder = constraint.list( @list_params )
-      expect( finder ).to eq([@c])
+        finder = RSpecModelFinderTest.list( @list_params )
+        expect( finder ).to eq([@b, @a])
+      end
 
-      @list_params.filter_data = {
-        'created_before' => @tn - 1.month + 1.day
-      }
+      it 'filters with chain' do
 
-      finder = constraint.list( @list_params )
-      expect( finder ).to eq([@c])
-    end
-  end
+        # Remember, the constraint is *inclusive* unlike all the
+        # subsequent filters which *exclude*.
 
-  # ==========================================================================
+        constraint = RSpecModelFinderTest.where( :field_one => 'group 2' )
 
-  # This set of copy-and-modify tests based on the helper-based search tests
-  # earlier seems somewhat redundant, but should anyone accidentally decouple
-  # the search/filter back-end processing and introduce some sort of error at
-  # a finder-level, the tests here have a chance of catching that.
+        @list_params.filter_data = {
+          'field_two' => 'two a'
+        }
 
-  context 'helper-based filtering' do
-    it 'filters by mapped code' do
-      @list_params.filter_data = {
-        'mapped_code' => @code
-      }
+        finder = constraint.list( @list_params )
+        expect( finder ).to eq([@c])
 
-      finder = RSpecModelFinderTestWithHelpers.list( @list_params )
-      expect( finder ).to eq( [ @b_wh, @a_wh ] )
-    end
+        @list_params.filter_data = {
+          'field_three' => 'three c'
+        }
 
-    it 'filters by mapped field-one' do
-      @list_params.filter_data = {
-        'mapped_field_one' => :'grOUp 1'
-      }
+        finder = constraint.list( @list_params )
+        expect( finder ).to eq([])
 
-      finder = RSpecModelFinderTestWithHelpers.list( @list_params )
-      expect( finder ).to eq( [ @c_wh ] )
-    end
+        @list_params.filter_data = {
+          'field_one' => [ 'group 1', 'group 2' ]
+        }
 
-    it 'filters by mapped, wildcard field-one' do
-      @list_params.filter_data = {
-        'wild_field_one' => :'oUP '
-      }
+        finder = constraint.list( @list_params )
+        expect( finder ).to eq([])
 
-      finder = RSpecModelFinderTestWithHelpers.list( @list_params )
-      expect( finder ).to eq( [] )
+        @list_params.filter_data = {
+          'field_one' => [ 'group 2' ]
+        }
 
-      @list_params.filter_data = {
-        'wild_field_one' => :'o!p '
-      }
+        finder = constraint.list( @list_params )
+        expect( finder ).to eq([])
 
-      finder = RSpecModelFinderTestWithHelpers.list( @list_params )
-      expect( finder ).to eq( [ @c_wh, @b_wh, @a_wh ] )
-    end
+        @list_params.filter_data = {
+          'field_one' => [ 'group 2' ],
+          'field_three' => 'three a'
+        }
 
-    it 'filters by comma-separated list' do
-      @list_params.filter_data = {
-        'field_two' => 'two a,something else,two c,more'
-      }
+        finder = constraint.list( @list_params )
+        expect( finder ).to eq([])
 
-      finder = RSpecModelFinderTestWithHelpers.list( @list_params )
-      expect( finder ).to eq( [ @b_wh ] )
-    end
+        @list_params.filter_data = {
+          'created_after' => @tn - 1.month
+        }
 
-    it 'filters by Array' do
-      @list_params.filter_data = {
-        'field_three' => [ 'hello', :'three b', 'three c', :there ]
-      }
+        finder = constraint.list( @list_params )
+        expect( finder ).to eq([])
 
-      finder = RSpecModelFinderTestWithHelpers.list( @list_params )
-      expect( finder ).to eq( [ @a_wh ] )
-    end
+        @list_params.filter_data = {
+          'created_before' => @tn - 1.month
+        }
 
-    it 'filters with framework override' do
-      @list_params.filter_data = {
-        'created_after' => @tn - 1.week
-      }
+        finder = constraint.list( @list_params )
+        expect( finder ).to eq([@c])
 
-      finder = RSpecModelFinderTestWithHelpers.list( @list_params )
-      expect( finder ).to eq( [ @a_wh ] )
+        @list_params.filter_data = {
+          'created_before' => @tn - 1.month + 1.day
+        }
 
-      @list_params.filter_data = {
-        'created_after' => @tn + 1.day
-      }
+        finder = constraint.list( @list_params )
+        expect( finder ).to eq([@c])
 
-      finder = RSpecModelFinderTestWithHelpers.list( @list_params )
-      expect( finder ).to eq( [ @b_wh, @a_wh ] )
-    end
-  end
+        @list_params.filter_data = {
+          'created_by' => @cb1
+        }
 
-  # ==========================================================================
+        finder = constraint.list( @list_params )
+        expect( finder ).to eq([@c])
 
-  context 'pure framework filter' do
-    it 'on created_after' do
-      @list_params.filter_data = {
-        'created_after' => @tn - 1.month
-      }
+        @list_params.filter_data = {
+          'created_by' => @cb2
+        }
 
-      finder = RSpecModelFinderWithoutSearchOrFilterTest.list( @list_params )
-      expect( finder ).to eq( [ @b_wosf, @a_wosf ] )
+        finder = constraint.list( @list_params )
+        expect( finder ).to eq([])
+      end
     end
 
-    it 'on created_before' do
-      @list_params.filter_data = {
-        'created_before' => @tn - 1.month
-      }
+    # ========================================================================
 
-      finder = RSpecModelFinderWithoutSearchOrFilterTest.list( @list_params )
-      expect( finder ).to eq( [ @c_wosf, @b_wosf ] )
-    end
-  end
+    # This set of copy-and-modify tests based on the helper-based search tests
+    # earlier seems somewhat redundant but should anyone accidentally decouple
+    # the search/filter back-end processing and introduce some sort of error
+    # at a finder-level, the tests here have a chance of catching that.
+    #
+    context 'helper-based filtering' do
+      it 'filters by mapped code' do
+        @list_params.filter_data = {
+          'mapped_code' => @code
+        }
 
-  # ==========================================================================
+        finder = RSpecModelFinderTestWithHelpers.list( @list_params )
+        expect( finder ).to eq( [ @b_wh, @a_wh ] )
+      end
 
-  context 'as a Hoodoo::ActiveRecord::Base subclass and sub-subclass' do # (instead of explicitly including the Finder module)
-    context 'custom filter' do
-      it 'on mapped_code' do
+      it 'filters by mapped field-one' do
         @list_params.filter_data = {
-          'mapped_code' => @code
+          'mapped_field_one' => :'grOUp 1'
+        }
+
+        finder = RSpecModelFinderTestWithHelpers.list( @list_params )
+        expect( finder ).to eq( [ @c_wh ] )
+      end
+
+      it 'filters by mapped, wildcard field-one' do
+        @list_params.filter_data = {
+          'wild_field_one' => :'oUP '
+        }
+
+        finder = RSpecModelFinderTestWithHelpers.list( @list_params )
+        expect( finder ).to eq( [] )
+
+        @list_params.filter_data = {
+          'wild_field_one' => :'o!p '
+        }
+
+        finder = RSpecModelFinderTestWithHelpers.list( @list_params )
+        expect( finder ).to eq( [ @c_wh, @b_wh, @a_wh ] )
+      end
+
+      it 'filters by comma-separated list' do
+        @list_params.filter_data = {
+          'field_two' => 'two a,something else,two c,more'
+        }
+
+        finder = RSpecModelFinderTestWithHelpers.list( @list_params )
+        expect( finder ).to eq( [ @b_wh ] )
+      end
+
+      it 'filters by Array' do
+        @list_params.filter_data = {
+          'field_three' => [ 'hello', :'three b', 'three c', :there ]
+        }
+
+        finder = RSpecModelFinderTestWithHelpers.list( @list_params )
+        expect( finder ).to eq( [ @a_wh ] )
+      end
+
+      it 'filters with framework override' do
+        @list_params.filter_data = {
+          'created_after' => @tn - 1.week
         }
 
-        finder = RSpecModelFinderSubclassTest.list( @list_params )
-        expect( finder ).to eq( [ @b_sc, @a_sc ] )
+        finder = RSpecModelFinderTestWithHelpers.list( @list_params )
+        expect( finder ).to eq( [ @a_wh ] )
 
-        finder = RSpecModelFinderSubclassATest.list( @list_params )
-        expect( finder ).to eq( [ @b_sc_a, @a_sc_a ] )
+        @list_params.filter_data = {
+          'created_after' => @tn + 1.day
+        }
 
-        finder = RSpecModelFinderSubclassBTest.list( @list_params )
-        expect( finder ).to eq( [ @b_sc_b, @a_sc_b ] )
+        finder = RSpecModelFinderTestWithHelpers.list( @list_params )
+        expect( finder ).to eq( [ @b_wh, @a_wh ] )
       end
     end
 
+    # ========================================================================
+
     context 'pure framework filter' do
       it 'on created_after' do
         @list_params.filter_data = {
           'created_after' => @tn - 1.month
         }
 
-        finder = RSpecModelFinderSubclassWithoutSearchOrFilterTest.list( @list_params )
-        expect( finder ).to eq( [ @b_sc_wosf, @a_sc_wosf ] )
-
-        finder = RSpecModelFinderSubclassWithoutSearchOrFilterATest.list( @list_params )
-        expect( finder ).to eq( [ @b_sc_wosf_a, @a_sc_wosf_a ] )
-
-        finder = RSpecModelFinderSubclassWithoutSearchOrFilterBTest.list( @list_params )
-        expect( finder ).to eq( [ @b_sc_wosf_b, @a_sc_wosf_b ] )
+        finder = RSpecModelFinderWithoutSearchOrFilterTest.list( @list_params )
+        expect( finder ).to eq( [ @b_wosf, @a_wosf ] )
       end
 
       it 'on created_before' do
@@ -1172,159 +1215,230 @@ describe Hoodoo::ActiveRecord::Finder do
           'created_before' => @tn - 1.month
         }
 
-        finder = RSpecModelFinderSubclassWithoutSearchOrFilterTest.list( @list_params )
-        expect( finder ).to eq( [ @c_sc_wosf, @b_sc_wosf ] )
+        finder = RSpecModelFinderWithoutSearchOrFilterTest.list( @list_params )
+        expect( finder ).to eq( [ @c_wosf, @b_wosf ] )
+      end
 
-        finder = RSpecModelFinderSubclassWithoutSearchOrFilterATest.list( @list_params )
-        expect( finder ).to eq( [ @c_sc_wosf_a, @b_sc_wosf_a ] )
+      it 'on created_by' do
+        @list_params.filter_data = {
+          'created_by' => @cb1
+        }
 
-        finder = RSpecModelFinderSubclassWithoutSearchOrFilterBTest.list( @list_params )
-        expect( finder ).to eq( [ @c_sc_wosf_b, @b_sc_wosf_b ] )
+        finder = RSpecModelFinderWithoutSearchOrFilterTest.list( @list_params )
+        expect( finder ).to eq( [ @c_wosf ] )
       end
     end
-  end
 
-  # ==========================================================================
+    # ========================================================================
 
-  context '#list_in' do
-    before :each do
-      @scoped_1 = RSpecModelFinderTest.new
-      @scoped_1.id   = 'id 1'
-      @scoped_1.uuid = 'uuid 1'
-      @scoped_1.code = 'code 1'
-      @scoped_1.field_one = 'scoped 1'
-      @scoped_1.created_at = @tn - 1.year
-      @scoped_1.save!
-
-      @scoped_2 = RSpecModelFinderTest.new
-      @scoped_2.id   = 'id 2'
-      @scoped_2.uuid = 'uuid 1'
-      @scoped_2.code = 'code 2'
-      @scoped_2.field_one = 'scoped 2'
-      @scoped_2.save!
-
-      @scoped_3 = RSpecModelFinderTest.new
-      @scoped_3.id   = 'id 3'
-      @scoped_3.uuid = 'uuid 2'
-      @scoped_3.code = 'code 2'
-      @scoped_3.field_one = 'scoped 3'
-      @scoped_3.save!
-
-      # Get a good-enough-for-test interaction which has a context
-      # that contains a Session we can modify.
-
-      @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 'as a Hoodoo::ActiveRecord::Base subclass and sub-subclass' do # (instead of explicitly including the Finder module)
+      context 'custom filter' do
+        it 'on mapped_code' do
+          @list_params.filter_data = {
+            'mapped_code' => @code
+          }
 
-      @context = @interaction.context
-      @session = @interaction.context.session
-    end
+          finder = RSpecModelFinderSubclassTest.list( @list_params )
+          expect( finder ).to eq( [ @b_sc, @a_sc ] )
 
-    it 'lists with secure scopes from the class' do
-      @session.scoping = { :authorised_uuids => [ 'uuid 1' ], :authorised_code => 'code 1' }
+          finder = RSpecModelFinderSubclassATest.list( @list_params )
+          expect( finder ).to eq( [ @b_sc_a, @a_sc_a ] )
 
-      list = RSpecModelFinderTest.list_in( @context )
-      expect( list ).to eq( [ @scoped_1 ] )
+          finder = RSpecModelFinderSubclassBTest.list( @list_params )
+          expect( finder ).to eq( [ @b_sc_b, @a_sc_b ] )
+        end
+      end
+
+      context 'pure framework filter' do
+        it 'on created_after' do
+          @list_params.filter_data = {
+            'created_after' => @tn - 1.month
+          }
+
+          finder = RSpecModelFinderSubclassWithoutSearchOrFilterTest.list( @list_params )
+          expect( finder ).to eq( [ @b_sc_wosf, @a_sc_wosf ] )
 
-      @session.scoping.authorised_code = 'code 2'
+          finder = RSpecModelFinderSubclassWithoutSearchOrFilterATest.list( @list_params )
+          expect( finder ).to eq( [ @b_sc_wosf_a, @a_sc_wosf_a ] )
 
-      list = RSpecModelFinderTest.list_in( @context )
-      expect( list ).to eq( [ @scoped_2 ] )
+          finder = RSpecModelFinderSubclassWithoutSearchOrFilterBTest.list( @list_params )
+          expect( finder ).to eq( [ @b_sc_wosf_b, @a_sc_wosf_b ] )
+        end
 
-      @session.scoping.authorised_uuids = [ 'uuid 2' ]
+        it 'on created_before' do
+          @list_params.filter_data = {
+            'created_before' => @tn - 1.month
+          }
 
-      list = RSpecModelFinderTest.list_in( @context )
-      expect( list ).to eq( [ @scoped_3 ] )
+          finder = RSpecModelFinderSubclassWithoutSearchOrFilterTest.list( @list_params )
+          expect( finder ).to eq( [ @c_sc_wosf, @b_sc_wosf ] )
 
-      @session.scoping.authorised_uuids = [ 'uuid 1', 'uuid 2' ]
+          finder = RSpecModelFinderSubclassWithoutSearchOrFilterATest.list( @list_params )
+          expect( finder ).to eq( [ @c_sc_wosf_a, @b_sc_wosf_a ] )
 
-      # OK, so these test 'with a chain' too... It's just convenient to (re-)cover
-      # that aspect here.
+          finder = RSpecModelFinderSubclassWithoutSearchOrFilterBTest.list( @list_params )
+          expect( finder ).to eq( [ @c_sc_wosf_b, @b_sc_wosf_b ] )
+        end
 
-      list = RSpecModelFinderTest.list_in( @context ).reorder( 'field_one' => 'asc' )
-      expect( list ).to eq( [ @scoped_2, @scoped_3 ] )
+        it 'on created_by' do
+          @list_params.filter_data = {
+            'created_by' => @cb2
+          }
 
-      list = RSpecModelFinderTest.list_in( @context ).reorder( 'field_one' => 'desc' )
-      expect( list ).to eq( [ @scoped_3, @scoped_2 ] )
+          finder = RSpecModelFinderSubclassWithoutSearchOrFilterTest.list( @list_params )
+          expect( finder ).to eq( [ @b_sc_wosf, @a_sc_wosf ] )
 
-      list = RSpecModelFinderTest.reorder( 'field_one' => 'asc' ).list_in( @context )
-      expect( list ).to eq( [ @scoped_2, @scoped_3 ] )
+          finder = RSpecModelFinderSubclassWithoutSearchOrFilterATest.list( @list_params )
+          expect( finder ).to eq( [ @b_sc_wosf_a, @a_sc_wosf_a ] )
 
-      list = RSpecModelFinderTest.reorder( 'field_one' => 'desc' ).list_in( @context )
-      expect( list ).to eq( [ @scoped_3, @scoped_2 ] )
+          finder = RSpecModelFinderSubclassWithoutSearchOrFilterBTest.list( @list_params )
+          expect( finder ).to eq( [ @b_sc_wosf_b, @a_sc_wosf_b ] )
+        end
+      end
     end
 
-    it 'finds with secure scopes with a chain' do
-      @session.scoping = { :authorised_uuids => [ 'uuid 1' ], :authorised_code => 'code 1' }
+    # ========================================================================
 
-      list = RSpecModelFinderTest.where( :field_one => @scoped_1.field_one ).list_in( @context )
-      expect( list ).to eq( [ @scoped_1 ] )
+    context '#list_in' do
+      before :each do
+        @scoped_1 = RSpecModelFinderTest.new
+        @scoped_1.id   = 'id 1'
+        @scoped_1.uuid = 'uuid 1'
+        @scoped_1.code = 'code 1'
+        @scoped_1.field_one = 'scoped 1'
+        @scoped_1.created_at = @tn - 1.year
+        @scoped_1.save!
+
+        @scoped_2 = RSpecModelFinderTest.new
+        @scoped_2.id   = 'id 2'
+        @scoped_2.uuid = 'uuid 1'
+        @scoped_2.code = 'code 2'
+        @scoped_2.field_one = 'scoped 2'
+        @scoped_2.save!
+
+        @scoped_3 = RSpecModelFinderTest.new
+        @scoped_3.id   = 'id 3'
+        @scoped_3.uuid = 'uuid 2'
+        @scoped_3.code = 'code 2'
+        @scoped_3.field_one = 'scoped 3'
+        @scoped_3.save!
+
+        # Get a good-enough-for-test interaction which has a context
+        # that contains a Session we can modify.
+
+        @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
+        @session = @interaction.context.session
+      end
 
-      list = RSpecModelFinderTest.where( :field_one => @scoped_1.field_one + '!' ).list_in( @context )
-      expect( list ).to eq( [] )
+      it 'lists with secure scopes from the class' do
+        @session.scoping = { :authorised_uuids => [ 'uuid 1' ], :authorised_code => 'code 1' }
 
-      list = RSpecModelFinderTest.list_in( @context ).where( :field_one => @scoped_1.field_one )
-      expect( list ).to eq( [ @scoped_1 ] )
+        list = RSpecModelFinderTest.list_in( @context )
+        expect( list ).to eq( [ @scoped_1 ] )
 
-      list = RSpecModelFinderTest.list_in( @context ).where( :field_one => @scoped_1.field_one + '!' )
-      expect( list ).to eq( [] )
+        @session.scoping.authorised_code = 'code 2'
 
-      @session.scoping.authorised_uuids = [ 'uuid 1', 'uuid 2' ]
-      @session.scoping.authorised_code  = 'code 2'
+        list = RSpecModelFinderTest.list_in( @context )
+        expect( list ).to eq( [ @scoped_2 ] )
 
-      list = RSpecModelFinderTest.where( :field_one => [ @scoped_1.field_one, @scoped_2.field_one ] ).list_in( @context )
-      expect( list ).to eq( [ @scoped_2 ] )
+        @session.scoping.authorised_uuids = [ 'uuid 2' ]
 
-      list = RSpecModelFinderTest.list_in( @context ).where( :field_one => [ @scoped_1.field_one, @scoped_2.field_one ] )
-      expect( list ).to eq( [ @scoped_2 ] )
+        list = RSpecModelFinderTest.list_in( @context )
+        expect( list ).to eq( [ @scoped_3 ] )
 
-      list = RSpecModelFinderTest.where( :field_one => [ @scoped_2.field_one, @scoped_3.field_one ] ).list_in( @context ).reorder( 'field_one' => 'asc' )
-      expect( list ).to eq( [ @scoped_2, @scoped_3 ] )
+        @session.scoping.authorised_uuids = [ 'uuid 1', 'uuid 2' ]
 
-      list = RSpecModelFinderTest.list_in( @context ).reorder( 'field_one' => 'asc' ).where( :field_one => [ @scoped_2.field_one, @scoped_3.field_one ] )
-      expect( list ).to eq( [ @scoped_2, @scoped_3 ] )
-    end
-  end
+        # OK, so these test 'with a chain' too... It's just convenient to (re-)cover
+        # that aspect here.
 
-  # ==========================================================================
+        list = RSpecModelFinderTest.list_in( @context ).reorder( 'field_one' => 'asc' )
+        expect( list ).to eq( [ @scoped_2, @scoped_3 ] )
 
-  context 'deprecated' do
-    it '#polymorphic_find calls #acquire' do
-      expect( $stderr ).to receive( :puts ).once
-      expect( RSpecModelFinderTest ).to receive( :acquire ).once.with( 21 )
-      RSpecModelFinderTest.polymorphic_find( RSpecModelFinderTest, 21 )
-    end
+        list = RSpecModelFinderTest.list_in( @context ).reorder( 'field_one' => 'desc' )
+        expect( list ).to eq( [ @scoped_3, @scoped_2 ] )
 
-    it '#polymorphic_id_fields calls #acquire_with' do
-      expect( $stderr ).to receive( :puts ).once
-      expect( RSpecModelFinderTest ).to receive( :acquire_with ).once.with( :uuid, :code )
-      RSpecModelFinderTest.polymorphic_id_fields( :uuid, :code )
-    end
+        list = RSpecModelFinderTest.reorder( 'field_one' => 'asc' ).list_in( @context )
+        expect( list ).to eq( [ @scoped_2, @scoped_3 ] )
 
-    it '#list_finder calls #list' do
-      params = { :search => { :field_one => 'one' } }
-      expect( $stderr ).to receive( :puts ).once
-      expect( RSpecModelFinderTest ).to receive( :list ).once.with( params )
-      RSpecModelFinderTest.list_finder( params )
-    end
+        list = RSpecModelFinderTest.reorder( 'field_one' => 'desc' ).list_in( @context )
+        expect( list ).to eq( [ @scoped_3, @scoped_2 ] )
+      end
+
+      it 'finds with secure scopes with a chain' do
+        @session.scoping = { :authorised_uuids => [ 'uuid 1' ], :authorised_code => 'code 1' }
+
+        list = RSpecModelFinderTest.where( :field_one => @scoped_1.field_one ).list_in( @context )
+        expect( list ).to eq( [ @scoped_1 ] )
+
+        list = RSpecModelFinderTest.where( :field_one => @scoped_1.field_one + '!' ).list_in( @context )
+        expect( list ).to eq( [] )
+
+        list = RSpecModelFinderTest.list_in( @context ).where( :field_one => @scoped_1.field_one )
+        expect( list ).to eq( [ @scoped_1 ] )
+
+        list = RSpecModelFinderTest.list_in( @context ).where( :field_one => @scoped_1.field_one + '!' )
+        expect( list ).to eq( [] )
+
+        @session.scoping.authorised_uuids = [ 'uuid 1', 'uuid 2' ]
+        @session.scoping.authorised_code  = 'code 2'
+
+        list = RSpecModelFinderTest.where( :field_one => [ @scoped_1.field_one, @scoped_2.field_one ] ).list_in( @context )
+        expect( list ).to eq( [ @scoped_2 ] )
+
+        list = RSpecModelFinderTest.list_in( @context ).where( :field_one => [ @scoped_1.field_one, @scoped_2.field_one ] )
+        expect( list ).to eq( [ @scoped_2 ] )
 
-    it '#list_search_map calls #search_with' do
-      params = { :foo => nil, :bar => nil }
-      expect( $stderr ).to receive( :puts ).once
-      expect( RSpecModelFinderTest ).to receive( :search_with ).once.with( params )
-      RSpecModelFinderTest.list_search_map( params )
+        list = RSpecModelFinderTest.where( :field_one => [ @scoped_2.field_one, @scoped_3.field_one ] ).list_in( @context ).reorder( 'field_one' => 'asc' )
+        expect( list ).to eq( [ @scoped_2, @scoped_3 ] )
+
+        list = RSpecModelFinderTest.list_in( @context ).reorder( 'field_one' => 'asc' ).where( :field_one => [ @scoped_2.field_one, @scoped_3.field_one ] )
+        expect( list ).to eq( [ @scoped_2, @scoped_3 ] )
+      end
     end
 
-    it '#list_filter_map calls #filter_with' do
-      params = { :foo => nil, :bar => nil }
-      expect( $stderr ).to receive( :puts ).once
-      expect( RSpecModelFinderTest ).to receive( :filter_with ).once.with( params )
-      RSpecModelFinderTest.list_filter_map( params )
+    # ========================================================================
+
+    context 'deprecated' do
+      it '#polymorphic_find calls #acquire' do
+        expect( $stderr ).to receive( :puts ).once
+        expect( RSpecModelFinderTest ).to receive( :acquire ).once.with( 21 )
+        RSpecModelFinderTest.polymorphic_find( RSpecModelFinderTest, 21 )
+      end
+
+      it '#polymorphic_id_fields calls #acquire_with' do
+        expect( $stderr ).to receive( :puts ).once
+        expect( RSpecModelFinderTest ).to receive( :acquire_with ).once.with( :uuid, :code )
+        RSpecModelFinderTest.polymorphic_id_fields( :uuid, :code )
+      end
+
+      it '#list_finder calls #list' do
+        params = { :search => { :field_one => 'one' } }
+        expect( $stderr ).to receive( :puts ).once
+        expect( RSpecModelFinderTest ).to receive( :list ).once.with( params )
+        RSpecModelFinderTest.list_finder( params )
+      end
+
+      it '#list_search_map calls #search_with' do
+        params = { :foo => nil, :bar => nil }
+        expect( $stderr ).to receive( :puts ).once
+        expect( RSpecModelFinderTest ).to receive( :search_with ).once.with( params )
+        RSpecModelFinderTest.list_search_map( params )
+      end
+
+      it '#list_filter_map calls #filter_with' do
+        params = { :foo => nil, :bar => nil }
+        expect( $stderr ).to receive( :puts ).once
+        expect( RSpecModelFinderTest ).to receive( :filter_with ).once.with( params )
+        RSpecModelFinderTest.list_filter_map( params )
+      end
     end
   end
 end