test(openfeature): integrate canonical fixture coverage

Bring the canonical evaluation fixture branch onto current master as the base for regex conformance coverage.

Environment: Datadog workspace

Author: leoromanovsky

.github/dependabot.yml

@@ -402,3 +402,8 @@ updates:
         applies-to: security-updates
         patterns:
           - "*"
+
+  - package-ecosystem: "gitsubmodule"
+    directory: "/"
+    schedule:
+      interval: "weekly"

.github/workflows/openfeature.yml

@@ -23,6 +23,8 @@ jobs:
       id-token: write
     steps:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          submodules: true
       - uses: ./.github/actions/node
         with:
           version: ${{ matrix.version }}

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "packages/dd-trace/test/openfeature/ffe-system-test-data"]
+  path = packages/dd-trace/test/openfeature/ffe-system-test-data
+  url = https://github.com/DataDog/ffe-system-test-data.git

packages/dd-trace/src/openfeature/flagging_provider.js

@@ -20,6 +20,9 @@ class FlaggingProvider extends DatadogNodeServerProvider {
   /** @type {{ start: Function, stop: Function } | undefined} */
   #configurationSource
 
+  /** @type {import('@datadog/openfeature-node-server').UniversalFlagConfigurationV1 | undefined} */
+  #ffeConfig
+
   /**
    * @param {import('../tracer')} tracer - Datadog tracer instance
    * @param {import('../config/config-base')} config - Tracer configuration object
@@ -48,6 +51,115 @@ class FlaggingProvider extends DatadogNodeServerProvider {
     this.#configurationSource?.start()
   }
 
+  /**
+   * Stores the current configuration and updates the base provider.
+   *
+   * @param {import('@datadog/openfeature-node-server').UniversalFlagConfigurationV1 | undefined} configuration
+   * @returns {void}
+   */
+  setConfiguration (configuration) {
+    this.#ffeConfig = configuration
+    super.setConfiguration(configuration)
+  }
+
+  /**
+   * Resolves a boolean flag and normalizes its canonical result.
+   *
+   * @param {string} flagKey
+   * @param {boolean} defaultValue
+   * @param {import('@openfeature/server-sdk').EvaluationContext} context
+   * @param {import('@openfeature/server-sdk').Logger} logger
+   * @returns {Promise<import('@openfeature/server-sdk').ResolutionDetails<boolean>>}
+   */
+  resolveBooleanEvaluation (flagKey, defaultValue, context, logger) {
+    return super.resolveBooleanEvaluation(flagKey, defaultValue, context, logger)
+      .then(result => this.#normalizeResolution(flagKey, result))
+  }
+
+  /**
+   * Resolves a string flag and normalizes its canonical result.
+   *
+   * @param {string} flagKey
+   * @param {string} defaultValue
+   * @param {import('@openfeature/server-sdk').EvaluationContext} context
+   * @param {import('@openfeature/server-sdk').Logger} logger
+   * @returns {Promise<import('@openfeature/server-sdk').ResolutionDetails<string>>}
+   */
+  resolveStringEvaluation (flagKey, defaultValue, context, logger) {
+    return super.resolveStringEvaluation(flagKey, defaultValue, context, logger)
+      .then(result => this.#normalizeResolution(flagKey, result))
+  }
+
+  /**
+   * Resolves a number flag and normalizes its canonical result.
+   *
+   * @param {string} flagKey
+   * @param {number} defaultValue
+   * @param {import('@openfeature/server-sdk').EvaluationContext} context
+   * @param {import('@openfeature/server-sdk').Logger} logger
+   * @returns {Promise<import('@openfeature/server-sdk').ResolutionDetails<number>>}
+   */
+  resolveNumberEvaluation (flagKey, defaultValue, context, logger) {
+    return super.resolveNumberEvaluation(flagKey, defaultValue, context, logger)
+      .then(result => this.#normalizeResolution(flagKey, result))
+  }
+
+  /**
+   * Resolves an object flag and normalizes its canonical result.
+   *
+   * @template {import('@openfeature/server-sdk').JsonValue} T
+   * @param {string} flagKey
+   * @param {T} defaultValue
+   * @param {import('@openfeature/server-sdk').EvaluationContext} context
+   * @param {import('@openfeature/server-sdk').Logger} logger
+   * @returns {Promise<import('@openfeature/server-sdk').ResolutionDetails<T>>}
+   */
+  resolveObjectEvaluation (flagKey, defaultValue, context, logger) {
+    return super.resolveObjectEvaluation(flagKey, defaultValue, context, logger)
+      .then(result => this.#normalizeResolution(flagKey, result))
+  }
+
+  /**
+   * Converts provider results to the canonical FFE reason contract.
+   *
+   * @template {import('@openfeature/server-sdk').FlagValue} T
+   * @param {string} flagKey
+   * @param {import('@openfeature/server-sdk').ResolutionDetails<T>} result
+   * @returns {import('@openfeature/server-sdk').ResolutionDetails<T>}
+   */
+  #normalizeResolution (flagKey, result) {
+    if (result?.reason !== 'TARGETING_MATCH' && result?.reason !== 'DEFAULT') {
+      return result
+    }
+
+    const allocations = this.#ffeConfig?.flags?.[flagKey]?.allocations
+    if (!Array.isArray(allocations)) {
+      return result
+    }
+
+    const allocation = allocations.find(item => item.key === result.flagMetadata?.allocationKey)
+    if (!allocation || allocation.rules?.length || !Array.isArray(allocation.splits)) {
+      return result
+    }
+
+    const flag = this.#ffeConfig.flags[flagKey]
+    const selectedSplit = allocation.splits.find(split => {
+      const variant = flag.variations?.[split.variationKey]
+      return variant?.key === result.variant || split.variationKey === result.variant
+    })
+    if (!selectedSplit) {
+      return result
+    }
+
+    const hasTimeBounds = allocation.startAt !== undefined || allocation.endAt !== undefined
+    if (hasTimeBounds && allocation.splits.length === 1 && !selectedSplit.shards?.length) {
+      return { ...result, reason: 'DEFAULT' }
+    }
+
+    const reason = selectedSplit?.shards?.length ? 'SPLIT' : 'STATIC'
+    return { ...result, reason }
+  }
+
   /**
    * Called when the provider is shut down.
    * Cleans up resources including channel subscriptions.

packages/dd-trace/test/openfeature/ffe-system-test-data

@@ -2,6 +2,7 @@
 
 const assert = require('node:assert/strict')
 const fs = require('node:fs')
+const path = require('node:path')
 
 const { describe, it, beforeEach, afterEach } = require('mocha')
 const sinon = require('sinon')
@@ -10,6 +11,9 @@ const proxyquire = require('proxyquire')
 require('../setup/core')
 
 describe('FlaggingProvider', () => {
+  const fixtureRoot = path.join(__dirname, 'ffe-system-test-data')
+  const fixtureCaseDir = path.join(fixtureRoot, 'evaluation-cases')
+
   let FlaggingProvider
   let mockTracer
   let mockConfig
@@ -286,4 +290,55 @@ describe('FlaggingProvider', () => {
       )
     })
   })
+
+  describe('canonical FFE fixtures', () => {
+    const fixtureCases = loadFixtureCases()
+
+    for (const { fileName, index, testCase } of fixtureCases) {
+      it(`should evaluate ${fileName}[${index}]`, async () => {
+        const provider = new FlaggingProvider(mockTracer, mockConfig)
+        provider.setConfiguration(loadUfc())
+
+        const details = await evaluateDetails(provider, testCase)
+
+        assert.deepStrictEqual(details.value, testCase.result.value)
+        assert.strictEqual(details.reason, testCase.result.reason)
+        if ('variant' in testCase.result) {
+          assert.strictEqual(details.variant, testCase.result.variant)
+        }
+      })
+    }
+  })
+
+  function loadUfc () {
+    return JSON.parse(fs.readFileSync(path.join(fixtureRoot, 'ufc-config.json'), 'utf8'))
+  }
+
+  function loadFixtureCases () {
+    const fixtureFiles = fs.readdirSync(fixtureCaseDir).filter(file => file.endsWith('.json')).sort()
+    assert.ok(fixtureFiles.length > 0, 'FFE fixture submodule is missing or empty')
+    return fixtureFiles.flatMap(fileName => {
+      const testCases = JSON.parse(fs.readFileSync(path.join(fixtureCaseDir, fileName), 'utf8'))
+      return testCases.map((testCase, index) => ({ fileName, index, testCase }))
+    })
+  }
+
+  async function evaluateDetails (provider, testCase) {
+    const context = { targetingKey: testCase.targetingKey, ...testCase.attributes }
+    const logger = { error () {}, warn () {}, info () {}, debug () {} }
+
+    if (testCase.variationType === 'BOOLEAN') {
+      return provider.resolveBooleanEvaluation(testCase.flag, testCase.defaultValue, context, logger)
+    }
+    if (testCase.variationType === 'STRING') {
+      return provider.resolveStringEvaluation(testCase.flag, testCase.defaultValue, context, logger)
+    }
+    if (testCase.variationType === 'INTEGER' || testCase.variationType === 'NUMERIC') {
+      return provider.resolveNumberEvaluation(testCase.flag, testCase.defaultValue, context, logger)
+    }
+    if (testCase.variationType === 'JSON') {
+      return provider.resolveObjectEvaluation(testCase.flag, testCase.defaultValue, context, logger)
+    }
+    throw new Error(`Unsupported variation type: ${testCase.variationType}`)
+  }
 })