Merge pull request #19323 from mozilla/fxa-12253

feat(l10n): Update backend to return localized strapi data

Author: vbudhram

.gitignore

@@ -37,6 +37,8 @@ secrets.json
 .es5
 .es5cache
 /artifacts
+**/artifacts
+**/.nx/cache/**/artifacts
 .last-audit
 .eslintcache
 storybooks-publish
@@ -60,6 +62,7 @@ coverage.html
 **/coverage
 **/.nyc_output
 test-results.xml
+**/artifacts/tests/**/*.xml
 
 # Local configuration
 /_dev/firebase/.config

libs/shared/cms/src/lib/relying-party-configuration.manager.spec.ts

@@ -7,9 +7,13 @@ import { StatsD } from 'hot-shots';
 import { DocumentNode } from 'graphql';
 
 import { StatsDService } from '@fxa/shared/metrics/statsd';
-import { relyingPartyQuery, RelyingPartyConfigurationManager } from '../../src';
+import { relyingPartyQuery } from '../../src';
+import { RelyingPartyConfigurationManager } from './relying-party-configuration.manager';
 import { StrapiClient, StrapiClientEventResponse } from './strapi.client';
 import { RelyingPartyQueryFactory } from './queries/relying-party/factories';
+import { MockFirestoreProvider } from '@fxa/shared/db/firestore';
+import { MockStrapiClientConfigProvider } from './strapi.client.config';
+import { LOGGER_PROVIDER } from '@fxa/shared/log';
 
 jest.mock('@type-cacheable/core', () => {
   const noopDecorator =
@@ -55,6 +59,7 @@ describe('RelyingPartyConfigurationManager', () => {
   let relyingPartyConfigurationManager: RelyingPartyConfigurationManager;
   let mockStrapiClient: jest.Mocked<StrapiClient>;
   let mockStatsd: jest.Mocked<StatsD>;
+  let mockWinstonLogger: any;
 
   beforeEach(async () => {
     mockStatsd = {
@@ -70,17 +75,30 @@ describe('RelyingPartyConfigurationManager', () => {
       invalidateQueryCache: jest.fn(),
     } as any;
 
+    mockWinstonLogger = {
+      error: jest.fn(),
+      warn: jest.fn(),
+      info: jest.fn(),
+      debug: jest.fn(),
+    } as any;
+
     const module = await Test.createTestingModule({
       providers: [
         RelyingPartyConfigurationManager,
+        MockStrapiClientConfigProvider,
+        MockFirestoreProvider,
         { provide: StatsDService, useValue: mockStatsd },
         { provide: StrapiClient, useValue: mockStrapiClient },
+        { provide: LOGGER_PROVIDER, useValue: mockWinstonLogger },
       ],
     }).compile();
 
     relyingPartyConfigurationManager = module.get(
       RelyingPartyConfigurationManager
     );
+
+    // Get the mock StatsD service from the module
+    mockStatsd = module.get(StatsDService);
   });
 
   afterEach(() => {
@@ -156,7 +174,8 @@ describe('RelyingPartyConfigurationManager', () => {
   describe('fetchCMSData', () => {
     it('should call StrapiClient.query with correct arguments and return data', async () => {
       const mockData = RelyingPartyQueryFactory();
-      const { clientId, entrypoint } = mockData.relyingParties[0];
+      const clientId = 'test-client-id';
+      const entrypoint = 'test-entrypoint';
 
       mockStrapiClient.query.mockResolvedValue(mockData);
 
@@ -186,7 +205,7 @@ describe('RelyingPartyConfigurationManager', () => {
   });
 
   describe('invalidateCache', () => {
-    it('should call StrapiClient.invalidateCache', async () => {
+    it('should call StrapiClient.invalidateQueryCache with correct parameters', async () => {
       const clientId = 'test-client-id';
       const entrypoint = 'test-entrypoint';
 
@@ -200,4 +219,153 @@ describe('RelyingPartyConfigurationManager', () => {
       );
     });
   });
+
+  describe('getFtlContent', () => {
+    // Mock global fetch for these tests
+    const mockFetch = jest.fn();
+    global.fetch = mockFetch;
+
+    beforeEach(() => {
+      mockFetch.mockClear();
+    });
+
+    it('should fetch FTL content from URL successfully', async () => {
+      const locale = 'en';
+      const config = {
+        cmsl10n: {
+          ftlUrl: {
+            template: 'https://example.com/locales/{locale}/cms.ftl',
+            timeout: 5000,
+          },
+        },
+      };
+      const ftlContent = 'test FTL content';
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        text: () => Promise.resolve(ftlContent),
+      });
+
+      const result = await relyingPartyConfigurationManager.getFtlContent(locale, config);
+
+      expect(result).toBe(ftlContent);
+      expect(mockFetch).toHaveBeenCalledWith(
+        'https://example.com/locales/en/cms.ftl',
+        {
+          headers: { Accept: 'text/plain' },
+          signal: expect.any(AbortSignal),
+        }
+      );
+    });
+
+    it('should return empty string when URL is not configured', async () => {
+      const locale = 'en';
+      const config = {
+        cmsl10n: {
+          ftlUrl: {
+            template: '',
+            timeout: 5000,
+          },
+        },
+      };
+
+      const result = await relyingPartyConfigurationManager.getFtlContent(locale, config);
+
+      expect(result).toBe('');
+      expect(mockFetch).not.toHaveBeenCalled();
+    });
+
+    it('should return empty string when fetch returns 404', async () => {
+      const locale = 'fr';
+      const config = {
+        cmsl10n: {
+          ftlUrl: {
+            template: 'https://example.com/locales/{locale}/cms.ftl',
+            timeout: 5000,
+          },
+        },
+      };
+
+      mockFetch.mockResolvedValue({
+        ok: false,
+        status: 404,
+      });
+
+      const result = await relyingPartyConfigurationManager.getFtlContent(locale, config);
+
+      expect(result).toBe('');
+    });
+
+    it('should handle fetch errors and emit metrics', async () => {
+      const locale = 'en';
+      const config = {
+        cmsl10n: {
+          ftlUrl: {
+            template: 'https://example.com/locales/{locale}/cms.ftl',
+            timeout: 5000,
+          },
+        },
+      };
+
+      mockFetch.mockRejectedValue(new Error('Network error'));
+
+      await expect(
+        relyingPartyConfigurationManager.getFtlContent(locale, config)
+      ).rejects.toThrow('Network error');
+
+      // Verify metrics are emitted for errors
+      expect(mockStatsd.timing).toHaveBeenCalledWith(
+        'cms_ftl_request',
+        expect.any(Number),
+        undefined,
+        {
+          method: 'getFtlContent',
+          error: 'true',
+          cache: 'false',
+          locale,
+        }
+      );
+    });
+  });
+
+  describe('invalidateFtlCache', () => {
+    it('should exist as a method and complete without error', async () => {
+      const locale = 'en';
+
+      // The method exists and can be called, but the actual cache clearing
+      // is handled by the @CacheClear decorators
+      await expect(
+        relyingPartyConfigurationManager.invalidateFtlCache(locale)
+      ).resolves.toBeUndefined();
+    });
+  });
+
+  describe('integration with StrapiClient events', () => {
+    it('should handle FTL-related response events in metrics', () => {
+      const eventHandler = mockStrapiClient.on.mock.calls[0][1];
+
+      const ftlResponse: StrapiClientEventResponse = {
+        method: 'cacheFtl',
+        requestStartTime: 1000,
+        requestEndTime: 1100,
+        elapsed: 100,
+        cache: true,
+        cacheType: 'memory',
+      };
+
+      eventHandler(ftlResponse);
+
+      expect(mockStatsd.timing).toHaveBeenCalledWith(
+        'cms_accounts_request',
+        100,
+        undefined,
+        {
+          method: 'cacheFtl',
+          error: 'false',
+          cache: 'true',
+          cacheType: 'memory',
+        }
+      );
+    });
+  });
 });