ti2 1.0.95 → 1.0.96

package/controllers/__tests__/bookings.js

@@ -30,12 +30,17 @@ describe('user: bookings controller', () => {
   let doApiPost;
   let plugins;
   let userToken;
+  let appSetup;
+  let createUserToken;
+  
   beforeAll(async () => {
     ({
       doApiDelete,
       doApiGet,
       doApiPost,
       plugins,
+      appSetup,
+      createUserToken,
     } = await testUtils({
       plugins: [newApp.name],
     }));
@@ -55,40 +60,25 @@ describe('user: bookings controller', () => {
       pluginName: appKey,
       key: `${cacheKey}:lock`,
     });
-    // create the travelgate app and user
-    const { value: apiKey } = await doApiPost({
-      url: '/app',
-      token: adminKey,
-      payload: newApp,
-    });
-    expect(apiKey).toBeTruthy();
-
-    // Create the user token
-    ({ value: userToken } = await doApiPost({
-      url: '/user',
-      token: adminKey,
-      payload: { userId },
-    }));
+    
+    // Create user token
+    userToken = createUserToken(userId);
     expect(userToken).toBeTruthy();
-    // Create the user first, then get the token
+    
+    // Create the user
     await doApiPost({
       url: '/user',
-        token: adminKey,
-        payload: { userId, email: `${userId}@example.com` },
-      });
-      // Now get the token
-      ({ value: userToken } = await doApiPost({
-        url: '/user',
-        token: adminKey,
-        payload: { userId },
-      }));
-      expect(userToken).toBeTruthy();
+      token: adminKey,
+      payload: { userId, email: `${userId}@example.com` },
+    });
+    
     // create the travelGage+User setup
     let userAppKeys = [];
     ({ userAppKeys } = await doApiGet({
       url: `/user/${userId}/apps`,
       token: userToken,
     }));
+    
     // Check if we need to create the integration
     if (!userAppKeys.find(e => e.hint === newIntegration.tokenHint
       && e.integrationId === newApp.name)) {
@@ -96,268 +86,30 @@ describe('user: bookings controller', () => {
       const { value } = await doApiPost({
         url: `/${appKey}/${userId}`,
         token: userToken,
-          payload: newIntegration,
-        });
-        expect(value).toBeTruthy();
-      }
+        payload: newIntegration,
+      });
+      expect(value).toBeTruthy();
+    }
   });
   beforeEach(async () => {
     jest.clearAllMocks();
   });
-  it('should be able to search a for a booking', async () => {
-    const payload = {
-      bookingId: '', supplierBookingId: '', name: '',
-    };
-    const { bookings } = await doApiPost({
-      url: `/bookings/${appKey}/${userId}/testingToken/search`,
-      token: userToken,
-      payload,
-    });
-    expect(plugins[0].searchHotelBooking).toHaveBeenCalled();
-    expect(Array.isArray(bookings)).toBeTruthy();
-    expect(plugins[0].searchHotelBooking.mock.calls[0][0].payload).toEqual(payload);
-    expect(plugins[0].searchHotelBooking.mock.calls[0][0].token).toEqual(token);
-
-    // expect(Array.isArray(retVal.bookings)).toBeTruthy();
-    // expect(retVal.bookings.length > 0).toBeTruthy();
-  });
-
-  describe('searchProducts', () => {
-    it('should be able to get bookings products for most users without special setup: no cache', async () => {
-      const payload = {};
-      const { products } = await doApiPost({
-        url: `/products/${appKey}/${userId}/testingToken/search`,
-        token: userToken,
-        payload,
-      });
-      expect(plugins[0].searchProducts).toHaveBeenCalled();
-      expect(Array.isArray(products)).toBeTruthy();
-      expect(products.length).toBe(2);
-      expect(products[0].options.length).toBe(1);
-      expect(products[1].options.length).toBe(2);
-    });
-    it('should be able to get booking products: no cache, forceRefresh', async () => {
-      // NOTE: we need to remove the cache first
-      const cacheKey = hash({
-        appKey,
-        userId,
-        hint: 'testingToken',
-        operationId: 'bookingsProductSearch',
-      });
-      await cache.drop({
-        pluginName: appKey,
-        key: cacheKey,
-      });
+  describe('bookings', ()=> {
+    it('should be able to search a for a booking', async () => {
       const payload = {
-        forceRefresh: true,
+        bookingId: '', supplierBookingId: '', name: '',
       };
-      const { products } = await doApiPost({
-        url: `/products/${appKey}/${userId}/testingToken/search`,
+      const { bookings } = await doApiPost({
+        url: `/bookings/${appKey}/${userId}/testingToken/search`,
         token: userToken,
         payload,
       });
-      expect(plugins[0].searchProducts).toHaveBeenCalled();
-      expect(Array.isArray(products)).toBeTruthy();
-      expect(products.length).toBe(2);
-      expect(products[0].options.length).toBe(1);
-      expect(products[1].options.length).toBe(2);
-      expect(plugins[0].searchProducts.mock.calls[0][0].token).toEqual(token);
+      expect(plugins[0].searchHotelBooking).toHaveBeenCalled();
+      expect(Array.isArray(bookings)).toBeTruthy();
+      expect(plugins[0].searchHotelBooking.mock.calls[0][0].payload).toEqual(payload);
+      expect(plugins[0].searchHotelBooking.mock.calls[0][0].token).toEqual(token);
     });
-    it('should be able to get booking products: using cache', async () => {
-      const payload = {};
-      const { products } = await doApiPost({
-        url: `/products/${appKey}/${userId}/testingToken/search`,
-        token: userToken,
-        payload,
-      });
-      expect(plugins[0].searchProducts).not.toHaveBeenCalled();
-      expect(Array.isArray(products)).toBeTruthy();
-      expect(products.length).toBe(2);
-      expect(products[0].options.length).toBe(1);
-      expect(products[1].options.length).toBe(2);
-    });
-    it('should be able to get booking products with searchInput', async () => {
 
-      const payload = {
-        searchInput: 'Transfer from Sydney Harbor to Hilton Hotel',
-      };
-      const { products } = await doApiPost({
-        url: `/products/${appKey}/${userId}/testingToken/search`,
-        token: userToken,
-        payload,
-      });
-      expect(plugins[0].searchProducts).not.toHaveBeenCalled();
-      expect(Array.isArray(products)).toBeTruthy();
-      expect(products.length).toBe(1);
-      expect(products[0].productName).toBe('Davids');
-      expect(products[0].options.length).toBe(1);
-      expect(products[0].options[0].optionName).toBe('Transfer from Sydney Harbor Bridge to Hilton Hotel');
-    });
-    it('should be able to process doNotCallPluginForProducts in token', async () => {
-      const { userAppKeys } = await doApiGet({
-        url: `/user/${userId}/apps`,
-        token: userToken,
-      });
-      let newnewIntegration = userAppKeys.find(e => e.hint === 'hint_for_doNotCallPluginForProducts'
-        && e.integrationId === newApp.name);
-      if (!newnewIntegration) {
-        const newIntegrationContent = {
-          endpoint: 'https://api.travelgatex.com',
-          apiKey: chance.guid(),
-          client: 'tourconnect',
-          doNotCallPluginForProducts: true,
-        };
-        // create a new user token with the new content
-        newnewIntegration = await doApiPost({
-          url: `/travelgate/${userId}`,
-          token: adminKey,
-          payload: {
-            token: newIntegrationContent,
-            tokenHint: 'hint_for_doNotCallPluginForProducts',
-          },
-        });
-      }
-      expect(newnewIntegration).toBeTruthy();
-      // first time call, no cache expect no plugin call and empty products
-      let products;
-      await doApiPost({
-        url: `/products/${appKey}/${userId}/hint_for_doNotCallPluginForProducts/search`,
-        token: userToken,
-        payload: {},
-      }).then(({ products: p }) => {
-        products = p;
-      });
-      expect(plugins[0].searchProducts).not.toHaveBeenCalled();
-      expect(Array.isArray(products)).toBeTruthy();
-      expect(products.length).toBe(0);
-      // second time call, forceRefresh and still expect plugin call
-      await doApiPost({
-        url: `/products/${appKey}/${userId}/hint_for_doNotCallPluginForProducts/search`,
-        token: userToken,
-        payload: { forceRefresh: true },
-      }).then(({ products: p }) => {
-        products = p;
-      });
-      expect(plugins[0].searchProducts).toHaveBeenCalled();
-      expect(Array.isArray(products)).toBeTruthy();
-      expect(products.length).toBe(2);
-    });
-
-    describe('cache TTR and lock mechanism', () => {
-      const shortTTRToken = {
-        endpoint: 'https://api.travelgatex.com',
-        apiKey: chance.guid(),
-        client: 'tourconnect',
-        ttlForProducts: 2, // 2 seconds TTR
-      };
-      beforeAll(async () => {
-        await doApiPost({
-          url: `/${appKey}/${userId}`,
-          token: userToken,
-          payload: {
-            tokenHint: 'ttr-test',
-            token: shortTTRToken,
-          },
-        });
-      });
-      beforeEach(async () => {
-        jest.clearAllMocks();
-      });
-
-      it('should use cache within TTR period', async () => {
-        await doApiPost({
-          url: `/products/${appKey}/${userId}/ttr-test/search`,
-          token: userToken,
-          payload: {},
-        });
-        expect(plugins[0].searchProducts).toHaveBeenCalledTimes(1);
-
-        // Second immediate call should use cache
-        await doApiPost({
-          url: `/products/${appKey}/${userId}/ttr-test/search`,
-          token: userToken,
-          payload: {},
-        });
-        expect(plugins[0].searchProducts).toHaveBeenCalledTimes(1); // Still 1, used cache
-      });
-
-      it('should refresh cache after TTR expires', async () => {
-        // Wait for TTR to expire (2 seconds + buffer) so the cache from previous test is stale
-        await new Promise(resolve => {
-          setTimeout(resolve, 2100);
-        });
-
-        // First call to populate cache
-        await doApiPost({
-          url: `/products/${appKey}/${userId}/ttr-test/search`,
-          token: userToken,
-          payload: {},
-        });
-        expect(plugins[0].searchProducts).toHaveBeenCalledTimes(1);
-
-        // Wait for TTR to expire (2 seconds + buffer)
-        await new Promise(resolve => {
-          setTimeout(resolve, 2100);
-        });
-
-        // Call after TTR expired should hit the plugin again
-        await doApiPost({
-          url: `/products/${appKey}/${userId}/ttr-test/search`,
-          token: userToken,
-          payload: {},
-        });
-        expect(plugins[0].searchProducts).toHaveBeenCalledTimes(2);
-      });
-
-      it('should use lock mechanism to prevent concurrent calls', async () => {
-        // Wait for TTR to expire (2 seconds + buffer) so the cache from previous test is stale
-        await new Promise(resolve => {
-          setTimeout(resolve, 2100);
-        });
-
-        // Make multiple requests with slight delays to simulate real-world concurrent requests
-        const makeRequest = () => doApiPost({
-          url: `/products/${appKey}/${userId}/ttr-test/search`,
-          token: userToken,
-          payload: {},
-        });
-
-        // Start first request
-        const request1 = makeRequest();
-        // Start second request after 10ms
-        await new Promise(resolve => {
-          setTimeout(resolve, 10);
-        });
-        const request2 = makeRequest();
-        // Start third request after another 10ms
-        await new Promise(resolve => {
-          setTimeout(resolve, 10);
-        });
-        const request3 = makeRequest();
-
-        // Wait for all requests to complete
-        const results = await Promise.all([request1, request2, request3]);
-
-        // All requests should return valid products
-        results.forEach(({ products }) => {
-          expect(Array.isArray(products)).toBeTruthy();
-          expect(products.length).toBe(2); // Based on existing test expectations
-        });
-
-        // Plugin should only be called once due to lock mechanism, and with correct context
-        expect(plugins[0].searchProducts).toHaveBeenCalledWith(
-          expect.objectContaining({
-            token: expect.objectContaining({
-              client: 'tourconnect',
-              endpoint: expect.stringContaining('https://api.travelgatex.com'),
-            }),
-            userId: expect.stringContaining(userId),
-            payload: {},
-            typeDefsAndQueries: expect.any(Object)
-          })
-        );
-      });
-    });
   });
 
   it('should be able to search for availabiility', async () => {

package/controllers/app.js

@@ -142,25 +142,28 @@ const createAppToken = async (req, res, next) => {
           if (existing) {
             const bullJob = await queue.getJob(job.bullJobId);
             if (!bullJob) {
-              bullJobId = await addJob(jobPayload, jobParams);
-              existing.bullJobId = bullJobId;
+              let rawBullJobId = await addJob(jobPayload, jobParams);
+              existing.bullJobId = (rawBullJobId && typeof rawBullJobId === 'object' && rawBullJobId.id) ? rawBullJobId.id : rawBullJobId;
               await existing.save();
             } else {
               // make sure the cron is the same
+              // bullJobId here is from existing.bullJobId, which should be a string.
+              // The queue.getJob expects a string ID.
               const bullCron = R.path(
                 ['opts', 'repeat', 'cron'],
-                await queue.getJob(bullJobId),
+                await queue.getJob(existing.bullJobId), // Use existing.bullJobId
               );
               if (bullCron !== job.cron) {
-                await queue.removeJobs(bullJobId);
-                bullJobId = await addJob(jobPayload, jobParams);
-                existing.bullJobId = bullJobId;
+                await queue.removeJobs(existing.bullJobId); // Use existing.bullJobId
+                let rawBullJobId = await addJob(jobPayload, jobParams);
+                existing.bullJobId = (rawBullJobId && typeof rawBullJobId === 'object' && rawBullJobId.id) ? rawBullJobId.id : rawBullJobId;
                 await existing.save();
               }
             }
           } else {
-            bullJobId = await addJob(jobPayload, jobParams);
-            await sqldb.CronJobs.create({ ...where, bullJobId });
+            let rawBullJobId = await addJob(jobPayload, jobParams);
+            const actualBullJobId = (rawBullJobId && typeof rawBullJobId === 'object' && rawBullJobId.id) ? rawBullJobId.id : rawBullJobId;
+            await sqldb.CronJobs.create({ ...where, bullJobId: actualBullJobId });
           }
         });
       }