[FSSDK-10439] client provider test (#278)

* [FSSDK-10439] provider test cleanup

* [FSSDK-10439] client test deprecated API update

* [FSSDK-10439] client test: onReady, isReady, onUserUpdate, createInstance update

* [FSSDK-10439] client test: getIsReadyPromiseFulfilled, getIsUsingSdkKey

* [FSSDK-10439] client test: activate

* [FSSDK-10439] client test: getVariation, getFeatureVariableString

* [FSSDK-10439] client test: feature variable test case update

* [FSSDK-10439] client test: feature variable test case update 2

* [FSSDK-10439] client test: track method test update

* [FSSDK-10439] client test restructured complete

* [FSSDK-10439] missing testcases added

* [FSSDK-10439] improving existing testcases - feature, decide

* [FSSDK-10439] testcase addition for decideForKeys, fetchQualifiedSegments

* [FSSDK-10439] adding remaining coverage for client

* [FSSDK-10439] provider coverage increased

* [FSSDK-10439] adding spaces

Author: junaed-optimizely

.gitignore

@@ -12,3 +12,4 @@ build/
 
 # test artifacts
 **.tgz
+coverage/

src/Provider.spec.tsx

@@ -16,80 +16,134 @@
 
 /// <reference types="jest" />
 
-//jest.mock('./client');
-
 import React from 'react';
-import { render, act } from '@testing-library/react';
+import { render, waitFor } from '@testing-library/react';
 import { OptimizelyProvider } from './Provider';
-import { DefaultUser, ReactSDKClient, createInstance } from './client';
+import { DefaultUser, ReactSDKClient } from './client';
+import { getLogger } from '@optimizely/optimizely-sdk';
+
+jest.mock('@optimizely/optimizely-sdk', () => {
+  const originalModule = jest.requireActual('@optimizely/optimizely-sdk');
+  return {
+    ...originalModule,
+    getLogger: jest.fn().mockReturnValue({
+      error: jest.fn(),
+      warn: jest.fn(),
+      info: jest.fn(),
+      debug: jest.fn(),
+    }),
+  };
+});
+
+const logger = getLogger('<OptimizelyProvider>');
 
 describe('OptimizelyProvider', () => {
   let mockReactClient: ReactSDKClient;
-  const config = {
-    datafile: {},
+  const user1 = {
+    id: 'user1',
+    attributes: { attr1: 'value1' },
   };
-
   beforeEach(() => {
     mockReactClient = {
-      user: {
-        id: 'test-id',
-        attributes: {},
-      },
+      user: user1,
       setUser: jest.fn().mockResolvedValue(undefined),
     } as unknown as ReactSDKClient;
   });
 
+  it('should log error if optimizely is not provided', async () => {
+    // @ts-ignore
+    render(<OptimizelyProvider optimizely={null} />);
+    expect(logger.error).toHaveBeenCalled();
+  });
+
+  it('should resolve user promise and set user in optimizely', async () => {
+    render(<OptimizelyProvider optimizely={mockReactClient} user={Promise.resolve(user1)} />);
+    await waitFor(() => expect(mockReactClient.setUser).toHaveBeenCalledWith(user1));
+  });
+
   it('should render successfully with user provided', () => {
-    act(() => {
-      render(<OptimizelyProvider optimizely={mockReactClient} user={{ id: 'user1' }} />);
-    });
+    render(<OptimizelyProvider optimizely={mockReactClient} user={user1} />);
 
-    expect(mockReactClient.setUser).toHaveBeenCalledWith({
-      id: 'user1',
-      attributes: {},
-    });
+    expect(mockReactClient.setUser).toHaveBeenCalledWith(user1);
+  });
+
+  it('should throw error, if setUser throws error', () => {
+    mockReactClient.setUser = jest.fn().mockRejectedValue(new Error('error'));
+    render(<OptimizelyProvider optimizely={mockReactClient} user={user1} />);
+    expect(logger.error).toHaveBeenCalled();
   });
 
   it('should render successfully with userId provided', () => {
-    act(() => {
-      render(<OptimizelyProvider optimizely={mockReactClient} userId="user1" />);
-    });
+    render(<OptimizelyProvider optimizely={mockReactClient} userId={user1.id} />);
 
     expect(mockReactClient.setUser).toHaveBeenCalledWith({
-      id: 'user1',
+      id: user1.id,
       attributes: {},
     });
   });
 
   it('should render successfully without user or userId provided', () => {
-    act(() => {
-      render(<OptimizelyProvider optimizely={mockReactClient} />);
-    });
+    render(<OptimizelyProvider optimizely={mockReactClient} />);
 
     expect(mockReactClient.setUser).toHaveBeenCalledWith(DefaultUser);
   });
 
   it('should render successfully with user id & attributes provided', () => {
-    act(() => {
-      render(
-        <OptimizelyProvider optimizely={mockReactClient} user={{ id: 'user1', attributes: { attr1: 'value1' } }} />
-      );
-    });
+    render(<OptimizelyProvider optimizely={mockReactClient} user={user1} />);
 
-    expect(mockReactClient.setUser).toHaveBeenCalledWith({
-      id: 'user1',
-      attributes: { attr1: 'value1' },
-    });
+    expect(mockReactClient.setUser).toHaveBeenCalledWith(user1);
   });
 
   it('should succeed just userAttributes provided', () => {
-    act(() => {
-      render(<OptimizelyProvider optimizely={mockReactClient} userAttributes={{ attr1: 'value1' }} />);
-    });
+    render(<OptimizelyProvider optimizely={mockReactClient} userAttributes={{ attr1: 'value1' }} />);
 
     expect(mockReactClient.setUser).toHaveBeenCalledWith({
       id: DefaultUser.id,
       attributes: { attr1: 'value1' },
     });
   });
+
+  it('should not update when isServerSide is true', () => {
+    // Initial render
+    const { rerender } = render(<OptimizelyProvider optimizely={mockReactClient} isServerSide={true} user={user1} />);
+
+    // Reset mock to clear the initial constructor call
+    (mockReactClient.setUser as jest.Mock).mockClear();
+
+    // Re-render with same `isServerSide` value
+    rerender(<OptimizelyProvider optimizely={mockReactClient} isServerSide={true} user={user1} />);
+
+    expect(mockReactClient.setUser).not.toHaveBeenCalled();
+  });
+
+  it('should set user if optimizely.user.id is not set', () => {
+    mockReactClient.user = { id: '', attributes: {} };
+    const { rerender } = render(<OptimizelyProvider optimizely={mockReactClient} />);
+
+    // Change props to trigger componentDidUpdate
+    rerender(<OptimizelyProvider optimizely={mockReactClient} user={user1} />);
+
+    expect(mockReactClient.setUser).toHaveBeenCalledWith(user1);
+  });
+
+  it('should update user if users are not equal', () => {
+    const user2 = { id: 'user-2', attributes: {} };
+
+    const { rerender } = render(<OptimizelyProvider optimizely={mockReactClient} user={user1} />);
+
+    // Change props to a different user to trigger componentDidUpdate
+    rerender(<OptimizelyProvider optimizely={mockReactClient} user={user2} />);
+
+    expect(mockReactClient.setUser).toHaveBeenCalledWith(user2);
+  });
+
+  it('should not update user if users are equal', () => {
+    const { rerender } = render(<OptimizelyProvider optimizely={mockReactClient} user={user1} />);
+    // Reset mock to clear the initial constructor call
+    (mockReactClient.setUser as jest.Mock).mockClear();
+    // Change props with the same user to trigger componentDidUpdate
+    rerender(<OptimizelyProvider optimizely={mockReactClient} user={user1} />);
+
+    expect(mockReactClient.setUser).not.toHaveBeenCalled();
+  });
 });

src/Provider.tsx

@@ -17,8 +17,6 @@
 import * as React from 'react';
 import { UserAttributes } from '@optimizely/optimizely-sdk';
 import { getLogger } from '@optimizely/optimizely-sdk';
-
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 import { OptimizelyContextProvider } from './Context';
 import { ReactSDKClient, DefaultUser } from './client';
 import { areUsersEqual, UserInfo } from './utils';