@usertour/helpers 0.0.15 → 0.0.18

package/dist/__tests__/attribute.test.cjs

@@ -0,0 +1,1036 @@
+"use strict";
+
+// src/__tests__/attribute.test.ts
+var import_types2 = require("@usertour/types");
+
+// src/conditions/attribute.ts
+var import_types = require("@usertour/types");
+var import_date_fns = require("date-fns");
+function evaluateFilterConditions(conditions, attributes, userAttributes) {
+  if (!conditions || !conditions.length) {
+    return true;
+  }
+  const result = evaluateAttributeConditionsGroup(conditions, attributes, userAttributes);
+  return evaluateFilterResult(result);
+}
+function evaluateAttributeConditionsGroup(conditions, attributes, userAttributes) {
+  if (!conditions || !conditions.length) {
+    return false;
+  }
+  const AND = [];
+  const OR = [];
+  for (const condition of conditions) {
+    const { operators } = condition;
+    const item = condition.type !== "group" ? evaluateAttributeCondition(condition, attributes, userAttributes) : evaluateAttributeConditionsGroup(condition.conditions || [], attributes, userAttributes);
+    if (!item) {
+      continue;
+    }
+    if (operators === "and") {
+      AND.push(item);
+    } else {
+      OR.push(item);
+    }
+  }
+  const filter = {};
+  if (AND.length > 0) {
+    filter.AND = AND;
+  }
+  if (OR.length > 0) {
+    filter.OR = OR;
+  }
+  if (AND.length === 0 && OR.length === 0) {
+    return false;
+  }
+  return filter;
+}
+function evaluateAttributeCondition(condition, attributes, userAttributes) {
+  const { data } = condition;
+  if (!data) {
+    return false;
+  }
+  const { logic, value, attrId, value2, listValues = [] } = data;
+  if (!attrId) {
+    return false;
+  }
+  const attr = attributes.find((attr2) => attr2.id === attrId);
+  if (!attr) {
+    return false;
+  }
+  const actualValue = getAttributeValue(attr.codeName, userAttributes);
+  if (attr.dataType === import_types.BizAttributeTypes.String) {
+    return evaluateStringCondition(logic, actualValue, value);
+  }
+  if (attr.dataType === import_types.BizAttributeTypes.Number) {
+    return evaluateNumberCondition(logic, actualValue, value, value2);
+  }
+  if (attr.dataType === import_types.BizAttributeTypes.Boolean) {
+    return evaluateBooleanCondition(logic, actualValue);
+  }
+  if (attr.dataType === import_types.BizAttributeTypes.List) {
+    return evaluateListCondition(logic, actualValue, listValues);
+  }
+  if (attr.dataType === import_types.BizAttributeTypes.DateTime) {
+    return evaluateDateTimeCondition(logic, actualValue, value);
+  }
+  return false;
+}
+function getAttributeValue(codeName, userAttributes) {
+  return userAttributes == null ? void 0 : userAttributes[codeName];
+}
+function evaluateStringCondition(logic, actualValue, expectedValue) {
+  const stringValue = actualValue === null || actualValue === void 0 ? "" : String(actualValue);
+  switch (logic) {
+    case "is":
+      return stringValue === expectedValue;
+    case "not":
+      return stringValue !== expectedValue;
+    case "contains":
+      return stringValue.includes(expectedValue);
+    case "notContain":
+      return !stringValue.includes(expectedValue);
+    case "startsWith":
+      return stringValue.startsWith(expectedValue);
+    case "endsWith":
+      return stringValue.endsWith(expectedValue);
+    case "empty": {
+      const isEmpty = !stringValue || stringValue === "";
+      return isEmpty;
+    }
+    case "any":
+      return Boolean(stringValue && stringValue !== "");
+    default:
+      return false;
+  }
+}
+function evaluateNumberCondition(logic, actualValue, expectedValue, expectedValue2) {
+  const numValue = Number(actualValue);
+  const numValue2 = Number(expectedValue2);
+  if (Number.isNaN(numValue)) {
+    return false;
+  }
+  switch (logic) {
+    case "is":
+      return numValue === expectedValue;
+    case "not":
+      return numValue !== expectedValue;
+    case "isLessThan":
+      return numValue < expectedValue;
+    case "isLessThanOrEqualTo":
+      return numValue <= expectedValue;
+    case "isGreaterThan":
+      return numValue > expectedValue;
+    case "isGreaterThanOrEqualTo":
+      return numValue >= expectedValue;
+    case "between":
+      return numValue >= expectedValue && numValue <= numValue2;
+    case "empty":
+      return actualValue === null || actualValue === void 0 || actualValue === "";
+    case "any":
+      return actualValue !== null && actualValue !== void 0 && actualValue !== "";
+    default:
+      return false;
+  }
+}
+function evaluateBooleanCondition(logic, actualValue) {
+  switch (logic) {
+    case "true":
+      return actualValue === true;
+    case "false":
+      return actualValue === false;
+    case "empty":
+      return actualValue === null || actualValue === void 0 || actualValue === "";
+    case "any":
+      return actualValue !== null && actualValue !== void 0 && actualValue !== "";
+    default:
+      return false;
+  }
+}
+function evaluateListCondition(logic, actualValue, expectedValues) {
+  const arrayValue = Array.isArray(actualValue) ? actualValue : [];
+  if (logic === "empty" || logic === "any") {
+    switch (logic) {
+      case "empty":
+        return !arrayValue || arrayValue.length === 0;
+      case "any":
+        return arrayValue && arrayValue.length > 0;
+      default:
+        return false;
+    }
+  }
+  const filteredValues = expectedValues.filter(
+    (value) => value !== null && value !== void 0 && value !== ""
+  );
+  if (!filteredValues.length) {
+    return false;
+  }
+  switch (logic) {
+    case "includesAtLeastOne":
+      return filteredValues.some((value) => arrayValue.includes(value));
+    case "includesAll":
+      return filteredValues.every((value) => arrayValue.includes(value));
+    case "notIncludesAtLeastOne":
+      return !filteredValues.some((value) => arrayValue.includes(value));
+    case "notIncludesAll":
+      return !filteredValues.every((value) => arrayValue.includes(value));
+    default:
+      return false;
+  }
+}
+function evaluateDateTimeCondition(logic, actualValue, expectedValue) {
+  const actualDate = actualValue ? new Date(actualValue) : null;
+  const now = /* @__PURE__ */ new Date();
+  if (!actualDate || Number.isNaN(actualDate.getTime())) {
+    return false;
+  }
+  switch (logic) {
+    case "lessThan": {
+      const targetDate = (0, import_date_fns.subDays)(now, Number(expectedValue));
+      return actualDate >= targetDate;
+    }
+    case "exactly": {
+      const targetDate = (0, import_date_fns.subDays)(now, Number(expectedValue));
+      const start = (0, import_date_fns.startOfDay)(targetDate);
+      const end = (0, import_date_fns.endOfDay)(targetDate);
+      return actualDate >= start && actualDate <= end;
+    }
+    case "moreThan": {
+      const targetDate = (0, import_date_fns.subDays)(now, Number(expectedValue));
+      return actualDate <= targetDate;
+    }
+    case "before": {
+      const expectedDate = new Date(expectedValue);
+      return actualDate <= expectedDate;
+    }
+    case "on": {
+      const expectedDateOn = new Date(expectedValue);
+      const start = (0, import_date_fns.startOfDay)(expectedDateOn);
+      const end = (0, import_date_fns.endOfDay)(expectedDateOn);
+      return actualDate >= start && actualDate <= end;
+    }
+    case "after": {
+      const expectedDateAfter = new Date(expectedValue);
+      return actualDate >= expectedDateAfter;
+    }
+    case "empty":
+      return !actualValue || actualValue === "";
+    case "any":
+      return actualValue && actualValue !== "";
+    default:
+      return false;
+  }
+}
+function evaluateFilterResult(filter) {
+  if (!filter) {
+    return false;
+  }
+  if (filter.AND) {
+    return filter.AND.every((item) => evaluateFilterResult(item));
+  }
+  if (filter.OR) {
+    return filter.OR.some((item) => evaluateFilterResult(item));
+  }
+  if (typeof filter === "boolean") {
+    return filter;
+  }
+  if (typeof filter === "object") {
+    return true;
+  }
+  return false;
+}
+
+// src/__tests__/attribute.test.ts
+var testAttributes = [
+  {
+    id: "email-attr",
+    codeName: "email",
+    dataType: import_types2.BizAttributeTypes.String
+  },
+  {
+    id: "age-attr",
+    codeName: "age",
+    dataType: import_types2.BizAttributeTypes.Number
+  },
+  {
+    id: "isPremium-attr",
+    codeName: "isPremium",
+    dataType: import_types2.BizAttributeTypes.Boolean
+  },
+  {
+    id: "roles-attr",
+    codeName: "roles",
+    dataType: import_types2.BizAttributeTypes.List
+  },
+  {
+    id: "signUpDate-attr",
+    codeName: "signUpDate",
+    dataType: import_types2.BizAttributeTypes.DateTime
+  },
+  {
+    id: "score-attr",
+    codeName: "score",
+    dataType: import_types2.BizAttributeTypes.Number
+  }
+];
+var testUserAttributes = {
+  email: "user@example.com",
+  age: 25,
+  isPremium: true,
+  roles: ["admin", "user"],
+  signUpDate: "2024-01-15T10:30:00Z",
+  score: 85.5
+};
+describe("Attribute Filter - Complete Test Suite", () => {
+  describe("String conditions (8 cases)", () => {
+    test('should evaluate "is" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-1",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "is",
+            value: "user@example.com",
+            attrId: "email-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(true);
+    });
+    test('should evaluate "not" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-2",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "not",
+            value: "other@example.com",
+            attrId: "email-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(true);
+    });
+    test('should evaluate "contains" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-3",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "contains",
+            value: "example.com",
+            attrId: "email-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(true);
+    });
+    test('should evaluate "notContain" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-4",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "notContain",
+            value: "gmail.com",
+            attrId: "email-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(true);
+    });
+    test('should evaluate "startsWith" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-5",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "startsWith",
+            value: "user",
+            attrId: "email-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(true);
+    });
+    test('should evaluate "endsWith" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-6",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "endsWith",
+            value: "example.com",
+            attrId: "email-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(true);
+    });
+    test('should evaluate "empty" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-7",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "empty",
+            attrId: "email-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(false);
+    });
+    test('should evaluate "any" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-8",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "any",
+            attrId: "email-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(true);
+    });
+  });
+  describe("Number conditions (9 cases)", () => {
+    test('should evaluate "is" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-9",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "is",
+            value: 25,
+            attrId: "age-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(true);
+    });
+    test('should evaluate "not" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-10",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "not",
+            value: 30,
+            attrId: "age-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(true);
+    });
+    test('should evaluate "isLessThan" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-11",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "isLessThan",
+            value: 30,
+            attrId: "age-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(true);
+    });
+    test('should evaluate "isLessThanOrEqualTo" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-12",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "isLessThanOrEqualTo",
+            value: 25,
+            attrId: "age-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(true);
+    });
+    test('should evaluate "isGreaterThan" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-13",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "isGreaterThan",
+            value: 18,
+            attrId: "age-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(true);
+    });
+    test('should evaluate "isGreaterThanOrEqualTo" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-14",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "isGreaterThanOrEqualTo",
+            value: 25,
+            attrId: "age-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(true);
+    });
+    test('should evaluate "between" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-15",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "between",
+            value: 20,
+            value2: 30,
+            attrId: "age-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(true);
+    });
+    test('should evaluate "empty" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-16",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "empty",
+            attrId: "age-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(false);
+    });
+    test('should evaluate "any" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-17",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "any",
+            attrId: "age-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(true);
+    });
+  });
+  describe("Boolean conditions (4 cases)", () => {
+    test('should evaluate "true" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-18",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "true",
+            attrId: "isPremium-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(true);
+    });
+    test('should evaluate "false" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-19",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "false",
+            attrId: "isPremium-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(false);
+    });
+    test('should evaluate "empty" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-20",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "empty",
+            attrId: "isPremium-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(false);
+    });
+    test('should evaluate "any" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-21",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "any",
+            attrId: "isPremium-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(true);
+    });
+  });
+  describe("List conditions (6 cases)", () => {
+    test('should evaluate "includesAtLeastOne" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-22",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "includesAtLeastOne",
+            listValues: ["admin"],
+            attrId: "roles-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(true);
+    });
+    test('should evaluate "includesAll" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-23",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "includesAll",
+            listValues: ["admin", "user"],
+            attrId: "roles-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(true);
+    });
+    test('should evaluate "notIncludesAtLeastOne" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-24",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "notIncludesAtLeastOne",
+            listValues: ["guest"],
+            attrId: "roles-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(true);
+    });
+    test('should evaluate "notIncludesAll" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-25",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "notIncludesAll",
+            listValues: ["admin", "guest"],
+            attrId: "roles-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(true);
+    });
+    test('should evaluate "empty" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-26",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "empty",
+            attrId: "roles-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(false);
+    });
+    test('should evaluate "any" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-27",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "any",
+            attrId: "roles-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(true);
+    });
+  });
+  describe("DateTime conditions (8 cases)", () => {
+    test('should evaluate "lessThan" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-28",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "lessThan",
+            value: 600,
+            // 600 days ago (signUpDate is 575 days ago, which is < 600, so should be false)
+            attrId: "signUpDate-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(true);
+    });
+    test('should evaluate "exactly" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-29",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "exactly",
+            value: 30,
+            // 30 days ago
+            attrId: "signUpDate-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(false);
+    });
+    test('should evaluate "moreThan" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-30",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "moreThan",
+            value: 500,
+            // 500 days ago (signUpDate is 575 days ago, which is > 500, so should be true)
+            attrId: "signUpDate-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(true);
+    });
+    test('should evaluate "before" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-31",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "before",
+            value: "2024-02-01T00:00:00Z",
+            attrId: "signUpDate-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(true);
+    });
+    test('should evaluate "on" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-32",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "on",
+            value: "2024-01-15T00:00:00Z",
+            attrId: "signUpDate-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(true);
+    });
+    test('should evaluate "after" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-33",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "after",
+            value: "2024-01-01T00:00:00Z",
+            attrId: "signUpDate-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(true);
+    });
+    test('should evaluate "empty" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-34",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "empty",
+            attrId: "signUpDate-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(false);
+    });
+    test('should evaluate "any" condition correctly', () => {
+      const condition = [
+        {
+          id: "condition-35",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "any",
+            attrId: "signUpDate-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(true);
+    });
+  });
+  describe("Complex conditions with AND/OR logic", () => {
+    test("should evaluate AND condition correctly", () => {
+      const condition = [
+        {
+          id: "condition-36",
+          type: "group",
+          operators: "and",
+          data: {},
+          conditions: [
+            {
+              id: "condition-36-1",
+              type: "condition",
+              operators: "and",
+              data: {
+                logic: "contains",
+                value: "example.com",
+                attrId: "email-attr"
+              }
+            },
+            {
+              id: "condition-36-2",
+              type: "condition",
+              operators: "and",
+              data: {
+                logic: "isGreaterThan",
+                value: 18,
+                attrId: "age-attr"
+              }
+            }
+          ]
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(true);
+    });
+    test("should evaluate OR condition correctly", () => {
+      const condition = [
+        {
+          id: "condition-37",
+          type: "group",
+          operators: "or",
+          data: {},
+          conditions: [
+            {
+              id: "condition-37-1",
+              type: "condition",
+              operators: "or",
+              data: {
+                logic: "is",
+                value: "wrong@email.com",
+                attrId: "email-attr"
+              }
+            },
+            {
+              id: "condition-37-2",
+              type: "condition",
+              operators: "or",
+              data: {
+                logic: "isGreaterThan",
+                value: 18,
+                attrId: "age-attr"
+              }
+            }
+          ]
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(true);
+    });
+    test("should evaluate mixed AND/OR condition correctly", () => {
+      const condition = [
+        {
+          id: "condition-38",
+          type: "group",
+          operators: "and",
+          data: {},
+          conditions: [
+            {
+              id: "condition-38-1",
+              type: "condition",
+              operators: "and",
+              data: {
+                logic: "contains",
+                value: "example.com",
+                attrId: "email-attr"
+              }
+            },
+            {
+              id: "condition-38-2",
+              type: "group",
+              operators: "or",
+              data: {},
+              conditions: [
+                {
+                  id: "condition-38-2-1",
+                  type: "condition",
+                  operators: "or",
+                  data: {
+                    logic: "is",
+                    value: "wrong@email.com",
+                    attrId: "email-attr"
+                  }
+                },
+                {
+                  id: "condition-38-2-2",
+                  type: "condition",
+                  operators: "or",
+                  data: {
+                    logic: "isGreaterThan",
+                    value: 18,
+                    attrId: "age-attr"
+                  }
+                }
+              ]
+            }
+          ]
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(true);
+    });
+  });
+  describe("Edge cases and error handling", () => {
+    test("should handle empty conditions array", () => {
+      expect(evaluateFilterConditions([], testAttributes, testUserAttributes)).toBe(true);
+    });
+    test("should handle null/undefined conditions", () => {
+      expect(evaluateFilterConditions(null, testAttributes, testUserAttributes)).toBe(true);
+    });
+    test("should handle missing attribute", () => {
+      const condition = [
+        {
+          id: "condition-39",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "is",
+            value: "test",
+            attrId: "non-existent-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(false);
+    });
+    test("should handle missing user attribute value", () => {
+      const userAttributesWithoutEmail = {
+        age: 25,
+        isPremium: true
+      };
+      const condition = [
+        {
+          id: "condition-40",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "is",
+            value: "test@example.com",
+            attrId: "email-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, userAttributesWithoutEmail)).toBe(
+        false
+      );
+    });
+    test("should handle invalid data type", () => {
+      const invalidAttribute = [
+        {
+          id: "invalid-attr",
+          codeName: "invalid",
+          dataType: 999
+          // Invalid data type
+        }
+      ];
+      const condition = [
+        {
+          id: "condition-41",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "is",
+            value: "test",
+            attrId: "invalid-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, invalidAttribute, testUserAttributes)).toBe(false);
+    });
+    test("should handle invalid logic", () => {
+      const condition = [
+        {
+          id: "condition-42",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "invalidLogic",
+            value: "test",
+            attrId: "email-attr"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(false);
+    });
+    test("should handle missing data in condition", () => {
+      const condition = [
+        {
+          id: "condition-43",
+          type: "condition",
+          operators: "and",
+          data: void 0
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(false);
+    });
+    test("should handle missing attrId in condition", () => {
+      const condition = [
+        {
+          id: "condition-44",
+          type: "condition",
+          operators: "and",
+          data: {
+            logic: "is",
+            value: "test"
+          }
+        }
+      ];
+      expect(evaluateFilterConditions(condition, testAttributes, testUserAttributes)).toBe(false);
+    });
+  });
+});