feat(Job): Add support for before and after lifecycle methods

A `before` and/or an `after` method can be defined on the Job instance.
This will be called as a lifecycle method either `before` or `after`
the job is ran.

models/Providers/AbstractQueueProvider.cfc

@@ -109,6 +109,9 @@ component accessors="true" {
 				}
 
 				beforeJobRun( job );
+				if ( structKeyExists( job, "before" ) ) {
+					job.before();
+				}
 
 				variables.interceptorService.announce( "onCBQJobMarshalled", { "job" : job } );
 
@@ -153,6 +156,9 @@ component accessors="true" {
 					}
 				);
 
+				if ( structKeyExists( job, "after" ) ) {
+					job.after();
+				}
 				afterJobRun( job );
 
 				ensureSuccessfulBatchJobIsRecorded( job );

models/Providers/SyncProvider.cfc

@@ -41,6 +41,9 @@ component accessors="true" extends="AbstractQueueProvider" {
 			}
 
 			beforeJobRun( arguments.job );
+			if ( structKeyExists( job, "before" ) ) {
+				job.before();
+			}
 
 			variables.interceptorService.announce( "onCBQJobMarshalled", { "job" : arguments.job } );
 
@@ -83,6 +86,9 @@ component accessors="true" extends="AbstractQueueProvider" {
 				}
 			);
 
+			if ( structKeyExists( job, "after" ) ) {
+				job.after();
+			}
 			afterJobRun( job );
 
 			ensureSuccessfulBatchJobIsRecorded( job );

tests/resources/AbstractQueueProviderSpec.cfc

@@ -2,6 +2,11 @@ component extends="tests.resources.ModuleIntegrationSpec" appMapping="/app" {
 
     function run() {
         describe( "queue provider - #getProviderMapping()#", function() {
+            beforeEach( function() {
+                structDelete( application, "jobBeforeCalled" );
+                structDelete( application, "jobAfterCalled" );
+            } );
+
             it( "can manually release a job back on to a queue with a given delay", function() {
                 var provider = getProvider();
                 $spy( provider, "releaseJob" );
@@ -78,6 +83,29 @@ component extends="tests.resources.ModuleIntegrationSpec" appMapping="/app" {
                 var callLog = provider.$callLog()[ "releaseJob" ][ 1 ];
                 expect( provider.getBackoffForJob( callLog[ 1 ], callLog[ 2 ] ) ).toBe( 2, "The delay [2] should have been passed to the provider" );
             } );
+
+            it( "calls a before and after method if present as lifecycle methods", () => {
+                var provider = getProvider();
+                var workerPool = makeWorkerPool( provider );
+                var job = getInstance( "BeforeAndAfterJob" )
+                    .setId( randRange( 1, 1000 ) );
+
+                param application.jobBeforeCalled = false;
+                param application.jobAfterCalled = false;
+
+                expect( application.jobBeforeCalled ).toBeFalse();
+                expect( application.jobAfterCalled ).toBeFalse();
+
+                // work the job
+                var jobFuture = provider.marshalJob( job, workerPool );
+                // if it is an async operation, wait for it to finish
+                if ( !isNull( jobFuture ) ) {
+                    jobFuture.get();
+                }
+
+                expect( application.jobBeforeCalled ).toBeTrue( "The before method should have been called" );
+                expect( application.jobAfterCalled ).toBeTrue( "The after method should have been called" );
+            } );
         } );
     }
 

tests/resources/app/models/Jobs/BeforeAndAfterJob.cfc

@@ -0,0 +1,15 @@
+component extends="cbq.models.Jobs.AbstractJob" {
+
+    function handle() {
+        // do nothing
+    }
+
+    function before() {
+        application.jobBeforeCalled = true;
+    }
+
+    function after() {
+        application.jobAfterCalled = true;
+    }
+
+}