ti2 1.0.95 → 1.0.96

package/controllers/bookings.js

@@ -2,6 +2,7 @@ const assert = require('assert');
 const hash = require('object-hash');
 const R = require('ramda');
 const { UserAppKey } = require('../models/index');
+const { addJob } = require('../worker/queue');
 const { typeDefs: productTypeDefs, query: productQuery } = require('./graphql-schemas/product');
 const { typeDefs: availTypeDefs, query: availQuery } = require('./graphql-schemas/availability');
 const { typeDefs: bookingTypeDefs, query: bookingQuery } = require('./graphql-schemas/booking');
@@ -126,113 +127,140 @@ const $bookingsProductSearch = plugins => async ({
   appKey,
   userId,
   hint,
-  payload: {
-    searchInput,
-    optionId,
-    forceRefresh,
-    ...restPayload
-  },
+  payload: originalRequestBody, // Renamed for clarity, this is req.body
   requestId,
+  headers, // To pass original request headers for background job
 }) => {
+  // Extract controller-specific flags from originalRequestBody
+  const {
+    searchInput = '', // Provide defaults
+    optionId = '',
+    forceRefresh = false,
+  } = originalRequestBody;
+
+  // Payload for the plugin function (func) - omit controller-specific flags
+  const payloadForPlugin = R.omit(['forceRefresh'], originalRequestBody);
+
   const app = plugins.find(({ name }) => name === appKey);
   assert(userId, 'userId is required');
   assert(appKey, 'appKey is required');
   assert(app.searchProducts || app.searchProductsForItinerary, `searchProducts or searchProductsForItinerary is not available for ${appKey}`);
   const userAppKeys = (await UserAppKey.findOne({
-    where: {
-      userId,
-      integrationId: appKey,
-      ...(hint ? { hint } : {}),
-    },
+    where: { userId, integrationId: appKey, ...(hint ? { hint } : {}) },
   }));
   assert(userAppKeys, 'could not find the app key');
   const token = await userAppKeys.token;
   const func = (app.searchProducts || app.searchProductsForItinerary).bind(app);
-  // NOTE: this is intend to cache the entire product list
-  const cacheKey = hash({
-    userId,
-    hint,
-    operationId: 'bookingsProductSearch',
-  });
-  // Check cache first if not forcing refresh
-  const cacheValue = forceRefresh ? null : await app.cache.get({
-    key: cacheKey,
-  });
-  const lastUpdated = await app.cache.get({
-    key: `${cacheKey}:lastUpdated`,
-  });
-  // refresh every 24 hours
+
+  const cacheKey = hash({ userId, hint, operationId: 'bookingsProductSearch' });
+  const pluginExecutionLockKey = `${cacheKey}:lock`; // Lock for direct plugin execution
+  const jobQueueLockKey = `${cacheKey}:jobLock`;   // Lock for preventing multiple job queues
+
+  // Fetch actualCacheContent once at the beginning.
+  const initialActualCacheContent = await app.cache.get({ key: cacheKey });
+  const lastUpdated = await app.cache.get({ key: `${cacheKey}:lastUpdated` });
   const ttr = token.ttlForProducts || R.path(['cacheSettings', 'bookingsProductSearch', 'ttr'], app) || 60 * 60 * 24;
-  let isStale = lastUpdated && (Date.now() - lastUpdated > ttr * 1000);
-  const doNotCallPluginForProducts = token.doNotCallPluginForProducts
-    || R.path(['cacheSettings', 'bookingsProductSearch', 'doNotCall'], app);
-  // if a company says never to call the plugin (their booking system)
-  // we will never treat their cache as stale
-  if (doNotCallPluginForProducts) {
-    isStale = false;
-  }
-  const hasLock = await app.cache.get({
-    key: `${cacheKey}:lock`,
-  });
-  // when there is a lock (meaning another request is already fetching the products)
-  // return stale cache during this short window
-  if (cacheValue && cacheValue.products && (hasLock || !isStale)) {
-    const searchResults = $searchProductList(cacheValue.products, searchInput, optionId);
-    return {
-      ...cacheValue,
-      products: searchResults,
-      // this is for sending the product filters specifically being used by pyfilematch
-      ...(token.configuration || {}),
-    };
-  }
+  const isStaleByTTR = lastUpdated && (Date.now() - lastUpdated > ttr * 1000);
+  const doNotCallPluginForProducts = token.doNotCallPluginForProducts || R.path(['cacheSettings', 'bookingsProductSearch', 'doNotCall'], app);
+  const hasPluginExecutionLock = await app.cache.get({ key: pluginExecutionLockKey });
+
+  // Helper function to call the plugin, save cache, and return results
+  const fetchFromPluginAndCache = async () => {
+    await app.cache.save({ key: pluginExecutionLockKey, value: true, ttl: 120 });
+    let pluginResults;
+    try {
+      pluginResults = await func({
+        axios, token, payload: payloadForPlugin, typeDefsAndQueries, requestId, userId,
+      });
+
+      // This function is responsible for caching if it fetched good results.
+      // This applies to forceRefresh, initial load, or direct calls that result in a fetch.
+      // The $updateProductSearchCache function handles caching for background jobs queued due to stale data.
+      if (pluginResults && pluginResults.products && pluginResults.products.length > 0) {
+        const monthInSeconds = 30 * 24 * 60 * 60;
+        await app.cache.save({ key: `${cacheKey}:lastUpdated`, value: Date.now(), ttl: monthInSeconds });
+        await app.cache.save({ key: cacheKey, value: pluginResults, ttl: monthInSeconds });
+        app.events.emit('bookingsProductSearch:cache:save', {
+          cacheKey, userId, hint, operationId: 'bookingsProductSearch', requestId, pluginName: app.name,
+        });
+      }
+      // If pluginResults are empty, cache is NOT updated here by fetchFromPluginAndCache.
+      // This maintains existing behavior for forceRefresh/initial load paths.
+      // $updateProductSearchCache has its own logic for handling empty results from background refresh.
+    } finally {
+      await app.cache.drop({ key: pluginExecutionLockKey });
+    }
+    return pluginResults || { products: [] }; // Ensure products array exists
+  };
+
+  // 1. `doNotCallPluginForProducts` is true, and not `forceRefresh`: Serve from cache or empty.
   if (doNotCallPluginForProducts && !forceRefresh) {
-    return { products: [] };
+    if (initialActualCacheContent && initialActualCacheContent.products) {
+      const searchResults = $searchProductList(initialActualCacheContent.products, searchInput, optionId);
+      return { ...initialActualCacheContent, products: searchResults, ...(token.configuration || {}) };
+    }
+    return { products: [], ...(token.configuration || {}) };
   }
-  // create a lock with 2 minute TTL
-  await app.cache.save({
-    key: `${cacheKey}:lock`,
-    value: true,
-    ttl: 120,
-  });
-  const funcResults = await func({
-    axios,
-    token,
-    payload: restPayload,
-    typeDefsAndQueries,
-    requestId,
-    userId,
-  });
-  // save cache if products are found
-  if (funcResults && funcResults.products && funcResults.products.length > 0) {
-    // I initially wanted to let the cache live forever
-    // but just in case user left TC or something, we don't want to keep the cache forever
-    // so we set the TTL to 30 days, within 30 days,
-    // we will refresh the cache every 24 hours(or specified by the user) without deleting the stale cache
-    const monthInSeconds = 30 * 24 * 60 * 60;
-    await app.cache.save({
-      key: `${cacheKey}:lastUpdated`,
-      value: Date.now(),
-      ttl: monthInSeconds,
-    });
-    await app.cache.save({
-      key: cacheKey,
-      value: funcResults,
-      ttl: monthInSeconds,
-    });
-    app.events.emit('bookingsProductSearch:cache:save', {
-      cacheKey,
-      userId,
-      hint,
-      operationId: 'bookingsProductSearch',
-      requestId,
-      pluginName: app.name,
-    });
+
+  // 2. `forceRefresh` is true (and not case 1): Fetch from plugin.
+  //    fetchFromPluginAndCache will handle caching the new results.
+  if (forceRefresh) {
+    const funcResults = await fetchFromPluginAndCache();
+    const searchResults = $searchProductList(funcResults.products, searchInput, optionId);
+    return { ...funcResults, products: searchResults, ...(token.configuration || {}) };
   }
-  // release the lock
-  await app.cache.drop({
-    key: `${cacheKey}:lock`,
-  });
-  const searchResults = $searchProductList(R.pathOr([], ['products'], funcResults), searchInput, optionId);
+
+  // 3. Cache exists (initialActualCacheContent) and not forceRefresh:
+  if (initialActualCacheContent && initialActualCacheContent.products) {
+    // Effective staleness check for deciding if a background refresh is needed.
+    const isEffectivelyStale = isStaleByTTR && !doNotCallPluginForProducts;
+
+    if (!isEffectivelyStale || hasPluginExecutionLock) {
+      // Cache is fresh OR (is stale BUT a plugin execution is already in progress for refresh): Serve from cache.
+      const searchResults = $searchProductList(initialActualCacheContent.products, searchInput, optionId);
+      return { ...initialActualCacheContent, products: searchResults, ...(token.configuration || {}) };
+    } else {
+      // Cache is effectively stale AND no plugin execution is currently in progress.
+      // Try to queue a background job.
+      const hasJobQueueLock = await app.cache.get({ key: jobQueueLockKey });
+
+      if (hasJobQueueLock) {
+        // A background job has recently been queued by another request. Serve stale data.
+        const searchResults = $searchProductList(initialActualCacheContent.products, searchInput, optionId);
+        return { ...initialActualCacheContent, products: searchResults, ...(token.configuration || {}) };
+      } else {
+        // No job queue lock. Set one, then queue the job, then serve stale data.
+        await app.cache.save({ key: jobQueueLockKey, value: true, ttl: 60 }); // Lock for 60 seconds
+
+        const searchResults = $searchProductList(initialActualCacheContent.products, searchInput, optionId);
+        
+        const pluginMethodPayload = {
+          payload: payloadForPlugin,
+          userId,
+        };
+        const jobData = {
+          type: 'plugin',
+          pluginName: appKey,
+          method: app.searchProducts ? 'searchProducts' : 'searchProductsForItinerary',
+          token,
+          payload: pluginMethodPayload,
+          postProcess: {
+            controller: 'bookings',
+            action: '$updateProductSearchCache',
+            args: { appKey, userId, hint },
+          },
+        };
+        await addJob(jobData, { removeOnComplete: true });
+        
+        return { ...initialActualCacheContent, products: searchResults, ...(token.configuration || {}) };
+      }
+    }
+  }
+
+  // 4. No cache content (and not caught by previous conditions like forceRefresh or doNotCallPluginForProducts):
+  //    Fetch from plugin. fetchFromPluginAndCache will handle caching.
+  const funcResults = await fetchFromPluginAndCache();
+  const searchResults = $searchProductList(funcResults.products, searchInput, optionId);
   return {
     ...funcResults,
     products: searchResults,
@@ -253,6 +281,7 @@ const bookingsProductSearch = plugins => async (req, res, next) => {
       ...params,
       payload,
       requestId,
+      headers: req.headers, // Pass original request headers
     }));
   } catch (err) {
     return next(err);
@@ -561,19 +590,70 @@ const getCreateBookingFields = plugins => async (req, res, next) => {
   }
 };
 
-module.exports = plugins => ({
-  bookingsSearch: bookingsSearch(plugins),
-  bookingsCancel: bookingsCancel(plugins),
-  $bookingsProductSearch,
-  bookingsProductSearch: bookingsProductSearch(plugins),
-  getProductPackages: getProductPackages(plugins),
-  bookingsAvailabilitySearch: bookingsAvailabilitySearch(plugins),
-  $bookingsAvailabilityCalendar,
-  bookingsAvailabilityCalendar: bookingsAvailabilityCalendar(plugins),
-  searchQuote: searchQuote(plugins),
-  createBooking: createBooking(plugins),
-  getAffiliateAgents: getAffiliateAgents(plugins),
-  getAffiliateDesks: getAffiliateDesks(plugins),
-  getPickupPoints: getPickupPoints(plugins),
-  getCreateBookingFields: getCreateBookingFields(plugins),
-});
+const $updateProductSearchCache = plugins => async ({
+  appKey,
+  userId,
+  hint,
+  pluginResult, // Result from the plugin method call
+  requestId,
+  // 'plugins' is available via the factory closure
+}) => {
+  const app = plugins.find(({ name }) => name === appKey);
+  if (!app) {
+    console.error(`[$updateProductSearchCache][requestId: ${requestId}] Plugin ${appKey} not found.`);
+    return; // Or throw error
+  }
+
+  const cacheKey = hash({ userId, hint, operationId: 'bookingsProductSearch' });
+  const monthInSeconds = 30 * 24 * 60 * 60;
+
+  // Always update lastUpdated to prevent immediate re-trigger of background jobs
+  // even if the plugin returned empty results.
+  await app.cache.save({ key: `${cacheKey}:lastUpdated`, value: Date.now(), ttl: monthInSeconds });
+
+  if (pluginResult && pluginResult.products && pluginResult.products.length > 0) {
+    await app.cache.save({ key: cacheKey, value: pluginResult, ttl: monthInSeconds });
+    app.events.emit('bookingsProductSearch:cache:save', {
+      cacheKey, userId, hint, operationId: 'bookingsProductSearch', requestId, pluginName: app.name,
+    });
+    console.log(`[$updateProductSearchCache][requestId: ${requestId}] Saved products to cache for ${appKey}, user ${userId}, hint ${hint}.`);
+  } else {
+    // If plugin returned no products, update the cache to reflect this.
+    // This prevents serving stale data indefinitely if the source truly has no products anymore.
+    await app.cache.save({ key: cacheKey, value: { products: [] }, ttl: monthInSeconds });
+    app.events.emit('bookingsProductSearch:cache:emptyRefresh', {
+      cacheKey, userId, hint, operationId: 'bookingsProductSearch', requestId, pluginName: app.name,
+      pluginResult, // Log what the plugin returned
+    });
+    console.log(`[$updateProductSearchCache][requestId: ${requestId}] Plugin returned empty/no products. Cached empty for ${appKey}, user ${userId}, hint ${hint}.`);
+  }
+};
+
+// Update the module.exports to correctly assign the plugin-wrapped function
+const controllerFactory = plugins => {
+  const controllerFunctions = {
+    bookingsSearch: bookingsSearch(plugins),
+    bookingsCancel: bookingsCancel(plugins),
+    $bookingsProductSearch: $bookingsProductSearch(plugins),
+    bookingsProductSearch: bookingsProductSearch(plugins),
+    getProductPackages: getProductPackages(plugins),
+    bookingsAvailabilitySearch: bookingsAvailabilitySearch(plugins),
+    $bookingsAvailabilityCalendar: $bookingsAvailabilityCalendar(plugins),
+    bookingsAvailabilityCalendar: bookingsAvailabilityCalendar(plugins),
+    searchQuote: searchQuote(plugins),
+    createBooking: createBooking(plugins),
+    getAffiliateAgents: getAffiliateAgents(plugins),
+    getAffiliateDesks: getAffiliateDesks(plugins),
+    getPickupPoints: getPickupPoints(plugins),
+    getCreateBookingFields: getCreateBookingFields(plugins),
+    $updateProductSearchCache: $updateProductSearchCache(plugins), // Add the new function here
+  };
+  // Ensure $bookingsProductSearch can be called internally by worker with plugins already bound
+  // This is more of a conceptual note as the factory pattern already handles this.
+  return controllerFunctions;
+};
+
+// Add this line to attach typeDefsAndQueries to the factory:
+controllerFactory.typeDefsAndQueries = typeDefsAndQueries;
+
+module.exports = controllerFactory;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ti2",
-  "version": "1.0.95",
+  "version": "1.0.96",
   "description": "Tourist Industry Exchange (TI2)",
   "main": "index.js",
   "scripts": {

package/test/utils.js

@@ -71,51 +71,51 @@ module.exports = async (appParams = {}) => {
   const doApiPut = params => doApi({ ...params, verb: 'put' });
   const doApiDelete = params => doApi({ ...params, verb: 'delete' });
 
-  const appSetup = async ({ userId: userIdParam, appName: appNameParam } = {}) => {
+  const appSetup = async ({ userId: userIdParam, appName: appNameParam, token: tokenDataParam, tokenHint: hintParam } = {}) => {
     const userId = userIdParam || chance.guid();
-    const appName1 = appNameParam || slugify(
-      chance.company(),
-    ).toLowerCase();
-    const newApp = {
-      name: appName1,
-      packageName: `ti2-${appName1}`,
-      adminEmail: chance.email(),
+    const appName = appNameParam || slugify(chance.company()).toLowerCase();
+
+    const integrationDetails = { // Details for the Integration (app) to be created/ensured
+      name: appName,
+      packageName: `ti2-${appName}`, // Default package name
+      adminEmail: chance.email(),   // Default admin email
     };
-    const apiKey1 = chance.guid();
-    const token = {
+
+    // Ensure the Integration (app) record exists.
+    // POST /app is an admin endpoint to create an Integration.
+    // This call ensures the 'Integrations' table has the required 'appName'.
+    // It's assumed this endpoint can be called safely even if the integration already exists.
+    await request(app)
+      .post('/app')
+      .set('Authorization', `Bearer ${adminKey}`) // Admin key to authorize Integration creation
+      .send(integrationDetails)
+      .expect(200); // Or handle potential non-200 responses if it errors on duplicate
+
+    // Prepare the token content for the UserAppKey.
+    // If tokenDataParam is provided by the test, use it; otherwise, generate default content.
+    const userAppKeyTokenContent = tokenDataParam || {
       endpoint: chance.url(),
-      apiKey: apiKey1,
+      apiKey: chance.guid(),
     };
+
+    // Determine the hint for the UserAppKey.
+    // If hintParam is provided, use it; otherwise, derive from apiKey or generate a random word.
+    const hint = hintParam || (userAppKeyTokenContent.apiKey ? userAppKeyTokenContent.apiKey.split('-')[0] : chance.word({ length: 8 }));
     
-    let appKey;
-    
-    // Only create a new app if appNameParam is not provided
-    if (!appNameParam) {
-      const { body: { value: newAppKey } } = await request(app)
-        .post('/app')
-        .set('Authorization', `Bearer ${adminKey}`)
-        .send(newApp);
-      appKey = newAppKey;
-    } else {
-      // If appNameParam is provided, we'll use the adminKey directly
-      // This avoids the need for a GET /app/{appName} endpoint
-      appKey = adminKey;
-    }
-    
-    // Create user token for the app
-    const hint = token.apiKey.split('-')[0];
+    // Create the UserAppKey, linking the user to the integration with specific token data and hint.
+    // This call depends on the Integration (appName) existing.
     await request(app)
-      .post(`/${newApp.name}/${userId}`)
-      .set('Authorization', `Bearer ${appKey}`)
+      .post(`/${appName}/${userId}`) // URL uses the Integration's name (appName)
+      .set('Authorization', `Bearer ${adminKey}`) // Admin key to authorize UserAppKey creation
       .send({
         tokenHint: hint,
-        token,
-      });
+        token: userAppKeyTokenContent, // This is the data to be stored in UserAppKey.appKey (will be encrypted)
+      })
+      .expect(200); // Expect success for UserAppKey creation
     
     return {
-      newApp,
-      token,
-      appKey,
+      newApp: integrationDetails, // Information about the integration that was ensured/created
+      token: userAppKeyTokenContent,  // The plaintext content that was intended for UserAppKey.appKey
       userId,
       hint,
     };
@@ -131,5 +131,6 @@ module.exports = async (appParams = {}) => {
     createUserToken,
     slugify,
     plugins: app.plugins,
+    sqldb, // Expose sqldb for direct DB interaction if needed in tests (e.g., cleanup)
   };
 };

package/worker/__tests__/job-plugin.js

@@ -0,0 +1,207 @@
+// Mock throng to directly execute the worker function
+jest.mock('throng', () => jest.fn(config => {
+  if (typeof config.worker === 'function') {
+    config.worker('test-worker-id-plugin', jest.fn());
+  } else {
+    console.error('Mocked throng (plugin test): config.worker is not a function or not provided.');
+  }
+}));
+
+// Mock the queue to avoid actual Redis operations and capture the handler
+jest.mock('../queue', () => {
+  const original = jest.requireActual('../queue');
+  return {
+    ...original,
+    queue: {
+      ...original.queue,
+      process: jest.fn(), // Used to capture the job handler
+    },
+    addJob: jest.fn().mockResolvedValue('test-plugin-job-id'), // Mock addJob
+    saveResult: jest.fn().mockResolvedValue(undefined), // Mock saveResult
+    // listJobs, jobStatus etc. can be original or mocked if needed by other tests
+  };
+});
+
+// Mock bookingsControllerFactory to provide a mock for postProcess actions
+const mockBookingsPostProcessAction = jest.fn();
+jest.mock('../../controllers/bookings', () => {
+  return jest.fn(() => ({
+    // This action name must match what's in job.data.postProcess.action
+    $updateProductSearchCache: mockBookingsPostProcessAction,
+    // Add other methods if the worker's initialization of bookingsCtrl calls them
+  }));
+});
+
+// Import the mocked queue and the actual worker module
+const { queue, addJob, saveResult } = require('../queue');
+const actualWorkerModule = require('../index'); // Actual worker module
+const testUtils = require('../../test/utils'); // For setting up plugins
+
+describe('worker: Plugin job handling', () => {
+  let instantiatedPlugins; // Array of instantiated mock plugins from testUtils
+  let actualJobHandler; // The job processing function from the worker
+
+  beforeAll(async () => {
+    jest.spyOn(console, 'log').mockImplementation(() => {});
+    jest.spyOn(console, 'error').mockImplementation(() => {});
+
+
+    const utils = await testUtils({
+      plugins: ['mockPluginForWorker'], // Provide a name for our mock plugin
+      startServer: false, // Worker tests usually don't need a live server
+      worker: false,
+    });
+    instantiatedPlugins = utils.plugins; // These are already instantiated mock plugins
+
+    // Capture the job handler from queue.process
+    queue.process.mockImplementation((concurrency, handler) => {
+      if (typeof handler === 'function') {
+        actualJobHandler = handler;
+      } else if (typeof concurrency === 'function') { // Handle case where concurrency is omitted
+        actualJobHandler = concurrency;
+      } else {
+        throw new Error('queue.process mock in plugin test could not capture handler');
+      }
+    });
+
+    // Initialize the worker module. This should cause queue.process to be called.
+    await actualWorkerModule({ plugins: instantiatedPlugins });
+
+    if (!actualJobHandler) {
+      throw new Error('Job handler was not captured in plugin test. Worker might not have initialized queue processing correctly.');
+    }
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks(); // Clears all mocks, including plugin method spies and postProcess action
+    // Reset specific mocks if needed, e.g., return values for plugin methods
+    if (instantiatedPlugins && instantiatedPlugins.length > 0 && instantiatedPlugins[0].searchProducts) {
+        instantiatedPlugins[0].searchProducts.mockClear();
+    }
+    mockBookingsPostProcessAction.mockClear();
+  });
+
+  afterAll(() => {
+    jest.restoreAllMocks();
+    actualJobHandler = null;
+  });
+
+  it('should call postProcess action after successful plugin method execution', async () => {
+    const mockPluginName = 'mockPluginForWorker'; // Must match plugin name used in testUtils setup
+    const mockPluginMethod = 'searchProducts'; // Method to be called on the plugin
+    const mockPluginPayload = { query: 'test query' };
+    const mockPluginToken = { apiKey: 'test-api-key-for-plugin' };
+    const mockPluginResult = { products: [{ id: 'prod123', name: 'Test Product' }] };
+    const jobId = 'plugin-job-with-pp-001';
+
+    // Ensure the target mock plugin and its method exist
+    const targetPlugin = instantiatedPlugins.find(p => p.name === mockPluginName);
+    if (!targetPlugin || typeof targetPlugin[mockPluginMethod] !== 'function') {
+      throw new Error(`Mock plugin ${mockPluginName} or method ${mockPluginMethod} not found or not a function.`);
+    }
+    // Mock the plugin method's return value for this specific test
+    targetPlugin[mockPluginMethod].mockResolvedValue(mockPluginResult);
+
+    const jobDataWithPostProcess = {
+      type: 'plugin',
+      pluginName: mockPluginName,
+      method: mockPluginMethod,
+      payload: mockPluginPayload, // This is job.data.payload
+      token: mockPluginToken,     // This is job.data.token
+      inTesting: true,
+      postProcess: {
+        controller: 'bookings',
+        action: '$updateProductSearchCache', // Must match the mocked action name in bookings mock
+        args: { staticArg1: 'value1', appKey: mockPluginName }, // Static args for postProcess
+      },
+    };
+
+    const mockJob = {
+      data: jobDataWithPostProcess,
+      id: jobId,
+      log: jest.fn(), // Bull's job.log
+      progress: jest.fn(), // Bull's job.progress
+    };
+
+    await actualJobHandler(mockJob);
+
+    // 1. Verify the plugin method was called correctly
+    expect(targetPlugin[mockPluginMethod]).toHaveBeenCalledTimes(1);
+    expect(targetPlugin[mockPluginMethod]).toHaveBeenCalledWith(expect.objectContaining({
+      ...mockPluginPayload, // job.data.payload is spread
+      token: mockPluginToken, // job.data.token is passed as 'token'
+      requestId: jobId,
+      // axios and typeDefsAndQueries are also injected by the worker
+    }));
+
+    // 2. Verify the postProcess action was called correctly
+    expect(mockBookingsPostProcessAction).toHaveBeenCalledTimes(1);
+    expect(mockBookingsPostProcessAction).toHaveBeenCalledWith(expect.objectContaining({
+      staticArg1: 'value1', // From postProcess.args
+      appKey: mockPluginName, // From postProcess.args
+      pluginResult: mockPluginResult, // The result from the plugin method
+      requestId: jobId,
+    }));
+
+    // 3. Verify saveResult was called (implicitly tests success path)
+    expect(saveResult).toHaveBeenCalledWith({ id: jobId, resultValue: mockPluginResult });
+  });
+
+  it('should still save result even if postProcess is not defined', async () => {
+    const mockPluginName = 'mockPluginForWorker';
+    const mockPluginMethod = 'searchProducts';
+    const mockPluginResult = { products: [{ id: 'prod456' }] };
+    const jobId = 'plugin-job-no-pp-002';
+
+    const targetPlugin = instantiatedPlugins.find(p => p.name === mockPluginName);
+    targetPlugin[mockPluginMethod].mockResolvedValue(mockPluginResult);
+
+    const jobDataNoPostProcess = {
+      type: 'plugin',
+      pluginName: mockPluginName,
+      method: mockPluginMethod,
+      payload: { query: 'another query' },
+      token: { apiKey: 'key-for-no-pp' },
+      inTesting: true,
+      // No postProcess field
+    };
+
+    const mockJob = { data: jobDataNoPostProcess, id: jobId, log: jest.fn(), progress: jest.fn() };
+    await actualJobHandler(mockJob);
+
+    expect(targetPlugin[mockPluginMethod]).toHaveBeenCalledTimes(1);
+    expect(mockBookingsPostProcessAction).not.toHaveBeenCalled();
+    expect(saveResult).toHaveBeenCalledWith({ id: jobId, resultValue: mockPluginResult });
+  });
+
+  it('should throw error and not call postProcess if plugin method fails', async () => {
+    const mockPluginName = 'mockPluginForWorker';
+    const mockPluginMethod = 'searchProducts';
+    const jobId = 'plugin-job-fail-003';
+    const pluginError = new Error('Plugin method failed');
+
+    const targetPlugin = instantiatedPlugins.find(p => p.name === mockPluginName);
+    targetPlugin[mockPluginMethod].mockRejectedValue(pluginError);
+
+    const jobDataWithPpForFailure = {
+      type: 'plugin',
+      pluginName: mockPluginName,
+      method: mockPluginMethod,
+      payload: {},
+      token: {},
+      inTesting: true,
+      postProcess: {
+        controller: 'bookings',
+        action: '$updateProductSearchCache',
+        args: { appKey: mockPluginName },
+      },
+    };
+    const mockJob = { data: jobDataWithPpForFailure, id: jobId, log: jest.fn(), progress: jest.fn() };
+
+    await expect(actualJobHandler(mockJob)).rejects.toThrow(pluginError.message);
+
+    expect(targetPlugin[mockPluginMethod]).toHaveBeenCalledTimes(1);
+    expect(mockBookingsPostProcessAction).not.toHaveBeenCalled();
+    expect(saveResult).not.toHaveBeenCalled(); // saveResult should not be called on failure
+  });
+});