@terreno/feature-flags 0.21.0 → 0.23.0

package/dist/tests/evaluate.test.js

@@ -1,594 +0,0 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var bun_test_1 = require("bun:test");
-var evaluate_1 = require("../evaluate");
-var createFlag = function (overrides) {
-    if (overrides === void 0) { overrides = {}; }
-    return __assign({ archived: false, description: "Test flag", enabled: true, key: "test-flag", name: "Test Flag", rolloutPercentage: 100, rules: [], type: "boolean", variants: [] }, overrides);
-};
-var noSegments = {};
-(0, bun_test_1.describe)("deterministicHash", function () {
-    (0, bun_test_1.it)("returns a number between 0 and 99", function () {
-        for (var i = 0; i < 100; i++) {
-            var hash = (0, evaluate_1.deterministicHash)("user-".concat(i, "flag-key"));
-            (0, bun_test_1.expect)(hash).toBeGreaterThanOrEqual(0);
-            (0, bun_test_1.expect)(hash).toBeLessThan(100);
-        }
-    });
-    (0, bun_test_1.it)("returns the same value for the same input", function () {
-        var input = "user123test-flag";
-        var hash1 = (0, evaluate_1.deterministicHash)(input);
-        var hash2 = (0, evaluate_1.deterministicHash)(input);
-        (0, bun_test_1.expect)(hash1).toBe(hash2);
-    });
-    (0, bun_test_1.it)("returns different values for different inputs", function () {
-        var hash1 = (0, evaluate_1.deterministicHash)("user1test-flag");
-        var hash2 = (0, evaluate_1.deterministicHash)("user2test-flag");
-        // Not guaranteed but extremely likely for different inputs
-        // Just verify they're both valid
-        (0, bun_test_1.expect)(hash1).toBeGreaterThanOrEqual(0);
-        (0, bun_test_1.expect)(hash2).toBeGreaterThanOrEqual(0);
-    });
-    (0, bun_test_1.it)("does not collide for ambiguous userId/key pairs", function () {
-        // "12" + "3" must not equal "1" + "23" — delimiter prevents this
-        var hash1 = (0, evaluate_1.deterministicHash)("12:3");
-        var hash2 = (0, evaluate_1.deterministicHash)("1:23");
-        (0, bun_test_1.expect)(hash1).not.toBe(hash2);
-    });
-});
-(0, bun_test_1.describe)("evaluateFlag", function () {
-    (0, bun_test_1.describe)("disabled flags", function () {
-        (0, bun_test_1.it)("returns false for disabled boolean flags", function () {
-            var flag = createFlag({ enabled: false, type: "boolean" });
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user1", {}, noSegments)).toBe(false);
-        });
-        (0, bun_test_1.it)("returns null for disabled variant flags", function () {
-            var flag = createFlag({
-                enabled: false,
-                type: "variant",
-                variants: [
-                    { key: "control", weight: 50 },
-                    { key: "variant-a", weight: 50 },
-                ],
-            });
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user1", {}, noSegments)).toBeNull();
-        });
-    });
-    (0, bun_test_1.describe)("boolean flags with rollout percentage", function () {
-        (0, bun_test_1.it)("returns true for all users at 100% rollout", function () {
-            var flag = createFlag({ rolloutPercentage: 100 });
-            // Test multiple users — all should get true
-            for (var i = 0; i < 20; i++) {
-                (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user-".concat(i), {}, noSegments)).toBe(true);
-            }
-        });
-        (0, bun_test_1.it)("returns false for all users at 0% rollout", function () {
-            var flag = createFlag({ rolloutPercentage: 0 });
-            for (var i = 0; i < 20; i++) {
-                (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user-".concat(i), {}, noSegments)).toBe(false);
-            }
-        });
-        (0, bun_test_1.it)("gives consistent results for the same user", function () {
-            var flag = createFlag({ rolloutPercentage: 50 });
-            var result1 = (0, evaluate_1.evaluateFlag)(flag, "user-abc", {}, noSegments);
-            var result2 = (0, evaluate_1.evaluateFlag)(flag, "user-abc", {}, noSegments);
-            (0, bun_test_1.expect)(result1).toBe(result2);
-        });
-        (0, bun_test_1.it)("distributes roughly proportionally at 50%", function () {
-            var flag = createFlag({ rolloutPercentage: 50 });
-            var trueCount = 0;
-            var total = 1000;
-            for (var i = 0; i < total; i++) {
-                if ((0, evaluate_1.evaluateFlag)(flag, "user-".concat(i), {}, noSegments) === true) {
-                    trueCount++;
-                }
-            }
-            // Allow 15% tolerance for randomness
-            (0, bun_test_1.expect)(trueCount).toBeGreaterThan(total * 0.35);
-            (0, bun_test_1.expect)(trueCount).toBeLessThan(total * 0.65);
-        });
-    });
-    (0, bun_test_1.describe)("variant flags", function () {
-        (0, bun_test_1.it)("assigns users to variants based on weights", function () {
-            var flag = createFlag({
-                type: "variant",
-                variants: [
-                    { key: "control", weight: 50 },
-                    { key: "variant-a", weight: 50 },
-                ],
-            });
-            var counts = { control: 0, "variant-a": 0 };
-            var total = 1000;
-            for (var i = 0; i < total; i++) {
-                var result = (0, evaluate_1.evaluateFlag)(flag, "user-".concat(i), {}, noSegments);
-                counts[result]++;
-            }
-            // Both variants should get roughly 50%
-            (0, bun_test_1.expect)(counts.control).toBeGreaterThan(total * 0.35);
-            (0, bun_test_1.expect)(counts["variant-a"]).toBeGreaterThan(total * 0.35);
-        });
-        (0, bun_test_1.it)("returns consistent variant for the same user", function () {
-            var flag = createFlag({
-                type: "variant",
-                variants: [
-                    { key: "control", weight: 50 },
-                    { key: "variant-a", weight: 50 },
-                ],
-            });
-            var result1 = (0, evaluate_1.evaluateFlag)(flag, "user-123", {}, noSegments);
-            var result2 = (0, evaluate_1.evaluateFlag)(flag, "user-123", {}, noSegments);
-            (0, bun_test_1.expect)(result1).toBe(result2);
-        });
-        (0, bun_test_1.it)("handles three-way split", function () {
-            var flag = createFlag({
-                type: "variant",
-                variants: [
-                    { key: "control", weight: 50 },
-                    { key: "variant-a", weight: 30 },
-                    { key: "variant-b", weight: 20 },
-                ],
-            });
-            var counts = { control: 0, "variant-a": 0, "variant-b": 0 };
-            var total = 1000;
-            for (var i = 0; i < total; i++) {
-                var result = (0, evaluate_1.evaluateFlag)(flag, "user-".concat(i), {}, noSegments);
-                counts[result]++;
-            }
-            // All variants should get some users
-            (0, bun_test_1.expect)(counts.control).toBeGreaterThan(0);
-            (0, bun_test_1.expect)(counts["variant-a"]).toBeGreaterThan(0);
-            (0, bun_test_1.expect)(counts["variant-b"]).toBeGreaterThan(0);
-        });
-    });
-    (0, bun_test_1.describe)("field rules", function () {
-        (0, bun_test_1.it)("matches eq operator", function () {
-            var flag = createFlag({
-                rules: [{ enabled: true, field: "admin", operator: "eq", value: true }],
-            });
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user1", { admin: true }, noSegments)).toBe(true);
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user2", { admin: false }, noSegments)).toBe(true); // Falls through to rollout at 100%
-        });
-        (0, bun_test_1.it)("matches neq operator", function () {
-            var flag = createFlag({
-                rolloutPercentage: 0,
-                rules: [{ enabled: true, field: "role", operator: "neq", value: "guest" }],
-            });
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user1", { role: "admin" }, noSegments)).toBe(true);
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user2", { role: "guest" }, noSegments)).toBe(false); // No match, 0% rollout
-        });
-        (0, bun_test_1.it)("matches in operator", function () {
-            var flag = createFlag({
-                rolloutPercentage: 0,
-                rules: [{ enabled: true, field: "plan", operator: "in", value: ["pro", "enterprise"] }],
-            });
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user1", { plan: "pro" }, noSegments)).toBe(true);
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user2", { plan: "free" }, noSegments)).toBe(false);
-        });
-        (0, bun_test_1.it)("matches nin operator", function () {
-            var flag = createFlag({
-                rolloutPercentage: 0,
-                rules: [{ enabled: true, field: "plan", operator: "nin", value: ["free", "trial"] }],
-            });
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user1", { plan: "pro" }, noSegments)).toBe(true);
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user2", { plan: "free" }, noSegments)).toBe(false);
-        });
-        (0, bun_test_1.it)("matches gt operator", function () {
-            var flag = createFlag({
-                rolloutPercentage: 0,
-                rules: [{ enabled: true, field: "totalActions", operator: "gt", value: 100 }],
-            });
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user1", { totalActions: 200 }, noSegments)).toBe(true);
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user2", { totalActions: 50 }, noSegments)).toBe(false);
-        });
-        (0, bun_test_1.it)("matches lt operator", function () {
-            var flag = createFlag({
-                rolloutPercentage: 0,
-                rules: [{ enabled: true, field: "age", operator: "lt", value: 18 }],
-            });
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user1", { age: 15 }, noSegments)).toBe(true);
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user2", { age: 25 }, noSegments)).toBe(false);
-        });
-        (0, bun_test_1.it)("matches contains operator", function () {
-            var flag = createFlag({
-                rolloutPercentage: 0,
-                rules: [{ enabled: true, field: "email", operator: "contains", value: "@company.com" }],
-            });
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user1", { email: "john@company.com" }, noSegments)).toBe(true);
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user2", { email: "john@gmail.com" }, noSegments)).toBe(false);
-        });
-        (0, bun_test_1.it)("does not match eq when rule.value is undefined", function () {
-            var flag = createFlag({
-                rolloutPercentage: 0,
-                rules: [{ enabled: true, field: "missingField", operator: "eq" }],
-            });
-            // Both user field and rule.value are undefined — should NOT match
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user1", {}, noSegments)).toBe(false);
-        });
-        (0, bun_test_1.it)("does not match neq when rule.value is undefined", function () {
-            var flag = createFlag({
-                rolloutPercentage: 0,
-                rules: [{ enabled: true, field: "missingField", operator: "neq" }],
-            });
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user1", {}, noSegments)).toBe(false);
-        });
-        (0, bun_test_1.it)("supports dot notation for nested fields", function () {
-            var flag = createFlag({
-                rolloutPercentage: 0,
-                rules: [{ enabled: true, field: "address.zip", operator: "eq", value: "94105" }],
-            });
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user1", { address: { zip: "94105" } }, noSegments)).toBe(true);
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user2", { address: { zip: "10001" } }, noSegments)).toBe(false);
-        });
-        (0, bun_test_1.it)("returns rule.enabled value for boolean flags", function () {
-            var flag = createFlag({
-                rules: [{ enabled: false, field: "admin", operator: "eq", value: true }],
-            });
-            // Rule matches and returns enabled: false
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user1", { admin: true }, noSegments)).toBe(false);
-        });
-        (0, bun_test_1.it)("first matching rule wins", function () {
-            var flag = createFlag({
-                rolloutPercentage: 0,
-                rules: [
-                    { enabled: true, field: "admin", operator: "eq", value: true },
-                    { enabled: false, field: "role", operator: "eq", value: "manager" },
-                ],
-            });
-            // Admin manager — first rule matches, gets true
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user1", { admin: true, role: "manager" }, noSegments)).toBe(true);
-        });
-    });
-    (0, bun_test_1.describe)("variant flag rules", function () {
-        (0, bun_test_1.it)("returns forced variant from matching rule", function () {
-            var flag = createFlag({
-                rules: [{ field: "admin", operator: "eq", value: true, variant: "variant-a" }],
-                type: "variant",
-                variants: [
-                    { key: "control", weight: 50 },
-                    { key: "variant-a", weight: 50 },
-                ],
-            });
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user1", { admin: true }, noSegments)).toBe("variant-a");
-        });
-    });
-    (0, bun_test_1.describe)("segment rules", function () {
-        (0, bun_test_1.it)("matches segment function", function () {
-            var segments = {
-                "pro-users": function (user) { return user.plan === "pro"; },
-            };
-            var flag = createFlag({
-                rolloutPercentage: 0,
-                rules: [{ enabled: true, segment: "pro-users" }],
-            });
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user1", { plan: "pro" }, segments)).toBe(true);
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user2", { plan: "free" }, segments)).toBe(false);
-        });
-        (0, bun_test_1.it)("returns false for unknown segment", function () {
-            var flag = createFlag({
-                rolloutPercentage: 0,
-                rules: [{ enabled: true, segment: "unknown-segment" }],
-            });
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user1", {}, noSegments)).toBe(false);
-        });
-        (0, bun_test_1.it)("returns false when segment function throws", function () {
-            var segments = {
-                "throwing-segment": function () {
-                    throw new Error("boom");
-                },
-            };
-            var flag = createFlag({
-                rolloutPercentage: 0,
-                rules: [{ enabled: true, segment: "throwing-segment" }],
-            });
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user1", {}, segments)).toBe(false);
-        });
-        (0, bun_test_1.it)("uses segment rule for variant flags", function () {
-            var segments = {
-                "pro-users": function (user) { return user.plan === "pro"; },
-            };
-            var flag = createFlag({
-                rules: [{ segment: "pro-users", variant: "variant-a" }],
-                type: "variant",
-                variants: [
-                    { key: "control", weight: 50 },
-                    { key: "variant-a", weight: 50 },
-                ],
-            });
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user1", { plan: "pro" }, segments)).toBe("variant-a");
-        });
-    });
-    (0, bun_test_1.describe)("malformed field rules", function () {
-        (0, bun_test_1.it)("does not match a rule with no field and no segment", function () {
-            var flag = createFlag({
-                rolloutPercentage: 0,
-                rules: [{ enabled: true }],
-            });
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user1", { anything: true }, noSegments)).toBe(false);
-        });
-        (0, bun_test_1.it)("does not match a rule with a field but no operator", function () {
-            var flag = createFlag({
-                rolloutPercentage: 0,
-                rules: [{ enabled: true, field: "admin" }],
-            });
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user1", { admin: true }, noSegments)).toBe(false);
-        });
-        (0, bun_test_1.it)("does not match a rule with an unknown operator", function () {
-            var flag = createFlag({
-                rolloutPercentage: 0,
-                rules: [
-                    {
-                        enabled: true,
-                        field: "admin",
-                        operator: "bogus",
-                        value: true,
-                    },
-                ],
-            });
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user1", { admin: true }, noSegments)).toBe(false);
-        });
-        (0, bun_test_1.it)("does not match gt/lt when values are not numbers", function () {
-            var gtFlag = createFlag({
-                rolloutPercentage: 0,
-                rules: [{ enabled: true, field: "age", operator: "gt", value: 18 }],
-            });
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(gtFlag, "user1", { age: "twenty" }, noSegments)).toBe(false);
-            var ltFlag = createFlag({
-                rolloutPercentage: 0,
-                rules: [{ enabled: true, field: "age", operator: "lt", value: 18 }],
-            });
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(ltFlag, "user1", { age: undefined }, noSegments)).toBe(false);
-        });
-        (0, bun_test_1.it)("does not match contains when values are not strings", function () {
-            var flag = createFlag({
-                rolloutPercentage: 0,
-                rules: [{ enabled: true, field: "email", operator: "contains", value: "@company.com" }],
-            });
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user1", { email: 42 }, noSegments)).toBe(false);
-        });
-        (0, bun_test_1.it)("does not match in/nin when rule.value is not an array", function () {
-            var inFlag = createFlag({
-                rolloutPercentage: 0,
-                rules: [{ enabled: true, field: "plan", operator: "in", value: "pro" }],
-            });
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(inFlag, "user1", { plan: "pro" }, noSegments)).toBe(false);
-            var ninFlag = createFlag({
-                rolloutPercentage: 0,
-                rules: [{ enabled: true, field: "plan", operator: "nin", value: "pro" }],
-            });
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(ninFlag, "user1", { plan: "pro" }, noSegments)).toBe(false);
-        });
-        (0, bun_test_1.it)("treats rule.enabled as false by default when undefined on a matching boolean rule", function () {
-            var flag = createFlag({
-                rolloutPercentage: 100,
-                rules: [{ field: "admin", operator: "eq", value: true }],
-            });
-            // rule matches, but rule.enabled is undefined → evaluates to false
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user1", { admin: true }, noSegments)).toBe(false);
-        });
-        (0, bun_test_1.it)("treats rule.variant as null when undefined on a matching variant rule", function () {
-            var flag = createFlag({
-                rules: [{ field: "admin", operator: "eq", value: true }],
-                type: "variant",
-                variants: [
-                    { key: "control", weight: 50 },
-                    { key: "variant-a", weight: 50 },
-                ],
-            });
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user1", { admin: true }, noSegments)).toBeNull();
-        });
-    });
-    (0, bun_test_1.describe)("variant fallback behavior", function () {
-        (0, bun_test_1.it)("falls back to the last variant when weights do not sum to 100", function () {
-            var flag = createFlag({
-                type: "variant",
-                // Weights only sum to 10 — the hash will always exceed cumulative weight
-                variants: [
-                    { key: "a", weight: 5 },
-                    { key: "b", weight: 5 },
-                ],
-            });
-            // Pick a user whose hash is guaranteed >= 10
-            var userId = "this-user-hashes-high";
-            var hash = (0, evaluate_1.deterministicHash)("".concat(userId, ":").concat(flag.key));
-            // Make sure our assumption holds before asserting the fallback
-            (0, bun_test_1.expect)(hash).toBeGreaterThanOrEqual(10);
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, userId, {}, noSegments)).toBe("b");
-        });
-        (0, bun_test_1.it)("returns null when an enabled variant flag has no variants defined", function () {
-            var flag = createFlag({
-                type: "variant",
-                variants: [],
-            });
-            (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user1", {}, noSegments)).toBeNull();
-        });
-    });
-    (0, bun_test_1.describe)("debug logging toggle", function () {
-        (0, bun_test_1.it)("runs without logging when FEATURE_FLAGS_DEBUG is 'false'", function () {
-            var original = process.env.FEATURE_FLAGS_DEBUG;
-            process.env.FEATURE_FLAGS_DEBUG = "false";
-            try {
-                var flag = createFlag({
-                    rolloutPercentage: 100,
-                    rules: [{ enabled: true, field: "admin", operator: "eq", value: true }],
-                });
-                (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user1", { admin: true }, noSegments)).toBe(true);
-                (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(flag, "user2", { admin: false }, noSegments)).toBe(true);
-                var disabledFlag = createFlag({ enabled: false });
-                (0, bun_test_1.expect)((0, evaluate_1.evaluateFlag)(disabledFlag, "user3", {}, noSegments)).toBe(false);
-            }
-            finally {
-                if (original === undefined) {
-                    delete process.env.FEATURE_FLAGS_DEBUG;
-                }
-                else {
-                    process.env.FEATURE_FLAGS_DEBUG = original;
-                }
-            }
-        });
-    });
-});
-(0, bun_test_1.describe)("evaluateAllFlags", function () {
-    var makeMockModel = function (flags) {
-        return {
-            find: function (query) { return __awaiter(void 0, void 0, void 0, function () {
-                return __generator(this, function (_a) {
-                    return [2 /*return*/, flags.filter(function (flag) {
-                            if (query.archived &&
-                                typeof query.archived === "object" &&
-                                "$ne" in query.archived) {
-                                if (flag.archived) {
-                                    return false;
-                                }
-                            }
-                            if (query.enabled !== undefined && flag.enabled !== query.enabled) {
-                                return false;
-                            }
-                            return true;
-                        })];
-                });
-            }); },
-        };
-    };
-    (0, bun_test_1.it)("returns an empty object when there are no flags", function () { return __awaiter(void 0, void 0, void 0, function () {
-        var model, result;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    model = makeMockModel([]);
-                    return [4 /*yield*/, (0, evaluate_1.evaluateAllFlags)(model, "user1", {}, noSegments)];
-                case 1:
-                    result = _a.sent();
-                    (0, bun_test_1.expect)(result).toEqual({});
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-    (0, bun_test_1.it)("evaluates each enabled flag and keys results by flag key", function () { return __awaiter(void 0, void 0, void 0, function () {
-        var flags, model, result;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    flags = [
-                        createFlag({ key: "flag-a", rolloutPercentage: 100 }),
-                        createFlag({ key: "flag-b", rolloutPercentage: 0 }),
-                        createFlag({
-                            key: "flag-c",
-                            rolloutPercentage: 0,
-                            rules: [{ enabled: true, field: "admin", operator: "eq", value: true }],
-                        }),
-                    ];
-                    model = makeMockModel(flags);
-                    return [4 /*yield*/, (0, evaluate_1.evaluateAllFlags)(model, "user1", { admin: true }, noSegments)];
-                case 1:
-                    result = _a.sent();
-                    (0, bun_test_1.expect)(result["flag-a"]).toBe(true);
-                    (0, bun_test_1.expect)(result["flag-b"]).toBe(false);
-                    (0, bun_test_1.expect)(result["flag-c"]).toBe(true);
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-    (0, bun_test_1.it)("supports variant flags in the aggregate evaluation", function () { return __awaiter(void 0, void 0, void 0, function () {
-        var flags, segments, model, result;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    flags = [
-                        createFlag({
-                            key: "variant-flag",
-                            rules: [{ segment: "pros", variant: "variant-a" }],
-                            type: "variant",
-                            variants: [
-                                { key: "control", weight: 50 },
-                                { key: "variant-a", weight: 50 },
-                            ],
-                        }),
-                    ];
-                    segments = {
-                        pros: function (user) { return user.pro === true; },
-                    };
-                    model = makeMockModel(flags);
-                    return [4 /*yield*/, (0, evaluate_1.evaluateAllFlags)(model, "user1", { pro: true }, segments)];
-                case 1:
-                    result = _a.sent();
-                    (0, bun_test_1.expect)(result["variant-flag"]).toBe("variant-a");
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-    (0, bun_test_1.it)("runs with debug logging disabled", function () { return __awaiter(void 0, void 0, void 0, function () {
-        var original, model, result;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    original = process.env.FEATURE_FLAGS_DEBUG;
-                    process.env.FEATURE_FLAGS_DEBUG = "false";
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, , 3, 4]);
-                    model = makeMockModel([createFlag({ key: "flag-a" })]);
-                    return [4 /*yield*/, (0, evaluate_1.evaluateAllFlags)(model, "user1", {}, noSegments)];
-                case 2:
-                    result = _a.sent();
-                    (0, bun_test_1.expect)(result["flag-a"]).toBe(true);
-                    return [3 /*break*/, 4];
-                case 3:
-                    if (original === undefined) {
-                        delete process.env.FEATURE_FLAGS_DEBUG;
-                    }
-                    else {
-                        process.env.FEATURE_FLAGS_DEBUG = original;
-                    }
-                    return [7 /*endfinally*/];
-                case 4: return [2 /*return*/];
-            }
-        });
-    }); });
-});

package/dist/tests/featureFlagModel.test.d.ts

@@ -1 +0,0 @@
-export {};