[SDKS-6942][DW] Update tests and constants

Author: Emmanuel Zamora

src/SplitTreatments.tsx

@@ -13,7 +13,7 @@ function argsAreEqual(newArgs: any[], lastArgs: any[]): boolean {
     shallowEqual(newArgs[4], lastArgs[4]); // client attributes
 }
 
-function evaluateSplits(client: SplitIO.IBrowserClient, lastUpdate: number, names: SplitIO.SplitNames, attributes?: SplitIO.Attributes, _clientAttributes?: SplitIO.Attributes) {
+function evaluateFeatureFlags(client: SplitIO.IBrowserClient, lastUpdate: number, names: SplitIO.SplitNames, attributes?: SplitIO.Attributes, _clientAttributes?: SplitIO.Attributes) {
   return client.getTreatmentsWithConfig(names, attributes);
 }
 
@@ -29,7 +29,7 @@ class SplitTreatments extends React.Component<ISplitTreatmentsProps> {
 
   // Attaching a memoized `client.getTreatmentsWithConfig` function to the component instance, to avoid duplicated impressions because
   // the function result is the same given the same `client` instance, `lastUpdate` timestamp, and list of split `names` and `attributes`.
-  private evaluateSplits = memoizeOne(evaluateSplits, argsAreEqual);
+  private evaluateFeatureFlags = memoizeOne(evaluateFeatureFlags, argsAreEqual);
 
   render() {
     const { names, children, attributes } = this.props;
@@ -43,7 +43,7 @@ class SplitTreatments extends React.Component<ISplitTreatmentsProps> {
           if (client && isOperational) {
             // Cloning `client.getAttributes` result for memoization, because it returns the same reference unless `client.clearAttributes` is called.
             // Caveat: same issue happens with `names` and `attributes` props if the user follows the bad practice of mutating the object instead of providing a new one.
-            treatments = this.evaluateSplits(client, lastUpdate, names, attributes, { ...client.getAttributes() });
+            treatments = this.evaluateFeatureFlags(client, lastUpdate, names, attributes, { ...client.getAttributes() });
           } else {
             treatments = getControlTreatmentsWithConfig(names);
             if (!client) { this.logWarning = true; }

src/__tests__/SplitTreatments.test.tsx

@@ -31,17 +31,17 @@ describe('SplitTreatments', () => {
   afterEach(() => { logSpy.mockClear() });
 
   it('passes as treatments prop the value returned by the function "getControlTreatmentsWithConfig" if the SDK is not ready.', (done) => {
-    const splitNames = ['split1', 'split2'];
+    const featureFlagNames = ['split1', 'split2'];
     render(
       <SplitFactory config={sdkBrowser} >{
         ({ factory }) => {
           return (
             <SplitClient splitKey='user1' >
-              <SplitTreatments names={splitNames} >
+              <SplitTreatments names={featureFlagNames} >
                 {({ treatments }: ISplitTreatmentsChildProps) => {
                   const clientMock: any = factory?.client('user1');
                   expect(clientMock.getTreatmentsWithConfig.mock.calls.length).toBe(0);
-                  expect(treatments).toEqual(getControlTreatmentsWithConfig(splitNames));
+                  expect(treatments).toEqual(getControlTreatmentsWithConfig(featureFlagNames));
                   done();
                   return null;
                 }}
@@ -53,7 +53,7 @@ describe('SplitTreatments', () => {
   });
 
   it('passes as treatments prop the value returned by the method "client.getTreatmentsWithConfig" if the SDK is ready.', (done) => {
-    const splitNames = ['split1', 'split2'];
+    const featureFlagNames = ['split1', 'split2'];
     const outerFactory = SplitSdk(sdkBrowser);
     (outerFactory as any).client().__emitter__.emit(Event.SDK_READY);
 
@@ -63,12 +63,12 @@ describe('SplitTreatments', () => {
           expect(getStatus(outerFactory.client()).isReady).toBe(isReady);
           expect(isReady).toBe(true);
           return (
-            <SplitTreatments names={splitNames} >
+            <SplitTreatments names={featureFlagNames} >
               {({ treatments, isReady: isReady2, isReadyFromCache, hasTimedout, isTimedout, isDestroyed, lastUpdate }: ISplitTreatmentsChildProps) => {
                 const clientMock: any = factory?.client();
                 expect(clientMock.getTreatmentsWithConfig.mock.calls.length).toBe(1);
                 expect(treatments).toBe(clientMock.getTreatmentsWithConfig.mock.results[0].value);
-                expect(splitNames).toBe(clientMock.getTreatmentsWithConfig.mock.calls[0][0]);
+                expect(featureFlagNames).toBe(clientMock.getTreatmentsWithConfig.mock.calls[0][0]);
                 expect([isReady2, isReadyFromCache, hasTimedout, isTimedout, isDestroyed, lastUpdate]).toStrictEqual([true, false, false, false, false, 0]);
                 done();
                 return null;
@@ -80,17 +80,17 @@ describe('SplitTreatments', () => {
   });
 
   it('logs error and passes control treatments ("getControlTreatmentsWithConfig") if rendered outside an SplitProvider component.', () => {
-    const splitNames = ['split1', 'split2'];
+    const featureFlagNames = ['split1', 'split2'];
     let passedTreatments;
     render(
-      <SplitTreatments names={splitNames} >
+      <SplitTreatments names={featureFlagNames} >
         {({ treatments }: ISplitTreatmentsChildProps) => {
           passedTreatments = treatments;
           return null;
         }}
       </SplitTreatments>);
     expect(logSpy).toBeCalledWith(WARN_ST_NO_CLIENT);
-    expect(getControlTreatmentsWithConfig).toBeCalledWith(splitNames);
+    expect(getControlTreatmentsWithConfig).toBeCalledWith(featureFlagNames);
     expect(getControlTreatmentsWithConfig).toHaveReturnedWith(passedTreatments);
   });
 
@@ -99,22 +99,22 @@ describe('SplitTreatments', () => {
    * is not ready doesn't emit errors, and logs meaningful messages instead.
    */
   it('Input validation: invalid "names" and "attributes" props in SplitTreatments.', (done) => {
-    const splitNames = ['split1', 'split2'];
+    const featureFlagNames = ['split1', 'split2'];
 
     render(
       <SplitFactory config={sdkBrowser} >{
         () => {
           return (
             <>
               {/* @ts-expect-error Test error handling */}
-              <SplitTreatments split_names={splitNames} >
+              <SplitTreatments split_names={featureFlagNames} >
                 {({ treatments }: ISplitTreatmentsChildProps) => {
                   expect(treatments).toEqual({});
                   return null;
                 }}
               </SplitTreatments>
               {/* @ts-expect-error Test error handling */}
-              <SplitTreatments names={splitNames[0]} >
+              <SplitTreatments names={featureFlagNames[0]} >
                 {({ treatments }: ISplitTreatmentsChildProps) => {
                   expect(treatments).toEqual({});
                   return null;
@@ -186,28 +186,28 @@ describe('SplitTreatments optimization', () => {
     wrapper.unmount(); // unmount to remove event listener from factory
   })
 
-  it('rerenders but does not re-evaluate splits if client, lastUpdate, names and attributes are the same object.', () => {
+  it('rerenders but does not re-evaluate feature flags if client, lastUpdate, names and attributes are the same object.', () => {
     wrapper.rerender(<Component names={names} attributes={attributes} splitKey={splitKey} />);
 
     expect(renderTimes).toBe(2);
     expect(outerFactory.client().getTreatmentsWithConfig).toBeCalledTimes(1);
   });
 
-  it('rerenders but does not re-evaluate splits if client, lastUpdate, names and attributes are equals (shallow comparison).', () => {
+  it('rerenders but does not re-evaluate feature flags if client, lastUpdate, names and attributes are equals (shallow comparison).', () => {
     wrapper.rerender(<Component names={[...names]} attributes={{ ...attributes }} splitKey={splitKey} />);
 
     expect(renderTimes).toBe(2);
     expect(outerFactory.client().getTreatmentsWithConfig).toBeCalledTimes(1);
   });
 
-  it('rerenders and re-evaluates splits if names are not equals (shallow array comparison).', () => {
+  it('rerenders and re-evaluates feature flags if names are not equals (shallow array comparison).', () => {
     wrapper.rerender(<Component names={[...names, 'split3']} attributes={{ ...attributes }} splitKey={splitKey} />);
 
     expect(renderTimes).toBe(2);
     expect(outerFactory.client().getTreatmentsWithConfig).toBeCalledTimes(2);
   });
 
-  it('rerenders and re-evaluates splits if attributes are not equals (shallow object comparison).', () => {
+  it('rerenders and re-evaluates feature flags if attributes are not equals (shallow object comparison).', () => {
     const attributesRef = { ...attributes, att2: 'att2' };
     wrapper.rerender(<Component names={[...names]} attributes={attributesRef} splitKey={splitKey} />);
 
@@ -221,7 +221,7 @@ describe('SplitTreatments optimization', () => {
     expect(outerFactory.client().getTreatmentsWithConfig).toBeCalledTimes(2);
   });
 
-  it('rerenders and re-evaluates splits if lastUpdate timestamp changes (e.g., SDK_UPDATE event).', (done) => {
+  it('rerenders and re-evaluates feature flags if lastUpdate timestamp changes (e.g., SDK_UPDATE event).', (done) => {
     expect(renderTimes).toBe(1);
 
     // State update and split evaluation
@@ -243,7 +243,7 @@ describe('SplitTreatments optimization', () => {
     })
   });
 
-  it('rerenders and re-evaluates splits if client changes.', () => {
+  it('rerenders and re-evaluates feature flags if client changes.', () => {
     wrapper.rerender(<Component names={names} attributes={attributes} splitKey={'otherKey'} />);
     act(() => (outerFactory as any).client('otherKey').__emitter__.emit(Event.SDK_READY));
 
@@ -253,7 +253,7 @@ describe('SplitTreatments optimization', () => {
     expect(outerFactory.client('otherKey').getTreatmentsWithConfig).toBeCalledTimes(1);
   });
 
-  it('rerenders and re-evaluate splits when Split context changes (in both SplitFactory and SplitClient components).', async () => {
+  it('rerenders and re-evaluate splfeature flagsits when Split context changes (in both SplitFactory and SplitClient components).', async () => {
     // changes in SplitContext implies that either the factory, the client (user key), or its status changed, what might imply a change in treatments
     const outerFactory = SplitSdk(sdkBrowser);
     const names = ['split1', 'split2'];
@@ -327,7 +327,7 @@ describe('SplitTreatments optimization', () => {
     expect(outerFactory.client('user2').getTreatmentsWithConfig).toBeCalledTimes(4); // idem
   });
 
-  it('rerenders and re-evaluates splits if client attributes changes.', (done) => {
+  it('rerenders and re-evaluates feature flags if client attributes changes.', (done) => {
     const originalFactory = outerFactory;
     outerFactory = newSplitFactoryLocalhostInstance();
 

src/__tests__/constants.test.ts

@@ -8,12 +8,12 @@ describe('getControlTreatmentsWithConfig', () => {
   });
 
   it('should return an empty object if an empty array is provided', () => {
-    const splitNames = ['split1', 'split2'];
-    const treatments: SplitIO.TreatmentsWithConfig = getControlTreatmentsWithConfig(splitNames);
-    splitNames.forEach((splitName) => {
-      expect(treatments[splitName]).toBe(CONTROL_WITH_CONFIG);
+    const featureFlagNames = ['split1', 'split2'];
+    const treatments: SplitIO.TreatmentsWithConfig = getControlTreatmentsWithConfig(featureFlagNames);
+    featureFlagNames.forEach((featureFlagName) => {
+      expect(treatments[featureFlagName]).toBe(CONTROL_WITH_CONFIG);
     });
-    expect(Object.keys(treatments).length).toBe(splitNames.length);
+    expect(Object.keys(treatments).length).toBe(featureFlagNames.length);
   });
 
 });

src/__tests__/useTreatments.test.tsx

@@ -25,7 +25,7 @@ import useTreatments from '../useTreatments';
 
 describe('useTreatments', () => {
 
-  const splitNames = ['split1'];
+  const featureFlagNames = ['split1'];
   const attributes = { att1: 'att1' };
 
   test('returns the treatments evaluated by the client at Split context updated by SplitFactory, or control if the client is not operational.', () => {
@@ -36,7 +36,7 @@ describe('useTreatments', () => {
     render(
       <SplitFactory factory={outerFactory} >{
         React.createElement(() => {
-          treatments = useTreatments(splitNames, attributes);
+          treatments = useTreatments(featureFlagNames, attributes);
           return null;
         })}</SplitFactory>,
     );
@@ -45,10 +45,10 @@ describe('useTreatments', () => {
     expect(client.getTreatmentsWithConfig).not.toBeCalled();
     expect(treatments!).toEqual({ split1: CONTROL_WITH_CONFIG });
 
-    // once operational (SDK_READY), it evaluates splits
+    // once operational (SDK_READY), it evaluates feature flags
     act(() => client.__emitter__.emit(Event.SDK_READY));
 
-    expect(client.getTreatmentsWithConfig).toBeCalledWith(splitNames, attributes);
+    expect(client.getTreatmentsWithConfig).toBeCalledWith(featureFlagNames, attributes);
     expect(client.getTreatmentsWithConfig).toHaveReturnedWith(treatments);
   });
 
@@ -61,7 +61,7 @@ describe('useTreatments', () => {
       <SplitFactory factory={outerFactory} >
         <SplitClient splitKey='user2' >{
           React.createElement(() => {
-            treatments = useTreatments(splitNames, attributes);
+            treatments = useTreatments(featureFlagNames, attributes);
             return null;
           })}
         </SplitClient>
@@ -72,10 +72,10 @@ describe('useTreatments', () => {
     expect(client.getTreatmentsWithConfig).not.toBeCalled();
     expect(treatments!).toEqual({ split1: CONTROL_WITH_CONFIG });
 
-    // once operational (SDK_READY_FROM_CACHE), it evaluates splits
+    // once operational (SDK_READY_FROM_CACHE), it evaluates feature flags
     act(() => client.__emitter__.emit(Event.SDK_READY_FROM_CACHE));
 
-    expect(client.getTreatmentsWithConfig).toBeCalledWith(splitNames, attributes);
+    expect(client.getTreatmentsWithConfig).toBeCalledWith(featureFlagNames, attributes);
     expect(client.getTreatmentsWithConfig).toHaveReturnedWith(treatments);
   });
 
@@ -90,7 +90,7 @@ describe('useTreatments', () => {
     render(
       <SplitFactory factory={outerFactory} >{
         React.createElement(() => {
-          treatments = useTreatments(splitNames, attributes, 'user2');
+          treatments = useTreatments(featureFlagNames, attributes, 'user2');
           return null;
         })}
       </SplitFactory>,
@@ -108,16 +108,16 @@ describe('useTreatments', () => {
     render(
       React.createElement(
         () => {
-          treatments = useTreatments(splitNames, attributes);
+          treatments = useTreatments(featureFlagNames, attributes);
           return null;
         }),
     );
-    expect(getControlTreatmentsWithConfig).toBeCalledWith(splitNames);
+    expect(getControlTreatmentsWithConfig).toBeCalledWith(featureFlagNames);
     expect(getControlTreatmentsWithConfig).toHaveReturnedWith(treatments);
   });
 
   /**
-   * Input validation. Passing invalid split names or attributes while the Sdk
+   * Input validation. Passing invalid feature flag names or attributes while the Sdk
    * is not ready doesn't emit errors, and logs meaningful messages instead.
    */
   test('Input validation: invalid "names" and "attributes" params in useTreatments.', (done) => {

src/__tests__/withSplitTreatments.test.tsx

@@ -20,17 +20,17 @@ describe('withSplitTreatments', () => {
   it(`passes Split props and outer props to the child.
       In this test, the value of "props.treatments" is obteined by the function "getControlTreatmentsWithConfig",
       and not "client.getTreatmentsWithConfig" since the client is not ready.`, (done) => {
-    const splitNames = ['split1', 'split2'];
+    const featureFlagNames = ['split1', 'split2'];
     const Component = withSplitFactory(sdkBrowser)<{ outerProp1: string, outerProp2: number }>(
       ({ outerProp1, outerProp2, factory }) => {
         const SubComponent = withSplitClient('user1')<{ outerProp1: string, outerProp2: number }>(
-          withSplitTreatments(splitNames)(
+          withSplitTreatments(featureFlagNames)(
             (props: ISplitTreatmentsChildProps & { outerProp1: string, outerProp2: number }) => {
               const clientMock = factory!.client('user1');
               expect(props.outerProp1).toBe('outerProp1');
               expect(props.outerProp2).toBe(2);
               expect((clientMock.getTreatmentsWithConfig as jest.Mock).mock.calls.length).toBe(0);
-              expect(props.treatments).toEqual(getControlTreatmentsWithConfig(splitNames));
+              expect(props.treatments).toEqual(getControlTreatmentsWithConfig(featureFlagNames));
               expect(props.isReady).toBe(false);
               expect(props.isReadyFromCache).toBe(false);
               expect(props.hasTimedout).toBe(false);

src/constants.ts

@@ -16,14 +16,14 @@ export const CONTROL_WITH_CONFIG: SplitIO.TreatmentWithConfig = {
 };
 
 export const getControlTreatmentsWithConfig = (splitNames: unknown): SplitIO.TreatmentsWithConfig => {
-  // validate split Names
-  const validatedSplitNames = validateFeatureFlags(splitNames);
+  // validate featureFlags Names
+  const validatedFeatureFlagNames = validateFeatureFlags(splitNames);
 
   // return empty object if the returned value is false
-  if (!validatedSplitNames) return {};
+  if (!validatedFeatureFlagNames) return {};
 
   // return control treatments for each validated split name
-  return validatedSplitNames.reduce((pValue: SplitIO.TreatmentsWithConfig, cValue: string) => {
+  return validatedFeatureFlagNames.reduce((pValue: SplitIO.TreatmentsWithConfig, cValue: string) => {
     pValue[cValue] = CONTROL_WITH_CONFIG;
     return pValue;
   }, {});