test(browser): address runtime smoke feedback

Author: leoromanovsky

scripts/test-package-install.sh

@@ -5,6 +5,21 @@ set -e
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 # Get the repo root (parent of scripts/)
 REPO_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+BROWSER_PACKAGE_JSON="$REPO_ROOT/packages/browser/package.json"
+BROWSER_PACKAGE_JSON_BACKUP="$BROWSER_PACKAGE_JSON.backup"
+ROOT_YARN_LOCK="$REPO_ROOT/yarn.lock"
+ROOT_YARN_LOCK_BACKUP="$ROOT_YARN_LOCK.backup"
+
+restore_package_files() {
+  if [[ -f "$BROWSER_PACKAGE_JSON_BACKUP" ]]; then
+    mv -f "$BROWSER_PACKAGE_JSON_BACKUP" "$BROWSER_PACKAGE_JSON"
+  fi
+  if [[ -f "$ROOT_YARN_LOCK_BACKUP" ]]; then
+    mv -f "$ROOT_YARN_LOCK_BACKUP" "$ROOT_YARN_LOCK"
+  fi
+}
+
+trap restore_package_files EXIT
 
 echo "Testing @datadog/openfeature-browser package installation..."
 echo "Repository root: $REPO_ROOT"
@@ -31,8 +46,8 @@ echo "Installing packed core into browser package..."
 cd "$REPO_ROOT/packages/browser"
 
 # Save original package.json and yarn.lock
-cp package.json package.json.backup
-cp "$REPO_ROOT/yarn.lock" "$REPO_ROOT/yarn.lock.backup"
+cp "$BROWSER_PACKAGE_JSON" "$BROWSER_PACKAGE_JSON_BACKUP"
+cp "$ROOT_YARN_LOCK" "$ROOT_YARN_LOCK_BACKUP"
 
 # Install the tarball temporarily
 yarn add "@datadog/flagging-core@file:$TEST_APP_DIR/core.tgz" --silent
@@ -41,12 +56,10 @@ yarn add "@datadog/flagging-core@file:$TEST_APP_DIR/core.tgz" --silent
 echo "Packing @datadog/openfeature-browser..."
 yarn pack --filename "$TEST_APP_DIR/browser.tgz" > /dev/null 2>&1
 
-# Restore browser package to original state using git
+# Restore browser package to original state
 echo "Restoring browser package..."
-rm package.json
-mv package.json.backup package.json
-rm "$REPO_ROOT/yarn.lock"
-mv "$REPO_ROOT/yarn.lock.backup" "$REPO_ROOT/yarn.lock"
+restore_package_files
+trap - EXIT
 
 cd "$REPO_ROOT"
 

test-app/src/precomputed.ts

@@ -25,15 +25,19 @@ const configuration = configurationFromString(
     rules: { response: 'ignored by the precomputed entrypoint' },
   })
 )
-const roundTrip = JSON.parse(configurationToString(configuration)) as Record<string, unknown>
+const serialized = configurationToString(configuration)
+const roundTripWire = JSON.parse(serialized) as Record<string, unknown>
+const restored = configurationFromString(serialized)
 const flag = configuration.precomputed?.response.data.attributes.flags['precomputed-flag']
+const restoredFlag = restored.precomputed?.response.data.attributes.flags['precomputed-flag']
 
 assert(flag?.variationValue === true, 'precomputed flag was not parsed')
 assert(configuration.rules === undefined, 'precomputed entrypoint parsed rules')
-assert(roundTrip.rules === undefined, 'precomputed entrypoint serialized rules')
+assert(roundTripWire.rules === undefined, 'precomputed entrypoint serialized rules')
+assert(restoredFlag?.variationValue === true, 'precomputed flag did not survive a round trip')
 
 reportSuccess({
   entrypoint: 'precomputed',
-  booleanValue: flag.variationValue,
+  booleanValue: restoredFlag.variationValue,
   rulesExcluded: true,
 })

test-app/src/protobuf.ts

@@ -1,11 +1,32 @@
 import { evaluateRulesBasedConfiguration, matchesRule, OperatorType } from '@datadog/flagging-core'
-import { configurationFromString, configurationToString } from '@datadog/openfeature-browser'
+import { configurationFromString, configurationToString, DatadogProvider } from '@datadog/openfeature-browser'
 import { assert, reportSuccess } from './smoke'
 
 const protobufRulesResponse =
   'EgRwcm9kGigKDGJyb3dzZXItZmxhZxIYEAQaAigBIhAKCmFsbG9jYXRpb24iAiADGigKDGludGVnZXItZmxhZxIYEAIaAhgqIhAKCmFsbG9jYXRpb24iAiADKgJvbg=='
+const precomputedResponse = {
+  data: {
+    attributes: {
+      createdAt: '2026-07-06T23:01:56.822Z',
+      flags: {
+        'provider-flag': {
+          allocationKey: 'allocation',
+          variationKey: 'on',
+          variationType: 'BOOLEAN',
+          variationValue: true,
+          reason: 'STATIC',
+          doLog: false,
+        },
+      },
+    },
+  },
+}
 const configuration = configurationFromString(
-  JSON.stringify({ version: 1, rules: { response: protobufRulesResponse } })
+  JSON.stringify({
+    version: 1,
+    precomputed: { response: JSON.stringify(precomputedResponse) },
+    rules: { response: protobufRulesResponse },
+  })
 )
 
 assert(configuration.rules, 'protobuf rules configuration was not decoded')
@@ -31,6 +52,16 @@ const integerDetails = evaluateRulesBasedConfiguration(
   context,
   console
 )
+const provider = new DatadogProvider({
+  clientToken: 'test-token',
+  site: 'datadoghq.com',
+  env: 'test',
+  enableExposureLogging: false,
+  enableFlagEvaluationTracking: false,
+  enableRumFeatureFlagTracking: false,
+  initialFlagsConfiguration: configuration,
+})
+const providerDetails = provider.resolveBooleanEvaluation('provider-flag', false, context, console)
 const restored = configurationFromString(configurationToString(configuration))
 const sha256Matched = matchesRule(
   {
@@ -50,6 +81,7 @@ const sha256Matched = matchesRule(
 
 assert(booleanDetails.value === true, 'protobuf boolean evaluation returned the wrong value')
 assert(integerDetails.value === 42, 'protobuf int64 evaluation returned the wrong value')
+assert(providerDetails.value === true, 'DatadogProvider did not evaluate the decoded configuration')
 assert(
   restored.rules?.response.$typeName === 'datadog.ffe.flagging.ufc.v1.FlagsConfiguration',
   'protobuf rules configuration did not survive a round trip'
@@ -61,5 +93,6 @@ reportSuccess({
   protobufTypeName: configuration.rules.response.$typeName,
   booleanValue: booleanDetails.value,
   integerValue: integerDetails.value,
+  providerValue: providerDetails.value,
   sha256Matched,
 })

test-app/tests/smoke.spec.ts

@@ -32,6 +32,7 @@ test('decodes and evaluates packed protobuf rules in Chromium', async ({ page })
     protobufTypeName: 'datadog.ffe.flagging.ufc.v1.FlagsConfiguration',
     booleanValue: true,
     integerValue: 42,
+    providerValue: true,
     sha256Matched: true,
   })
 })
@@ -49,6 +50,7 @@ test('decodes protobuf without native text or bigint globals', async ({ page })
   expect(result.protobufTypeName).toBe('datadog.ffe.flagging.ufc.v1.FlagsConfiguration')
   expect(result.booleanValue).toBe(true)
   expect(result.integerValue).toBe(42)
+  expect(result.providerValue).toBe(true)
 })
 
 test('executes the packed precomputed entrypoint in Chromium', async ({ page }) => {