Normalize empty preferred locale (#324)

Author: marcospassos

src/api/fetchContent.ts

@@ -46,14 +46,16 @@ export function fetchContent<I extends VersionedSlotId, C extends JsonObject>(
     const {apiKey, appId, fallback, baseEndpointUrl, logger, ...fetchOptions} = options ?? {};
     const auth = {appId: appId, apiKey: apiKey};
     const [id, version = 'latest'] = slotId.split('@') as [I, `${number}` | 'latest' | undefined];
+    const preferredLocale = options?.preferredLocale !== undefined && options.preferredLocale !== ''
+        ? options.preferredLocale
+        : undefined;
 
     const promise = (new ContentFetcher({...auth, baseEndpointUrl: baseEndpointUrl}))
-        .fetch<SlotContent<I, C>>(
-            id,
-            version === 'latest'
-                ? fetchOptions
-                : {...fetchOptions, version: version},
-        );
+        .fetch<SlotContent<I, C>>(id, {
+            ...fetchOptions,
+            preferredLocale: preferredLocale,
+            version: version === 'latest' ? undefined : version,
+        });
 
     return promise.catch(
         async error => {
@@ -65,7 +67,7 @@ export function fetchContent<I extends VersionedSlotId, C extends JsonObject>(
                 return {content: fallback};
             }
 
-            const staticContent = await loadSlotContent(id, (fetchOptions as DynamicContentOptions).preferredLocale);
+            const staticContent = await loadSlotContent(id, preferredLocale);
 
             if (staticContent === null) {
                 throw error;

src/plug.ts

@@ -149,6 +149,10 @@ export class GlobalPlug implements Plug {
 
         const {plugins, test, ...sdkConfiguration} = configuration;
 
+        if (sdkConfiguration.defaultPreferredLocale === '') {
+            delete sdkConfiguration.defaultPreferredLocale;
+        }
+
         const sdk = SdkFacade.init({
             ...sdkConfiguration,
             appId: appId,
@@ -383,15 +387,22 @@ export class GlobalPlug implements Plug {
     ): Promise<FetchResponse<I>> {
         const [id, version = 'latest'] = slotId.split('@') as [string, `${number}` | 'latest' | undefined];
         const logger = this.sdk.getLogger();
+        const preferredLocale = options.preferredLocale !== undefined && options.preferredLocale !== ''
+            ? options.preferredLocale
+            : undefined;
 
         return this.sdk
             .contentFetcher
-            .fetch<SlotContent<I>>(id, version === 'latest' ? options : {...options, version: version})
+            .fetch<SlotContent<I>>(id, {
+                ...options,
+                preferredLocale: preferredLocale,
+                version: version === 'latest' ? undefined : version,
+            })
             .catch(async error => {
                 logger.error(`Failed to fetch content for slot "${id}@${version}": ${formatCause(error)}`);
 
                 const resolvedFallback = fallback === undefined
-                    ? (await loadSlotContent(slotId, options.preferredLocale) as SlotContent<I>|null ?? undefined)
+                    ? (await loadSlotContent(slotId, preferredLocale) as SlotContent<I>|null ?? undefined)
                     : fallback;
 
                 if (resolvedFallback === undefined) {

test/api/fetchContent.test.ts

@@ -308,4 +308,25 @@ describe('fetchContent', () => {
 
         expect(logger.error).toHaveBeenCalledWith('Failed to fetch content for slot "test@latest": reason');
     });
+
+    it('should normalize an empty preferred locale to undefined', async () => {
+        const options: FetchOptions = {
+            apiKey: apiKey,
+            preferredLocale: '',
+        };
+
+        const error = new Error('Reason');
+
+        jest.mocked(mockFetch).mockRejectedValue(error);
+
+        jest.mocked(loadSlotContent).mockResolvedValue(null);
+
+        await expect(fetchContent('test', options)).rejects.toBe(error);
+
+        expect(loadSlotContent).toHaveBeenCalledWith('test', undefined);
+
+        expect(mockFetch).toHaveBeenCalledWith('test', {
+            preferredLocale: undefined,
+        });
+    });
 });

test/plug.test.ts

@@ -157,6 +157,33 @@ describe('The Croct plug', () => {
         expect(initialize).toHaveBeenCalledWith(config);
     });
 
+    it('should normalize an empty default preferred locale to undefined', () => {
+        const config: SdkFacadeConfiguration = {
+            appId: APP_ID,
+            track: false,
+            debug: false,
+            test: true,
+            tokenScope: 'isolated',
+            userId: 'c4r0l',
+            eventMetadata: {
+                foo: 'bar',
+            },
+        };
+
+        const sdkFacade = SdkFacade.init(config);
+        const initialize = jest.spyOn(SdkFacade, 'init').mockReturnValue(sdkFacade);
+
+        croct.plug({
+            ...config,
+            defaultPreferredLocale: '',
+        });
+
+        expect(initialize).toHaveBeenCalledWith({
+            ...config,
+            defaultPreferredLocale: undefined,
+        });
+    });
+
     it.each([
         'test',
         'development',
@@ -1055,6 +1082,45 @@ describe('The Croct plug', () => {
         );
     });
 
+    it('should normalize an empty locale to undefined', async () => {
+        const logger: Logger = {
+            debug: jest.fn(),
+            info: jest.fn(),
+            warn: jest.fn(),
+            error: jest.fn(),
+        };
+
+        const config: SdkFacadeConfiguration = {
+            appId: APP_ID,
+            logger: logger,
+        };
+
+        const sdkFacade = SdkFacade.init(config);
+
+        const initialize = jest.spyOn(SdkFacade, 'init').mockReturnValue(sdkFacade);
+
+        croct.plug(config);
+
+        expect(initialize).toHaveBeenCalledWith(expect.objectContaining(config));
+
+        const error = new Error('Reason');
+        const fetch = jest.spyOn(sdkFacade.contentFetcher, 'fetch').mockRejectedValue(error);
+
+        const slotId = 'test';
+
+        const options: FetchOptions = {preferredLocale: ''};
+
+        jest.mocked(loadSlotContent).mockResolvedValue(null);
+
+        await expect(croct.fetch(slotId, options)).rejects.toBe(error);
+
+        expect(fetch).toHaveBeenCalledWith(slotId, {
+            preferredLocale: undefined,
+        });
+
+        expect(loadSlotContent).toHaveBeenCalledWith(slotId, undefined);
+    });
+
     it('should extract the slot ID and version', async () => {
         const config: SdkFacadeConfiguration = {appId: APP_ID};
         const sdkFacade = SdkFacade.init(config);