[FSSDK-11238] event tag validator test addition

Author: junaed-optimizely

lib/core/bucketer/bucket_value_generator.spec.ts

@@ -36,8 +36,14 @@ describe('generateBucketValue', () => {
   it('should return an error if it cannot generate the hash value', () => {
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore
-    expect(() => generateBucketValue(null)).toThrowError(
-      new OptimizelyError(INVALID_BUCKETING_ID)
-    );
+    expect(() => generateBucketValue(null)).toThrow(OptimizelyError);
+    try {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      generateBucketValue(null);
+    } catch (err) {
+      expect(err).toBeInstanceOf(OptimizelyError);
+      expect(err.baseMessage).toBe(INVALID_BUCKETING_ID);
+    }
   });
 });

lib/core/bucketer/index.spec.ts

@@ -198,9 +198,14 @@ describe('including groups: random', () => {
     const bucketerParamsWithInvalidGroupId = cloneDeep(bucketerParams);
     bucketerParamsWithInvalidGroupId.experimentIdMap[configObj.experiments[4].id].groupId = '6969';
 
-    expect(() => bucketer.bucket(bucketerParamsWithInvalidGroupId)).toThrowError(
-      new OptimizelyError(INVALID_GROUP_ID, '6969')
-    );
+    expect(()=> bucketer.bucket(bucketerParamsWithInvalidGroupId)).toThrow(OptimizelyError);
+
+    try {
+      bucketer.bucket(bucketerParamsWithInvalidGroupId);
+    } catch(err) {
+      expect(err).toBeInstanceOf(OptimizelyError);
+      expect(err.baseMessage).toBe(INVALID_GROUP_ID);
+    }
   });
 });
 

lib/project_config/project_config.spec.ts

@@ -322,9 +322,6 @@ describe('getLayerId', () => {
   });
 
   it('should throw error for invalid experiment key in getLayerId', function() {
-    // expect(() => projectConfig.getLayerId(configObj, 'invalidExperimentKey')).toThrowError(
-    //   sprintf(INVALID_EXPERIMENT_ID, 'PROJECT_CONFIG', 'invalidExperimentKey')
-    // );
     expect(() => projectConfig.getLayerId(configObj, 'invalidExperimentKey')).toThrowError(
       expect.objectContaining({
         baseMessage: INVALID_EXPERIMENT_ID,

lib/utils/attributes_validator/index.spec.ts

@@ -27,27 +27,55 @@ describe('validate', () => {
   it('should throw an error if attributes is an array', () => {
     const attributesArray = ['notGonnaWork'];
 
-    expect(() => attributesValidator.validate(attributesArray)).toThrowError(new OptimizelyError(INVALID_ATTRIBUTES));
+    expect(() => attributesValidator.validate(attributesArray)).toThrow(OptimizelyError);
+
+    try {
+      attributesValidator.validate(attributesArray);
+    } catch (err) {
+      expect(err).toBeInstanceOf(OptimizelyError);
+      expect(err.baseMessage).toBe(INVALID_ATTRIBUTES);
+    }
   });
 
   it('should throw an error if attributes is null', () => {
-    expect(() => attributesValidator.validate(null)).toThrowError(new OptimizelyError(INVALID_ATTRIBUTES));
+    expect(() => attributesValidator.validate(null)).toThrowError(OptimizelyError);
+
+    try {
+      attributesValidator.validate(null);
+    } catch (err) {
+      expect(err).toBeInstanceOf(OptimizelyError);
+      expect(err.baseMessage).toBe(INVALID_ATTRIBUTES);
+    }
   });
 
   it('should throw an error if attributes is a function', () => {
     function invalidInput() {
       console.log('This is an invalid input!');
     }
 
-    expect(() => attributesValidator.validate(invalidInput)).toThrowError(new OptimizelyError(INVALID_ATTRIBUTES));
+    expect(() => attributesValidator.validate(invalidInput)).toThrowError(OptimizelyError);
+
+    try {
+      attributesValidator.validate(invalidInput);
+    } catch(err) {
+      expect(err).toBeInstanceOf(OptimizelyError);
+      expect(err.baseMessage).toBe(INVALID_ATTRIBUTES);
+    }
   });
 
   it('should throw an error if attributes contains a key with an undefined value', () => {
     const attributeKey = 'testAttribute';
     const attributes: Record<string, unknown> = {};
     attributes[attributeKey] = undefined;
 
-    expect(() => attributesValidator.validate(attributes)).toThrowError(new OptimizelyError(UNDEFINED_ATTRIBUTE));
+    expect(() => attributesValidator.validate(attributes)).toThrowError(OptimizelyError);
+
+    try {
+      attributesValidator.validate(attributes);
+    } catch(err) {
+      expect(err).toBeInstanceOf(OptimizelyError);
+      expect(err.baseMessage).toBe(UNDEFINED_ATTRIBUTE); 
+    }
   });
 });
 
@@ -61,7 +89,7 @@ describe('isAttributeValid', () => {
       '': 'javascript',
     };
 
-    Object.keys(userAttributes).forEach((key) =>	 {
+    Object.keys(userAttributes).forEach(key => {
       const value = userAttributes[key];
 
       expect(attributesValidator.isAttributeValid(key, value)).toBe(true);
@@ -77,10 +105,10 @@ describe('isAttributeValid', () => {
       NaN: NaN,
     };
 
-    Object.keys(userAttributes).forEach((key) => {
+    Object.keys(userAttributes).forEach(key => {
       const value = userAttributes[key];
 
-			expect(attributesValidator.isAttributeValid(key, value)).toBe(false);
+      expect(attributesValidator.isAttributeValid(key, value)).toBe(false);
     });
   });
 });

lib/utils/config_validator/index.spec.ts

@@ -24,22 +24,41 @@ describe('validate', () => {
   it('should complain if datafile is not provided', () => {
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore
-    expect(() => configValidator.validateDatafile()).toThrowError(new OptimizelyError(NO_DATAFILE_SPECIFIED));
+    expect(() => configValidator.validateDatafile()).toThrow(OptimizelyError);
+
+    try {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      configValidator.validateDatafile();
+    } catch (err) {
+      expect(err).toBeInstanceOf(OptimizelyError);
+      expect(err.baseMessage).toBe(NO_DATAFILE_SPECIFIED);
+    }
   });
 
   it('should complain if datafile is malformed', () => {
-    expect(() => configValidator.validateDatafile('abc')).toThrowError(new OptimizelyError(INVALID_DATAFILE_MALFORMED));
+    expect(() => configValidator.validateDatafile('abc')).toThrow( OptimizelyError);
+
+    try {
+      configValidator.validateDatafile('abc');
+    } catch(err) {
+      expect(err).toBeInstanceOf(OptimizelyError);
+      expect(err.baseMessage).toBe(INVALID_DATAFILE_MALFORMED);
+    }
   });
 
   it('should complain if datafile version is not supported', () => {
-    expect(() =>
-      configValidator
-        .validateDatafile(JSON.stringify(testData.getUnsupportedVersionConfig()))
-        .toThrowError(new OptimizelyError(INVALID_DATAFILE_VERSION))
-    );
+    expect(() => configValidator.validateDatafile(JSON.stringify(testData.getUnsupportedVersionConfig())).toThrow(OptimizelyError));
+
+    try {
+      configValidator.validateDatafile(JSON.stringify(testData.getUnsupportedVersionConfig()));
+    } catch(err) {
+      expect(err).toBeInstanceOf(OptimizelyError);
+      expect(err.baseMessage).toBe(INVALID_DATAFILE_VERSION);
+    }
   });
 
-  it('should not complain if datafile is valid', function() {
+  it('should not complain if datafile is valid', () => {
     expect(() => configValidator.validateDatafile(JSON.stringify(testData.getTestProjectConfig())).not.toThrowError());
   });
 });

lib/utils/event_tags_validator/index.spec.ts

@@ -0,0 +1,63 @@
+/**
+ * Copyright 2025, Optimizely
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import { validate } from '.';
+import { OptimizelyError } from '../../error/optimizly_error';
+import { INVALID_EVENT_TAGS } from 'error_message';
+
+describe('validate', () => {
+  it('should validate the given event tags if event tag is an object', () => {
+    expect(validate({ testAttribute: 'testValue' })).toBe(true);
+  });
+
+  it('should throw an error if event tags is an array', () => {
+    const eventTagsArray = ['notGonnaWork'];
+
+		expect(() => validate(eventTagsArray)).toThrow(OptimizelyError)
+
+    try {
+      validate(eventTagsArray);
+    } catch(err) {
+      expect(err).toBeInstanceOf(OptimizelyError);
+      expect(err.baseMessage).toBe(INVALID_EVENT_TAGS);
+    }
+  });
+
+  it('should throw an error if event tags is null', () => {
+		expect(() => validate(null)).toThrow(OptimizelyError);
+
+    try {
+      validate(null);
+    } catch(err) {
+      expect(err).toBeInstanceOf(OptimizelyError);
+      expect(err.baseMessage).toBe(INVALID_EVENT_TAGS);
+    }
+  });
+
+  it('should throw an error if event tags is a function', () => {
+    function invalidInput() {
+      console.log('This is an invalid input!');
+    }
+		expect(() => validate(invalidInput)).toThrow(OptimizelyError);
+
+    try {
+      validate(invalidInput);
+    } catch(err) {
+      expect(err).toBeInstanceOf(OptimizelyError);
+      expect(err.baseMessage).toBe(INVALID_EVENT_TAGS);
+    }
+  });
+});