Add withScope test

Author: aliu39

dev-packages/browser-integration-tests/suites/integrations/featureFlags/unleash/basic/test.ts

@@ -24,26 +24,35 @@ sentryTest('Basic test with eviction, update, and no async tasks', async ({ getL
 
   await page.evaluate(bufferSize => {
     const client = new (window as any).UnleashClient();
-    for (let i = 1; i <= bufferSize; i++) {
+
+    client.isEnabled('feat1');
+    client.isEnabled('strFeat');
+    client.isEnabled('noPayloadFeat');
+    client.isEnabled('jsonFeat');
+    client.isEnabled('noVariantFeat');
+    client.isEnabled('disabledFeat');
+
+    for (let i = 7; i <= bufferSize; i++) {
       client.isEnabled(`feat${i}`);
     }
     client.isEnabled(`feat${bufferSize + 1}`); // eviction
-    client.isEnabled('feat3'); // update
+    client.isEnabled('noPayloadFeat'); // update (move to tail)
   }, FLAG_BUFFER_SIZE);
 
   const reqPromise = waitForErrorRequest(page);
   await page.locator('#error').click();
   const req = await reqPromise;
   const event = envelopeRequestParser(req);
 
-  const expectedFlags = [{ flag: 'feat2', result: true }];
-  expectedFlags.push({ flag: 'feat4', result: true });
-  expectedFlags.push({ flag: 'feat5', result: true });
-  for (let i = 6; i <= FLAG_BUFFER_SIZE; i++) {
+  const expectedFlags = [{ flag: 'strFeat', result: true }];
+  expectedFlags.push({ flag: 'jsonFeat', result: true });
+  expectedFlags.push({ flag: 'noVariantFeat', result: true });
+  expectedFlags.push({ flag: 'disabledFeat', result: false });
+  for (let i = 7; i <= FLAG_BUFFER_SIZE; i++) {
     expectedFlags.push({ flag: `feat${i}`, result: false });
   }
   expectedFlags.push({ flag: `feat${FLAG_BUFFER_SIZE + 1}`, result: false });
-  expectedFlags.push({ flag: 'feat3', result: true });
+  expectedFlags.push({ flag: 'noPayloadFeat', result: true });
 
   expect(event.contexts?.flags?.values).toEqual(expectedFlags);
 });

dev-packages/browser-integration-tests/suites/integrations/featureFlags/unleash/init.js

@@ -3,9 +3,9 @@ import * as Sentry from '@sentry/browser';
 window.UnleashClient = class {
   constructor() {
     this._featureToVariant = {
-      feat2: { name: 'variant1', enabled: true, feature_enabled: true, payload: { type: 'string', value: 'test' } },
-      feat3: { name: 'eu-west', enabled: true, feature_enabled: true },
-      feat4: {
+      strFeat: { name: 'variant1', enabled: true, feature_enabled: true, payload: { type: 'string', value: 'test' } },
+      noPayloadFeat: { name: 'eu-west', enabled: true, feature_enabled: true },
+      jsonFeat: {
         name: 'paid-orgs',
         enabled: true,
         feature_enabled: true,
@@ -16,10 +16,10 @@ window.UnleashClient = class {
       },
 
       // Enabled feature with no configured variants.
-      feat5: { name: 'disabled', enabled: false, feature_enabled: true },
+      noVariantFeat: { name: 'disabled', enabled: false, feature_enabled: true },
 
       // Disabled feature.
-      feat6: { name: 'disabled', enabled: false, feature_enabled: false },
+      disabledFeat: { name: 'disabled', enabled: false, feature_enabled: false },
     };
 
     // Variant returned for features that don't exist.

dev-packages/browser-integration-tests/suites/integrations/featureFlags/unleash/withScope/test.ts

@@ -0,0 +1,65 @@
+import { expect } from '@playwright/test';
+
+import { sentryTest } from '../../../../../utils/fixtures';
+
+import { envelopeRequestParser, shouldSkipFeatureFlagsTest, waitForErrorRequest } from '../../../../../utils/helpers';
+
+import type { Scope } from '@sentry/browser';
+
+sentryTest('Flag evaluations in forked scopes are stored separately.', async ({ getLocalTestUrl, page }) => {
+  if (shouldSkipFeatureFlagsTest()) {
+    sentryTest.skip();
+  }
+
+  await page.route('https://dsn.ingest.sentry.io/**/*', route => {
+    return route.fulfill({
+      status: 200,
+      contentType: 'application/json',
+      body: JSON.stringify({ id: 'test-id' }),
+    });
+  });
+
+  const url = await getLocalTestUrl({ testDir: __dirname, skipDsnRouteHandler: true });
+  await page.goto(url);
+
+  const forkedReqPromise = waitForErrorRequest(page, event => !!event.tags && event.tags.isForked === true);
+  const mainReqPromise = waitForErrorRequest(page, event => !!event.tags && event.tags.isForked === false);
+
+  await page.evaluate(() => {
+    const Sentry = (window as any).Sentry;
+    const errorButton = document.querySelector('#error') as HTMLButtonElement;
+    const unleash = new (window as any).UnleashClient();
+
+    unleash.isEnabled('strFeat');
+
+    Sentry.withScope((scope: Scope) => {
+      unleash.isEnabled('disabledFeat');
+      unleash.isEnabled('strFeat');
+      scope.setTag('isForked', true);
+      if (errorButton) {
+        errorButton.click();
+      }
+    });
+
+    unleash.isEnabled('noPayloadFeat');
+    Sentry.getCurrentScope().setTag('isForked', false);
+    errorButton.click();
+    return true;
+  });
+
+  const forkedReq = await forkedReqPromise;
+  const forkedEvent = envelopeRequestParser(forkedReq);
+
+  const mainReq = await mainReqPromise;
+  const mainEvent = envelopeRequestParser(mainReq);
+
+  expect(forkedEvent.contexts?.flags?.values).toEqual([
+    { flag: 'disabledFeat', result: false },
+    { flag: 'strFeat', result: true },
+  ]);
+
+  expect(mainEvent.contexts?.flags?.values).toEqual([
+    { flag: 'strFeat', result: true },
+    { flag: 'noPayloadFeat', result: true },
+  ]);
+});