@frontegg/entitlements-javascript-commons 1.0.1 → 1.1.0-alpha.2

package/src/plans/tests/plans.evaluator.spec.ts

@@ -0,0 +1,121 @@
+import { ConditionLogicEnum, TreatmentEnum } from '../../rules';
+import { OperationEnum } from '../../operations/types';
+import { Plan } from '../types';
+import { evaluatePlan } from '../plan.evaluator';
+
+type PlanCreator = (data?: Partial<Plan>) => Plan;
+const planFactory: PlanCreator = (data?: Partial<Plan>) => ({
+  defaultTreatment: TreatmentEnum.False,
+  ...data,
+});
+
+describe('evaluatePlan', () => {
+  describe('default treatment', () => {
+    it('should return false when no rule is valid and defaultTreatment is false', () => {
+      const plan: Plan = planFactory({
+        rules: [
+          {
+            treatment: TreatmentEnum.True,
+            conditions: [
+              {
+                attribute: 'test',
+                op: 'not supported' as any,
+                value: { list: ['test'] },
+                negate: false,
+              },
+            ],
+            conditionLogic: ConditionLogicEnum.And,
+          },
+        ],
+      });
+
+      const result = evaluatePlan(plan, {});
+
+      expect(result).toEqual({ treatment: TreatmentEnum.False });
+    });
+
+    it('should return true when no rule is valid and defaultTreatment is true', () => {
+      const plan: Plan = planFactory({
+        defaultTreatment: TreatmentEnum.True,
+        rules: [
+          {
+            treatment: TreatmentEnum.True,
+            conditions: [
+              {
+                attribute: 'test',
+                op: 'not supported' as any,
+                value: { list: ['test'] },
+                negate: false,
+              },
+            ],
+            conditionLogic: ConditionLogicEnum.And,
+          },
+        ],
+      });
+
+      const result = evaluatePlan(plan, {});
+
+      expect(result).toEqual({ treatment: TreatmentEnum.True });
+    });
+  });
+
+  describe('complete evaluation', () => {
+    it('should return false according to first treatable rule', () => {
+      const plan: Plan = planFactory({
+        rules: [
+          {
+            treatment: TreatmentEnum.False,
+            conditions: [
+              {
+                attribute: 'attribute',
+                op: OperationEnum.InList,
+                value: { list: ['test'] },
+                negate: false,
+              },
+            ],
+            conditionLogic: ConditionLogicEnum.And,
+          },
+        ],
+      });
+
+      const result = evaluatePlan(plan, { attribute: 'test' });
+
+      expect(result).toEqual({ treatment: TreatmentEnum.False });
+    });
+
+    it('should return true according to first treatable rule', () => {
+      const plan: Plan = planFactory({
+        rules: [
+          {
+            treatment: TreatmentEnum.False,
+            conditions: [
+              {
+                attribute: 'test',
+                op: 'not supported' as any,
+                value: { list: ['test'] },
+                negate: false,
+              },
+            ],
+            conditionLogic: ConditionLogicEnum.And,
+          },
+          {
+            treatment: TreatmentEnum.True,
+            conditions: [
+              {
+                attribute: 'attribute',
+                op: OperationEnum.InList,
+                value: { list: ['test'] },
+                negate: false,
+              },
+            ],
+            conditionLogic: ConditionLogicEnum.And,
+          },
+        ],
+      });
+
+      const result = evaluatePlan(plan, { attribute: 'test' });
+
+      expect(result).toEqual({ treatment: TreatmentEnum.True });
+    });
+  });
+});

package/src/plans/types.ts

@@ -0,0 +1,11 @@
+import { Rule, TreatmentEnum } from '../rules';
+
+export interface Plan {
+    defaultTreatment: TreatmentEnum;
+    rules?: Rule[];
+}
+
+export interface PlanEvaluationResult {
+    treatment: TreatmentEnum;
+  }
+  

package/src/user-entitlements/index.ts

@@ -1,4 +1,4 @@
-export * from './is-entitled.evaluator';
+export * from './is-entitled-to-feature';
+export * from './is-entitled-to-permission';
 export * from './types';
-export * from './attributes.utils';
-export * from './permissions.utils';
+export * from './utils';

package/src/user-entitlements/is-entitled-to-feature/evaluators/direct-entitlement.evaluator.ts

@@ -0,0 +1,28 @@
+import {
+  Attributes,
+  EntitlementResult,
+  NO_EXPIRATION_TIME,
+  NotEntitledJustification,
+  UserEntitlementsContext,
+} from '../../types';
+
+export function directEntitlementEvalutor(
+  featureKey: string,
+  userEntitlementsContext: UserEntitlementsContext,
+  attributes: Attributes = {},
+): EntitlementResult {
+  const feature = userEntitlementsContext.features[featureKey];
+  let hasExpired = false;
+  if (feature && feature.expireTime !== null) {
+    hasExpired = feature.expireTime !== NO_EXPIRATION_TIME && feature.expireTime < Date.now();
+
+    if (!hasExpired) {
+      return { isEntitled: true };
+    }
+  }
+
+  return {
+    isEntitled: false,
+    justification: hasExpired ? NotEntitledJustification.BUNDLE_EXPIRED : NotEntitledJustification.MISSING_FEATURE,
+  };
+}

package/src/user-entitlements/is-entitled-to-feature/evaluators/feature-flag.evaluator.ts

@@ -0,0 +1,24 @@
+import { Attributes, EntitlementResult, NotEntitledJustification, UserEntitlementsContext } from '../../types';
+import { evaluateFeatureFlag } from '../../../feature-flags';
+import { prepareAttributes } from '../../utils/attributes.utils';
+import { TreatmentEnum } from '../../../rules';
+
+export function featureFlagEvaluator(
+  featureKey: string,
+  userEntitlementsContext: UserEntitlementsContext,
+  attributes: Attributes = {},
+): EntitlementResult {
+  const feature = userEntitlementsContext.features[featureKey];
+  if (feature && feature.featureFlag) {
+    const preparedAttributes = prepareAttributes(attributes);
+    const { treatment } = evaluateFeatureFlag(feature.featureFlag, preparedAttributes);
+    if (treatment === TreatmentEnum.True) {
+      return { isEntitled: true };
+    }
+  }
+
+  return {
+    isEntitled: false,
+    justification: NotEntitledJustification.MISSING_FEATURE,
+  };
+}

package/src/user-entitlements/is-entitled-to-feature/evaluators/index.ts

@@ -0,0 +1,8 @@
+import { directEntitlementEvalutor } from './direct-entitlement.evaluator';
+import { featureFlagEvaluator } from './feature-flag.evaluator';
+import { planTargetingRulesEvalutor } from './plan-targeting-rules.evaluator';
+import { IsEntitledEvaluator } from './types';
+
+export function getIsEntitledEvaluators(): IsEntitledEvaluator[] {
+  return [directEntitlementEvalutor, featureFlagEvaluator, planTargetingRulesEvalutor];
+}

package/src/user-entitlements/is-entitled-to-feature/evaluators/plan-targeting-rules.evaluator.ts

@@ -0,0 +1,30 @@
+import { Attributes, EntitlementResult, NotEntitledJustification, UserEntitlementsContext } from '../../types';
+import { prepareAttributes } from '../../utils/attributes.utils';
+import { TreatmentEnum } from '../../../rules';
+import { evaluatePlan } from '../../../plans';
+
+export function planTargetingRulesEvalutor(
+  featureKey: string,
+  userEntitlementsContext: UserEntitlementsContext,
+  attributes: Attributes = {},
+): EntitlementResult {
+  const feature = userEntitlementsContext.features[featureKey];
+  if (feature && feature.planIds && feature.planIds.length > 0) {
+    const preparedAttributes = prepareAttributes(attributes);
+    const plans = userEntitlementsContext.plans;
+    for (const planId of feature.planIds) {
+      const plan = plans[planId];
+      if (plan) {
+        const { treatment } = evaluatePlan(plan, preparedAttributes);
+        if (treatment === TreatmentEnum.True) {
+          return { isEntitled: true };
+        }
+      }
+    }
+  }
+
+  return {
+    isEntitled: false,
+    justification: NotEntitledJustification.MISSING_FEATURE,
+  };
+}

package/src/user-entitlements/is-entitled-to-feature/evaluators/tests/direct-entitlements.evaluator.spec.ts

@@ -0,0 +1,81 @@
+import { NO_EXPIRATION_TIME, NotEntitledJustification } from '../../../types';
+import { directEntitlementEvalutor } from '../direct-entitlement.evaluator';
+
+describe('directEntitlementEvalutor', () => {
+  describe('entitled', () => {
+    test('feature is entitled with no expiration date', async () => {
+      const result = directEntitlementEvalutor('feature-key', {
+        features: {
+          'feature-key': {
+            expireTime: NO_EXPIRATION_TIME,
+            linkedPermissions: [],
+            planIds: [],
+          },
+        },
+        permissions: {},
+        plans: {},
+      });
+
+      expect(result).toEqual({ isEntitled: true });
+    });
+
+    test('feature is entitled with a valid expiration date', async () => {
+      const result = directEntitlementEvalutor('feature-key', {
+        features: {
+          'feature-key': {
+            expireTime: Date.now() + 3600,
+            linkedPermissions: [],
+            planIds: [],
+          },
+        },
+        permissions: {},
+        plans: {},
+      });
+
+      expect(result).toEqual({ isEntitled: true });
+    });
+  });
+  describe('not-entitled', () => {
+    test('feature is not entitled', async () => {
+      const result = directEntitlementEvalutor('feature-key', {
+        features: {
+          'feature-key': {
+            expireTime: null,
+            linkedPermissions: [],
+            planIds: [],
+          },
+        },
+        permissions: {},
+        plans: {},
+      });
+
+      expect(result).toEqual({ isEntitled: false, justification: NotEntitledJustification.MISSING_FEATURE });
+    });
+
+    test('feature is entitled with an expired expiration date', async () => {
+      const result = directEntitlementEvalutor('feature-key', {
+        features: {
+          'feature-key': {
+            expireTime: Date.now() - 3600,
+            linkedPermissions: [],
+            planIds: [],
+          },
+        },
+        permissions: {},
+        plans: {},
+      });
+
+      expect(result).toEqual({ isEntitled: false, justification: NotEntitledJustification.BUNDLE_EXPIRED });
+    });
+
+    test('feature does not exist', async () => {
+      const result = directEntitlementEvalutor('feature-key', {
+        features: {},
+        permissions: {},
+        plans: {},
+      });
+
+      expect(result).toEqual({ isEntitled: false, justification: NotEntitledJustification.MISSING_FEATURE });
+    });
+  });
+});

package/src/user-entitlements/is-entitled-to-feature/evaluators/tests/feature-flag.evaluator.spec.ts

@@ -0,0 +1,57 @@
+import * as AttributesUtils from '../../../utils/attributes.utils';
+import * as FeatureFlagEvaluator from '../../../../feature-flags/feature-flag.evaluator';
+import { TreatmentEnum } from '../../../../rules';
+import { featureFlagEvaluator } from '../feature-flag.evaluator';
+import { NotEntitledJustification } from '../../../types';
+describe('featureFlagEvaluator', () => {
+  beforeAll(async () => {
+    jest.spyOn(AttributesUtils, 'prepareAttributes').mockReturnValue({ testAttribute: 'test-value' });
+  });
+  describe('entitled', () => {
+    test('feature flag evaluation return truthy', async () => {
+      jest.spyOn(FeatureFlagEvaluator, 'evaluateFeatureFlag').mockReturnValue({ treatment: TreatmentEnum.True });
+      const result = featureFlagEvaluator('feature-key', {
+        features: {
+          'feature-key': {
+            expireTime: null,
+            linkedPermissions: [],
+            planIds: [],
+            featureFlag: { defaultTreatment: TreatmentEnum.True, on: true, offTreatment: TreatmentEnum.False },
+          },
+        },
+        permissions: {},
+        plans: {},
+      });
+
+      expect(result).toEqual({ isEntitled: true });
+    });
+  });
+  describe('not-entitled', () => {
+    test('feature flag evaluation return falsy', async () => {
+      jest.spyOn(FeatureFlagEvaluator, 'evaluateFeatureFlag').mockReturnValue({ treatment: TreatmentEnum.False });
+      const result = featureFlagEvaluator('feature-key', {
+        features: {
+          'feature-key': {
+            expireTime: null,
+            linkedPermissions: [],
+            planIds: [],
+            featureFlag: { defaultTreatment: TreatmentEnum.False, on: true, offTreatment: TreatmentEnum.False },
+          },
+        },
+        permissions: {},
+        plans: {},
+      });
+
+      expect(result).toEqual({ isEntitled: false, justification: NotEntitledJustification.MISSING_FEATURE });
+    });
+    test('feataure does not exist', async () => {
+      const result = featureFlagEvaluator('feature-key', {
+        features: {},
+        permissions: {},
+        plans: {},
+      });
+
+      expect(result).toEqual({ isEntitled: false, justification: NotEntitledJustification.MISSING_FEATURE });
+    });
+  });
+});

package/src/user-entitlements/is-entitled-to-feature/evaluators/tests/plan-targeting-rules.evaluator.spec.ts

@@ -0,0 +1,70 @@
+import * as PlanEvaluator from '../../../../plans/plan.evaluator';
+import { TreatmentEnum } from '../../../../rules';
+import { NotEntitledJustification } from '../../../types';
+import { planTargetingRulesEvalutor } from '../plan-targeting-rules.evaluator';
+describe('planTargetingRulesEvalutor', () => {
+  describe('entitled', () => {
+    test('some of the plans targeting rules return truthy', async () => {
+      jest.spyOn(PlanEvaluator, 'evaluatePlan').mockReturnValueOnce({ treatment: TreatmentEnum.True });
+      jest.spyOn(PlanEvaluator, 'evaluatePlan').mockReturnValueOnce({ treatment: TreatmentEnum.False });
+
+      const result = planTargetingRulesEvalutor('feature-key', {
+        features: {
+          'feature-key': {
+            expireTime: null,
+            linkedPermissions: [],
+            planIds: ['plan-1', 'plan-2'],
+          },
+        },
+        permissions: {},
+        plans: {
+          'plan-1': {
+            defaultTreatment: TreatmentEnum.True,
+          },
+          'plan-2': {
+            defaultTreatment: TreatmentEnum.False,
+          },
+        },
+      });
+
+      expect(result).toEqual({ isEntitled: true });
+    });
+  });
+  describe('not-entitled', () => {
+    test('all of the plans targeting rules return falsy', async () => {
+      jest.spyOn(PlanEvaluator, 'evaluatePlan').mockReturnValueOnce({ treatment: TreatmentEnum.False });
+      jest.spyOn(PlanEvaluator, 'evaluatePlan').mockReturnValueOnce({ treatment: TreatmentEnum.False });
+
+      const result = planTargetingRulesEvalutor('feature-key', {
+        features: {
+          'feature-key': {
+            expireTime: null,
+            linkedPermissions: [],
+            planIds: ['plan-1', 'plan-2'],
+          },
+        },
+        permissions: {},
+        plans: {
+          'plan-1': {
+            defaultTreatment: TreatmentEnum.False,
+          },
+          'plan-2': {
+            defaultTreatment: TreatmentEnum.False,
+          },
+        },
+      });
+
+      expect(result).toEqual({ isEntitled: false, justification: NotEntitledJustification.MISSING_FEATURE });
+    });
+
+    test('feature does not exist', async () => {
+      const result = planTargetingRulesEvalutor('feature-key', {
+        features: {},
+        permissions: {},
+        plans: {},
+      });
+
+      expect(result).toEqual({ isEntitled: false, justification: NotEntitledJustification.MISSING_FEATURE });
+    });
+  });
+});

package/src/user-entitlements/is-entitled-to-feature/evaluators/types.ts

@@ -0,0 +1,7 @@
+import { Attributes, EntitlementResult, UserEntitlementsContext } from '../../types';
+
+export type IsEntitledEvaluator = (
+  featureKey: string,
+  userEntitlementsContext: UserEntitlementsContext,
+  attributes: Attributes,
+) => EntitlementResult;

package/src/user-entitlements/is-entitled-to-feature/index.ts

@@ -0,0 +1 @@
+export * from './is-entitled-to-feature.evaluator';

package/src/user-entitlements/is-entitled-to-feature/is-entitled-to-feature.evaluator.ts

@@ -0,0 +1,18 @@
+import { EntitlementResult, NotEntitledJustification, UserEntitlementsContext, Attributes } from '../types';
+import { getResult, shouldContinue } from '../utils';
+import { getIsEntitledEvaluators } from './evaluators';
+export function evaluateIsEntitledToFeature(
+  featureKey: string,
+  userEntitlementsContext: UserEntitlementsContext,
+  attributes: Attributes = {},
+): EntitlementResult {
+  const entitlementResults: EntitlementResult[] = [];
+  for (const evaluator of getIsEntitledEvaluators()) {
+    entitlementResults.push(evaluator(featureKey, userEntitlementsContext, attributes));
+    if (!shouldContinue(entitlementResults)) {
+      break;
+    }
+  }
+
+  return getResult(entitlementResults);
+}

package/src/user-entitlements/is-entitled-to-feature/tests/is-entitled-to-feature.evaluator.spec.ts

@@ -0,0 +1,68 @@
+import * as IsEntitledEvaluators from '../evaluators';
+import { evaluateIsEntitledToFeature } from '../is-entitled-to-feature.evaluator';
+import { EntitlementResult, NotEntitledJustification, NO_EXPIRATION_TIME, UserEntitlementsContext } from '../../types';
+
+describe('evaluateIsEntitledToFeature', () => {
+  const mockTruthyEvaluator = (): EntitlementResult => ({ isEntitled: true });
+  const mockFalsyMissingFeatureEvaluator = (): EntitlementResult => ({
+    isEntitled: false,
+    justification: NotEntitledJustification.MISSING_PERMISSION,
+  });
+  const mockFalsyExpiredEvaluator = (): EntitlementResult => ({
+    isEntitled: false,
+    justification: NotEntitledJustification.BUNDLE_EXPIRED,
+  });
+
+  describe('entitled', () => {
+    test('given all evaluators return truthy, feature is entitled', async () => {
+      jest
+        .spyOn(IsEntitledEvaluators, 'getIsEntitledEvaluators')
+        .mockReturnValue([mockTruthyEvaluator, mockTruthyEvaluator]);
+      const result = evaluateIsEntitledToFeature('feauture-key', {
+        features: {},
+        permissions: {},
+        plans: {},
+      });
+
+      expect(result).toEqual({ isEntitled: true });
+    });
+    test('given some evaluators return truthy, feature is entitled', async () => {
+      jest
+        .spyOn(IsEntitledEvaluators, 'getIsEntitledEvaluators')
+        .mockReturnValue([mockTruthyEvaluator, mockFalsyMissingFeatureEvaluator]);
+      const result = evaluateIsEntitledToFeature('feauture-key', {
+        features: {},
+        permissions: {},
+        plans: {},
+      });
+
+      expect(result).toEqual({ isEntitled: true });
+    });
+  });
+  describe('not-entitled', () => {
+    test('given all evaluators return falsy with missing feature, feature is not entitled, justified with missing feature', async () => {
+      jest
+        .spyOn(IsEntitledEvaluators, 'getIsEntitledEvaluators')
+        .mockReturnValue([mockFalsyMissingFeatureEvaluator, mockFalsyMissingFeatureEvaluator]);
+      const result = evaluateIsEntitledToFeature('feauture-key', {
+        features: {},
+        permissions: {},
+        plans: {},
+      });
+
+      expect(result).toEqual({ isEntitled: false, justification: NotEntitledJustification.MISSING_FEATURE });
+    });
+    test('given all evaluators return falsy, some with missing feature, some with bundle expired, feature is not entitled, justified with bundle expired', async () => {
+      jest
+        .spyOn(IsEntitledEvaluators, 'getIsEntitledEvaluators')
+        .mockReturnValue([mockFalsyMissingFeatureEvaluator, mockFalsyExpiredEvaluator]);
+      const result = evaluateIsEntitledToFeature('feauture-key', {
+        features: {},
+        permissions: {},
+        plans: {},
+      });
+
+      expect(result).toEqual({ isEntitled: false, justification: NotEntitledJustification.BUNDLE_EXPIRED });
+    });
+  });
+});

package/src/user-entitlements/is-entitled-to-permission/index.ts

@@ -0,0 +1 @@
+export * from './is-entitled-to-permission.evaluator';

package/src/user-entitlements/is-entitled-to-permission/is-entitled-to-permission.evaluator.ts

@@ -0,0 +1,38 @@
+import { evaluateIsEntitledToFeature } from '../is-entitled-to-feature/is-entitled-to-feature.evaluator';
+import { UserEntitlementsContext, Attributes, EntitlementResult, NotEntitledJustification } from '../types';
+import { getResult, shouldContinue } from '../utils';
+import { checkPermission } from '../utils/permissions.utils';
+
+export function evaluateIsEntitledToPermissions(
+  permissionKey: string,
+  userEntitlementsContext: UserEntitlementsContext,
+  attributes?: Attributes,
+): EntitlementResult {
+  const hasPermission = checkPermission(userEntitlementsContext.permissions, permissionKey);
+  if (!hasPermission) {
+    return { isEntitled: false, justification: NotEntitledJustification.MISSING_PERMISSION };
+  }
+
+  const linkedFeatures = getLinkedFeatures(permissionKey, userEntitlementsContext);
+
+  if (!linkedFeatures.length) {
+    return { isEntitled: true };
+  }
+
+  const entitlementResults: EntitlementResult[] = [];
+  for (const featureKey of linkedFeatures) {
+    entitlementResults.push(evaluateIsEntitledToFeature(featureKey, userEntitlementsContext, attributes));
+
+    if (!shouldContinue(entitlementResults)) {
+      break;
+    }
+  }
+
+  return getResult(entitlementResults);
+}
+
+function getLinkedFeatures(permissionKey: string, userEntitlementsContext: UserEntitlementsContext): string[] {
+  return Object.keys(userEntitlementsContext.features).filter((featureKey) =>
+    userEntitlementsContext.features[featureKey].linkedPermissions.includes(permissionKey),
+  );
+}

package/src/user-entitlements/is-entitled-to-permission/tests/is-entitled-to-permission.evaluator.spec.ts

@@ -0,0 +1,79 @@
+import { evaluateIsEntitledToPermissions } from '../is-entitled-to-permission.evaluator';
+import { NO_EXPIRATION_TIME, NotEntitledJustification, UserEntitlementsContext } from '../../types';
+import * as IsEntitledToFeatureEvaluator from '../../is-entitled-to-feature/is-entitled-to-feature.evaluator';
+describe('evaluateIsEntitledToPermission', () => {
+  describe('entitled', () => {
+    test('permission granted, no linked feature/s to it', async () => {
+      const userEntitlementContext: UserEntitlementsContext = {
+        features: {},
+        plans: {},
+
+        permissions: { 'test.permission': true },
+      };
+      const result = evaluateIsEntitledToPermissions('test.permission', userEntitlementContext, {});
+
+      expect(result).toEqual({ isEntitled: true });
+    });
+    test('permission granted with linked feature/s, feature is entitled', async () => {
+      jest.spyOn(IsEntitledToFeatureEvaluator, 'evaluateIsEntitledToFeature').mockReturnValue({ isEntitled: true });
+
+      const userEntitlementContext: UserEntitlementsContext = {
+        features: {
+          'test-feature': { planIds: [], expireTime: NO_EXPIRATION_TIME, linkedPermissions: ['test.permission'] },
+        },
+        plans: {},
+
+        permissions: { 'test.permission': true },
+      };
+
+      const result = evaluateIsEntitledToPermissions('test.permission', userEntitlementContext, {});
+
+      expect(result).toEqual({ isEntitled: true });
+    });
+  });
+
+  describe('not entitled', () => {
+    test('permission not granted', async () => {
+      const userEntitlementContext: UserEntitlementsContext = {
+        features: {},
+        plans: {},
+        permissions: {},
+      };
+      const result = evaluateIsEntitledToPermissions('test.permission', userEntitlementContext, {});
+
+      expect(result).toEqual({ isEntitled: false, justification: NotEntitledJustification.MISSING_PERMISSION });
+    });
+    test('permission granted with linked feature/s, no feature is entiteld', async () => {
+      jest
+        .spyOn(IsEntitledToFeatureEvaluator, 'evaluateIsEntitledToFeature')
+        .mockReturnValue({ isEntitled: false, justification: NotEntitledJustification.MISSING_FEATURE });
+
+      const userEntitlementContext: UserEntitlementsContext = {
+        features: { 'test-feature': { planIds: [], expireTime: null, linkedPermissions: ['test.permission'] } },
+        plans: {},
+        permissions: { 'test.permission': true },
+      };
+
+      const result = evaluateIsEntitledToPermissions('test.permission', userEntitlementContext, {});
+
+      expect(result).toEqual({ isEntitled: false, justification: NotEntitledJustification.MISSING_FEATURE });
+    });
+    test('permission granted with linked feature/s, no feature is entiteld with expired bundle', async () => {
+      jest
+        .spyOn(IsEntitledToFeatureEvaluator, 'evaluateIsEntitledToFeature')
+        .mockReturnValue({ isEntitled: false, justification: NotEntitledJustification.BUNDLE_EXPIRED });
+    });
+
+    const userEntitlementContext: UserEntitlementsContext = {
+      features: {
+        'test-feature': { planIds: [], expireTime: Date.now() - 3600, linkedPermissions: ['test.permission'] },
+      },
+      plans: {},
+      permissions: { 'test.permission': true },
+    };
+
+    const result = evaluateIsEntitledToPermissions('test.permission', userEntitlementContext, {});
+
+    expect(result).toEqual({ isEntitled: false, justification: NotEntitledJustification.BUNDLE_EXPIRED });
+  });
+});