ti2 1.0.115 → 1.0.118

package/controllers/__tests__/bookings-searchProducts.js

@@ -9,13 +9,14 @@ const cache = require('../../cache');
 // Mock the worker/queue module
 jest.mock('../../worker/queue', () => ({
   ...jest.requireActual('../../worker/queue'), // Import and retain default behavior
-  addJob: jest.fn().mockResolvedValue({ id: 'mockJobId' }), // Mock addJob
+  addJob: jest.fn().mockResolvedValue('mockJobId'), // Mock addJob
   // Provide mock for jobStatus as it might be called by other parts of the code or tests
   jobStatus: jest.fn().mockResolvedValue({ status: 'completed', progress: 100, returnValue: null }),
 }));
 const { addJob, jobStatus: mockJobStatus } = require('../../worker/queue'); // Now addJob is the mock
 
 const testUtils = require('../../test/utils'); // Require the module itself
+const bookingsControllerFactory = require('../bookings');
 
 // Global setup for the entire test file
 let globalDoApiPost, globalPlugins, globalUtils, globalSqldb;
@@ -159,6 +160,44 @@ describe('user: bookings controller - searchProducts', () => {
         expect(products[0].options.length).toBe(1);
         expect(products[0].options[0].optionName).toBe('Transfer from Sydney Harbor Bridge to Hilton Hotel');
       });
+      it('should filter cached full catalog by optionId without another plugin call', async () => {
+        const { products } = await doApiPost({
+          url: `/products/${testAppName}/${testUserId}/${testHint}/search`,
+          token: userToken,
+          payload: { optionId: '2345' },
+        });
+        expect(travelgatePlugin.searchProducts).not.toHaveBeenCalled();
+        expect(products).toHaveLength(1);
+        expect(products[0].options).toHaveLength(1);
+        expect(products[0].options[0].optionId).toBe('2345');
+      });
+      it('should emit sanitized cache-decision telemetry without raw ids, hints, payloads, or plugin results', async () => {
+        const emitSpy = jest.spyOn(travelgatePlugin.events, 'emit');
+        await doApiPost({
+          url: `/products/${testAppName}/${testUserId}/${testHint}/search`,
+          token: userToken,
+          payload: { searchInput: 'Transfer from Sydney Harbor to Hilton Hotel' },
+        });
+        const decisionPayloads = emitSpy.mock.calls
+          .filter(call => call[0] === 'bookingsProductSearch:cache:decision')
+          .map(call => call[1]);
+        expect(decisionPayloads.length).toBeGreaterThan(0);
+        decisionPayloads.forEach(payload => {
+          expect(payload.userId).toBeUndefined();
+          expect(payload.hint).toBeUndefined();
+          expect(payload.cacheKey).toBeUndefined();
+          expect(payload.pluginResult).toBeUndefined();
+          expect(payload.searchInput).toBeUndefined();
+          expect(payload.optionId).toBeUndefined();
+          expect(payload.userIdHash).toBeTruthy();
+          expect(payload.hintHash).toBeTruthy();
+          expect(payload.cacheKeyHash).toBeTruthy();
+          expect(JSON.stringify(payload)).not.toContain(testUserId);
+          expect(JSON.stringify(payload)).not.toContain(testHint);
+          expect(JSON.stringify(payload)).not.toContain('Transfer from Sydney Harbor');
+        });
+        emitSpy.mockRestore();
+      });
     });
     describe('doNotCallPluginForProducts flag', () => {
       const doNotCallHint = 'hint_for_doNotCallPluginForProducts';
@@ -259,6 +298,7 @@ describe('user: bookings controller - searchProducts', () => {
         it('call outside of TTR should serve stale data and queue background refresh with correct parameters', async () => {
           travelgatePlugin.searchProducts.mockClear(); // Clear before action
           addJob.mockClear(); // Clear addJob mock before this action that should trigger it
+          const emitSpy = jest.spyOn(travelgatePlugin.events, 'emit');
 
           const { products } = await doApiPost({
             url: `/products/${testAppName}/${testUserId}/${ttrTestHint}/search`, // appName is 'travelgate'
@@ -292,6 +332,15 @@ describe('user: bookings controller - searchProducts', () => {
           expect(jobData.postProcess.args.userId).toBe(testUserId);
           expect(jobData.postProcess.args.hint).toBe(ttrTestHint);
           expect(jobParams).toEqual({ removeOnComplete: true });
+          expect(emitSpy).toHaveBeenCalledWith(
+            'bookingsProductSearch:cache:decision',
+            expect.objectContaining({
+              action: 'stale_served',
+              reason: 'backgroundRefreshQueued',
+              jobId: 'mockJobId',
+            }),
+          );
+          emitSpy.mockRestore();
         });
       });
       // The 'lock mechanism (job queuing on stale cache)' describe block has been moved to the top level.
@@ -314,8 +363,8 @@ describe('user: bookings controller - searchProducts', () => {
 
     beforeEach(async () => {
       // Clear mocks
-      if (travelgatePlugin && travelgatePlugin.searchProducts && travelgatePlugin.searchProducts.mockClear) {
-        travelgatePlugin.searchProducts.mockClear();
+      if (travelgatePlugin && travelgatePlugin.searchProducts && travelgatePlugin.searchProducts.mockReset) {
+        travelgatePlugin.searchProducts.mockReset();
       }
       if (addJob && addJob.mockClear) {
         addJob.mockClear();
@@ -341,13 +390,18 @@ describe('user: bookings controller - searchProducts', () => {
           token: staleCacheTokenConfig,
       });
       // Clear mocks that might have been called during appSetup
-      if (travelgatePlugin.searchProducts.mockClear) travelgatePlugin.searchProducts.mockClear();
+      if (travelgatePlugin.searchProducts.mockReset) travelgatePlugin.searchProducts.mockReset();
       if (addJob.mockClear) addJob.mockClear();
     });
 
-    it('should return stale (non-empty) products when TTR expires and refresh yields empty products', async () => {
+    it('should return stale products and preserve the cache when refresh yields empty products', async () => {
       const initialProductsInCache = [{ productId: 'staleProd1', name: 'Stale Product One', optionId: 'optStale1' }];
       const productsFromPluginRefresh = []; // Simulate plugin returning empty on refresh
+      const cacheKeyForTest = hash({
+        userId: testUserId,
+        hint: staleCacheTestHint,
+        operationId: 'bookingsProductSearch',
+      });
 
       // 1. First call: Populate the cache with initialProductsInCache
       travelgatePlugin.searchProducts.mockResolvedValueOnce({ products: initialProductsInCache });
@@ -387,8 +441,222 @@ describe('user: bookings controller - searchProducts', () => {
       expect(travelgatePlugin.searchProducts).not.toHaveBeenCalled();
 
       // Note: This test verifies the immediate response serves stale data and a job is queued.
-      // It does not verify the cache state *after* the job (which would use the empty refresh)
-      // because $updateProductSearchCache currently caches empty results.
+      // Cache preservation for empty background refreshes is covered below.
+    });
+
+    it('should keep existing non-empty cache when background refresh returns empty products', async () => {
+      const initialProductsInCache = [{ productId: 'staleProd1', name: 'Stale Product One', optionId: 'optStale1' }];
+      const cacheKeyForTest = hash({
+        userId: testUserId,
+        hint: staleCacheTestHint,
+        operationId: 'bookingsProductSearch',
+      });
+      await cache.save({
+        pluginName: testAppName,
+        key: cacheKeyForTest,
+        value: { products: initialProductsInCache },
+        ttl: 60,
+      });
+      await cache.save({
+        pluginName: testAppName,
+        key: `${cacheKeyForTest}:lastUpdated`,
+        value: 1,
+        ttl: 60,
+      });
+      const emitSpy = jest.spyOn(travelgatePlugin.events, 'emit');
+
+      await bookingsControllerFactory(globalPlugins).$updateProductSearchCache({
+        appKey: testAppName,
+        userId: testUserId,
+        hint: staleCacheTestHint,
+        pluginResult: { products: [] },
+        requestId: 'empty-refresh-test',
+      });
+
+      const cached = await cache.get({ pluginName: testAppName, key: cacheKeyForTest });
+      const lastUpdated = await cache.get({ pluginName: testAppName, key: `${cacheKeyForTest}:lastUpdated` });
+      expect(cached.products).toEqual(initialProductsInCache);
+      expect(lastUpdated).toBeGreaterThan(1);
+      expect(emitSpy).toHaveBeenCalledWith(
+        'bookingsProductSearch:cache:decision',
+        expect.objectContaining({
+          action: 'empty_refresh_skipped',
+          reason: 'emptyResultPreservedExistingCache',
+          cachePreserved: true,
+          existingProductCount: initialProductsInCache.length,
+        }),
+      );
+      expect(emitSpy).toHaveBeenCalledWith(
+        'bookingsProductSearch:cache:emptyRefreshSkipped',
+        expect.objectContaining({
+          action: 'empty_refresh_skipped',
+          reason: 'emptyResultPreservedExistingCache',
+          cachePreserved: true,
+        }),
+      );
+      emitSpy.mockRestore();
+    });
+
+    it('should not cache partial product refreshes as complete results', async () => {
+      const cacheKeyForTest = hash({
+        userId: testUserId,
+        hint: staleCacheTestHint,
+        operationId: 'bookingsProductSearch',
+      });
+      await cache.drop({ pluginName: testAppName, key: cacheKeyForTest });
+
+      await bookingsControllerFactory(globalPlugins).$updateProductSearchCache({
+        appKey: testAppName,
+        userId: testUserId,
+        hint: staleCacheTestHint,
+        pluginResult: {
+          catalogPartial: true,
+          products: [{ productId: 'partialProd1' }],
+        },
+        requestId: 'partial-refresh-test',
+      });
+
+      const cached = await cache.get({ pluginName: testAppName, key: cacheKeyForTest });
+      const lastUpdated = await cache.get({ pluginName: testAppName, key: `${cacheKeyForTest}:lastUpdated` });
+      expect(cached).toBeFalsy();
+      expect(lastUpdated).toBeTruthy();
+    });
+
+    it('should not update cache metadata when direct force refresh returns partial products', async () => {
+      const pluginResult = {
+        catalogPartial: true,
+        products: [{ productId: 'partialProd1' }],
+      };
+      const cacheKeyForTest = hash({
+        userId: testUserId,
+        hint: staleCacheTestHint,
+        operationId: 'bookingsProductSearch',
+      });
+      travelgatePlugin.searchProducts.mockResolvedValueOnce(pluginResult);
+
+      await doApiPost({
+        url: `/products/${testAppName}/${testUserId}/${staleCacheTestHint}/search`,
+        token: userToken,
+        payload: { forceRefresh: true },
+      });
+
+      const cached = await cache.get({ pluginName: testAppName, key: cacheKeyForTest });
+      const lastUpdated = await cache.get({ pluginName: testAppName, key: `${cacheKeyForTest}:lastUpdated` });
+      expect(travelgatePlugin.searchProducts).toHaveBeenCalledTimes(1);
+      expect(cached).toBeFalsy();
+      expect(lastUpdated).toBeFalsy();
+    });
+
+    it('should keep existing non-empty cache when background refresh returns partial products', async () => {
+      const initialProductsInCache = [{ productId: 'staleProd1', name: 'Stale Product One', optionId: 'optStale1' }];
+      const pluginResult = {
+        catalogPartial: true,
+        products: [{ productId: 'partialProd1' }],
+      };
+      const cacheKeyForTest = hash({
+        userId: testUserId,
+        hint: staleCacheTestHint,
+        operationId: 'bookingsProductSearch',
+      });
+      await cache.save({
+        pluginName: testAppName,
+        key: cacheKeyForTest,
+        value: { products: initialProductsInCache },
+        ttl: 60,
+      });
+      await cache.save({
+        pluginName: testAppName,
+        key: `${cacheKeyForTest}:lastUpdated`,
+        value: 1,
+        ttl: 60,
+      });
+      const emitSpy = jest.spyOn(travelgatePlugin.events, 'emit');
+
+      await bookingsControllerFactory(globalPlugins).$updateProductSearchCache({
+        appKey: testAppName,
+        userId: testUserId,
+        hint: staleCacheTestHint,
+        pluginResult,
+        requestId: 'partial-refresh-test',
+      });
+
+      const cached = await cache.get({ pluginName: testAppName, key: cacheKeyForTest });
+      const lastUpdated = await cache.get({ pluginName: testAppName, key: `${cacheKeyForTest}:lastUpdated` });
+      expect(cached.products).toEqual(initialProductsInCache);
+      expect(lastUpdated).toBeGreaterThan(1);
+      expect(emitSpy).toHaveBeenCalledWith(
+        'bookingsProductSearch:cache:decision',
+        expect.objectContaining({
+          action: 'partial_refresh_skipped',
+          reason: 'partialResultPreservedExistingCache',
+          cachePreserved: true,
+          existingProductCount: initialProductsInCache.length,
+          returnedProductCount: pluginResult.products.length,
+        }),
+      );
+      expect(emitSpy).toHaveBeenCalledWith(
+        'bookingsProductSearch:cache:partialRefreshSkipped',
+        expect.objectContaining({
+          action: 'partial_refresh_skipped',
+          reason: 'partialResultPreservedExistingCache',
+          cachePreserved: true,
+        }),
+      );
+      emitSpy.mockRestore();
+    });
+
+    it('should not cache empty products if non-empty cache appears before the empty save', async () => {
+      const cacheKeyForTest = hash({
+        userId: 'race-user',
+        hint: 'race-hint',
+        operationId: 'bookingsProductSearch',
+      });
+      const pluginResult = { products: [] };
+      const fakePlugin = {
+        name: 'racePlugin',
+        cache: {
+          get: jest.fn()
+            .mockResolvedValueOnce(null)
+            .mockResolvedValueOnce({ products: [{ productId: 'raceProd1' }] }),
+          save: jest.fn(async () => {}),
+        },
+        events: {
+          emit: jest.fn(),
+        },
+      };
+
+      await bookingsControllerFactory([fakePlugin]).$updateProductSearchCache({
+        appKey: fakePlugin.name,
+        userId: 'race-user',
+        hint: 'race-hint',
+        pluginResult,
+        requestId: 'race-refresh-test',
+      });
+
+      expect(fakePlugin.cache.save).toHaveBeenCalledWith(expect.objectContaining({
+        key: `${cacheKeyForTest}:lastUpdated`,
+      }));
+      expect(fakePlugin.cache.save).not.toHaveBeenCalledWith(expect.objectContaining({
+        key: cacheKeyForTest,
+        value: { products: [] },
+      }));
+      expect(fakePlugin.events.emit).toHaveBeenCalledWith(
+        'bookingsProductSearch:cache:decision',
+        expect.objectContaining({
+          action: 'empty_refresh_skipped',
+          reason: 'emptyResultPreservedConcurrentCache',
+          cachePreserved: true,
+          existingProductCount: 1,
+        }),
+      );
+      expect(fakePlugin.events.emit).toHaveBeenCalledWith(
+        'bookingsProductSearch:cache:emptyRefreshSkipped',
+        expect.objectContaining({
+          action: 'empty_refresh_skipped',
+          reason: 'emptyResultPreservedConcurrentCache',
+          cachePreserved: true,
+        }),
+      );
     });
   });
 });
@@ -445,6 +713,24 @@ describe('Bookings Product Search Lock Mechanism (Job Queuing on Stale Cache)',
     await cache.drop({ pluginName: testAppName, key: `${cacheKey}:jobLock` }); // jobQueueLock
   });
 
+  const clearProductSearchCache = async () => {
+    const cacheKey = hash({
+      userId: testUserId,
+      hint: ttrTestHint,
+      operationId: 'bookingsProductSearch',
+    });
+    await cache.drop({ pluginName: testAppName, key: cacheKey });
+    await cache.drop({ pluginName: testAppName, key: `${cacheKey}:lastUpdated` });
+    await cache.drop({ pluginName: testAppName, key: `${cacheKey}:lock` });
+    await cache.drop({ pluginName: testAppName, key: `${cacheKey}:jobLock` });
+  };
+
+  const makeProductSearchRequest = () => doApiPost({
+    url: `/products/${testAppName}/${testUserId}/${ttrTestHint}/search`,
+    token: userToken,
+    payload: {},
+  });
+
   beforeEach(async () => {
     // Clear mocks before each test in this suite
     addJob.mockClear(); // Reset addJob mock calls
@@ -529,5 +815,194 @@ describe('Bookings Product Search Lock Mechanism (Job Queuing on Stale Cache)',
       );
     }
   });
-});
 
+  it('multiple concurrent requests with no cache should wait for one plugin fetch', async () => {
+    await clearProductSearchCache();
+
+    const coldProducts = [{
+      productId: 'cold-product',
+      productName: 'Cold Product',
+      options: [{
+        optionId: 'cold-option',
+        optionName: 'Cold Option',
+      }],
+    }];
+    lockTestPlugin.searchProducts.mockReset();
+    const releasePluginFetches = [];
+    const pluginFetchStarted = new Promise(resolve => {
+      lockTestPlugin.searchProducts.mockImplementation(() => {
+        resolve();
+        return new Promise(pluginResolve => {
+          releasePluginFetches.push(() => pluginResolve({ products: coldProducts }));
+        });
+      });
+    });
+
+    const requestPromises = [makeProductSearchRequest(), makeProductSearchRequest(), makeProductSearchRequest()];
+    await pluginFetchStarted;
+    await new Promise(resolve => setTimeout(resolve, 50));
+
+    releasePluginFetches.forEach(releasePluginFetch => releasePluginFetch());
+    const results = await Promise.all(requestPromises);
+
+    results.forEach(result => {
+      expect(result.products).toEqual(coldProducts);
+    });
+    expect(lockTestPlugin.searchProducts).toHaveBeenCalledTimes(1);
+    expect(addJob).not.toHaveBeenCalled();
+  });
+
+  it('concurrent forceRefresh requests should wait for one plugin fetch', async () => {
+    await clearProductSearchCache();
+
+    const refreshedProducts = [{
+      productId: 'force-product',
+      productName: 'Force Product',
+      options: [{
+        optionId: 'force-option',
+        optionName: 'Force Option',
+      }],
+    }];
+    lockTestPlugin.searchProducts.mockReset();
+    const releasePluginFetches = [];
+    const pluginFetchStarted = new Promise(resolve => {
+      lockTestPlugin.searchProducts.mockImplementation(() => {
+        resolve();
+        return new Promise(pluginResolve => {
+          releasePluginFetches.push(() => pluginResolve({ products: refreshedProducts }));
+        });
+      });
+    });
+    const makeForceRequest = () => doApiPost({
+      url: `/products/${testAppName}/${testUserId}/${ttrTestHint}/search`,
+      token: userToken,
+      payload: { forceRefresh: true },
+    });
+
+    const requestPromises = [makeForceRequest(), makeForceRequest(), makeForceRequest()];
+    await pluginFetchStarted;
+    await new Promise(resolve => setTimeout(resolve, 50));
+
+    releasePluginFetches.forEach(releasePluginFetch => releasePluginFetch());
+    const results = await Promise.all(requestPromises);
+
+    results.forEach(result => {
+      expect(result.products).toEqual(refreshedProducts);
+    });
+    expect(lockTestPlugin.searchProducts).toHaveBeenCalledTimes(1);
+    expect(addJob).not.toHaveBeenCalled();
+  });
+
+  it('renews the plugin execution lock while a cold product fetch exceeds the initial TTL', async () => {
+    await clearProductSearchCache();
+    const originalLockTtl = process.env.PRODUCT_SEARCH_LOCK_TTL_SECONDS;
+    process.env.PRODUCT_SEARCH_LOCK_TTL_SECONDS = '1';
+
+    const slowProducts = [{
+      productId: 'slow-product',
+      productName: 'Slow Product',
+      options: [{
+        optionId: 'slow-option',
+        optionName: 'Slow Option',
+      }],
+    }];
+    lockTestPlugin.searchProducts.mockReset();
+    const expireIfValueSpy = jest.spyOn(lockTestPlugin.cache, 'expireIfValue');
+    const releasePluginFetches = [];
+    const pluginFetchStarted = new Promise(resolve => {
+      lockTestPlugin.searchProducts.mockImplementation(() => {
+        resolve();
+        return new Promise(pluginResolve => {
+          releasePluginFetches.push(() => pluginResolve({ products: slowProducts }));
+        });
+      });
+    });
+
+    try {
+      const firstRequest = makeProductSearchRequest();
+      await pluginFetchStarted;
+      await new Promise(resolve => setTimeout(resolve, 1500));
+      const secondRequest = makeProductSearchRequest();
+      await new Promise(resolve => setTimeout(resolve, 50));
+
+      releasePluginFetches.forEach(releasePluginFetch => releasePluginFetch());
+      const results = await Promise.all([firstRequest, secondRequest]);
+
+      results.forEach(result => {
+        expect(result.products).toEqual(slowProducts);
+      });
+      expect(lockTestPlugin.searchProducts).toHaveBeenCalledTimes(1);
+      expect(addJob).not.toHaveBeenCalled();
+      expect(expireIfValueSpy).toHaveBeenCalled();
+    } finally {
+      expireIfValueSpy.mockRestore();
+      if (originalLockTtl === undefined) {
+        delete process.env.PRODUCT_SEARCH_LOCK_TTL_SECONDS;
+      } else {
+        process.env.PRODUCT_SEARCH_LOCK_TTL_SECONDS = originalLockTtl;
+      }
+    }
+  });
+
+  it('multiple concurrent requests with no cache should share an empty plugin result', async () => {
+    await clearProductSearchCache();
+
+    lockTestPlugin.searchProducts.mockReset();
+    const releasePluginFetches = [];
+    const pluginFetchStarted = new Promise(resolve => {
+      lockTestPlugin.searchProducts.mockImplementation(() => {
+        resolve();
+        return new Promise(pluginResolve => {
+          releasePluginFetches.push(() => pluginResolve({ products: [] }));
+        });
+      });
+    });
+
+    const requestPromises = [makeProductSearchRequest(), makeProductSearchRequest(), makeProductSearchRequest()];
+    await pluginFetchStarted;
+    await new Promise(resolve => setTimeout(resolve, 50));
+
+    releasePluginFetches.forEach(releasePluginFetch => releasePluginFetch());
+    const results = await Promise.all(requestPromises);
+
+    results.forEach(result => {
+      expect(result.products).toEqual([]);
+    });
+    expect(lockTestPlugin.searchProducts).toHaveBeenCalledTimes(1);
+    expect(addJob).not.toHaveBeenCalled();
+  });
+
+  it('multiple concurrent requests with no cache should fail when the leader throws', async () => {
+    await clearProductSearchCache();
+
+    lockTestPlugin.searchProducts.mockReset();
+    let rejectPluginFetch;
+    const pluginFetchStarted = new Promise(resolve => {
+      lockTestPlugin.searchProducts.mockImplementation(() => {
+        resolve();
+        return new Promise((_, reject) => {
+          rejectPluginFetch = () => reject(new Error('boom'));
+        });
+      });
+    });
+
+    const requestPromises = [makeProductSearchRequest(), makeProductSearchRequest(), makeProductSearchRequest()]
+      .map(requestPromise => requestPromise
+        .then(result => ({ status: 'fulfilled', result }))
+        .catch(error => ({ status: 'rejected', error })));
+    await pluginFetchStarted;
+    await new Promise(resolve => setTimeout(resolve, 50));
+
+    rejectPluginFetch();
+    const results = await Promise.all(requestPromises);
+
+    results.forEach(result => {
+      expect(result.status).toBe('rejected');
+    });
+    expect(lockTestPlugin.searchProducts).toHaveBeenCalledTimes(1);
+    expect(addJob).not.toHaveBeenCalled();
+
+    const statuses = results.map(result => result.error.response.status).sort();
+    expect(statuses).toEqual([500, 503, 503]);
+  });
+});

package/controllers/__tests__/bookings.js

@@ -170,6 +170,59 @@ describe('user: bookings controller', () => {
     expect(plugins[0].createBooking.mock.calls[0][0].payload).toEqual(payload);
     expect(plugins[0].createBooking.mock.calls[0][0].token).toEqual(token);
   });
+  it('should be able to confirm a booking (with hint)', async () => {
+    const payload = {
+      bookingId: '14226',
+    };
+    await doApiPost({
+      url: `/bookings/${appKey}/${userId}/testingToken/confirm`,
+      token: userToken,
+      payload,
+    });
+    expect(plugins[0].confirmBooking).toHaveBeenCalled();
+    expect(plugins[0].confirmBooking.mock.calls[0][0].payload).toEqual(payload);
+    expect(plugins[0].confirmBooking.mock.calls[0][0].token).toEqual(token);
+  });
+  it('should be able to confirm a booking (no hint)', async () => {
+    const payload = {
+      bookingId: '14226',
+    };
+    await doApiPost({
+      url: `/bookings/${appKey}/${userId}/confirm`,
+      token: userToken,
+      payload,
+    });
+    expect(plugins[0].confirmBooking).toHaveBeenCalled();
+    expect(plugins[0].confirmBooking.mock.calls[0][0].payload).toEqual(payload);
+    expect(plugins[0].confirmBooking.mock.calls[0][0].token).toEqual(token);
+  });
+  it('should emit cancelBooking operation metadata when cancelling', async () => {
+    const payload = {
+      bookingId: chance.guid(),
+    };
+    const emitSpy = jest.spyOn(plugins[0].events, 'emit');
+    try {
+      await doApiPost({
+        url: `/bookings/${appKey}/${userId}/testingToken/cancel`,
+        token: userToken,
+        payload,
+      });
+      expect(plugins[0].cancelBooking).toHaveBeenCalled();
+      expect(plugins[0].cancelBooking.mock.calls[0][0].payload).toEqual(payload);
+      expect(plugins[0].cancelBooking.mock.calls[0][0].token).toEqual(token);
+      expect(emitSpy).toHaveBeenCalledWith(
+        'bookingsCancelBooking',
+        expect.objectContaining({
+          userId,
+          hint: 'testingToken',
+          operationId: 'cancelBooking',
+          pluginName: appKey,
+        }),
+      );
+    } finally {
+      emitSpy.mockRestore();
+    }
+  });
   it('should forward inline credentials directly to create booking', async () => {
     const payload = {
       id: chance.guid(),