diff --git a/.github/workflows/csharp.yml b/.github/workflows/csharp.yml index f417b0e87..300016b82 100644 --- a/.github/workflows/csharp.yml +++ b/.github/workflows/csharp.yml @@ -5,19 +5,21 @@ on: branches: [ master ] pull_request: branches: [ master ] + types: [ opened, synchronize, reopened, ready_for_review ] jobs: lintCodebase: + name: Lint Codebase if Not Draft + if: github.event.pull_request.draft == false runs-on: ubuntu-latest - name: Lint Codebase steps: - name: Checkout code - uses: actions/checkout@v3 + uses: actions/checkout@v4 with: # Full git history is needed to get a proper list of changed files fetch-depth: 0 - name: Run Super-Linter - uses: github/super-linter@v4 + uses: github/super-linter@v7 env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} VALIDATE_ALL_CODEBASE: false @@ -27,7 +29,7 @@ jobs: netFrameworksAndUnitTest: name: Build Framework & Run Unit Tests needs: [ lintCodebase ] - runs-on: windows-2019 # required version for Framework 4.0 + runs-on: windows-2022 env: REPO_SLUG: ${{ github.repository }} BUILD_NUMBER: ${{ github.run_id }} @@ -37,20 +39,56 @@ jobs: CURRENT_BRANCH: ${{ github.head_ref || github.ref_name }} steps: - name: Checkout code - uses: actions/checkout@v3 + uses: actions/checkout@v4 - name: Add msbuild to PATH uses: microsoft/setup-msbuild@v1 - name: Setup NuGet uses: NuGet/setup-nuget@v1 + - name: Download and Extract .NET Framework Reference Assemblies + run: | + # Create temp directory + New-Item -ItemType Directory -Path "temp_ref_assemblies" -Force + + # Download .NET 4.0 Reference Assemblies + echo "Downloading .NET 4.0 Reference Assemblies..." + Invoke-WebRequest -Uri "https://www.nuget.org/api/v2/package/Microsoft.NETFramework.ReferenceAssemblies.net40/1.0.3" -OutFile "temp_ref_assemblies/net40_ref.zip" + + # Download .NET 4.5 Reference Assemblies + echo "Downloading .NET 4.5 Reference Assemblies..." + Invoke-WebRequest -Uri "https://www.nuget.org/api/v2/package/Microsoft.NETFramework.ReferenceAssemblies.net45/1.0.3" -OutFile "temp_ref_assemblies/net45_ref.zip" + + # Extract .NET 4.0 Reference Assemblies + echo "Extracting .NET 4.0 Reference Assemblies..." + Expand-Archive -Path "temp_ref_assemblies/net40_ref.zip" -DestinationPath "temp_ref_assemblies/net40" -Force + if (Test-Path "temp_ref_assemblies/net40/build/.NETFramework/v4.0") { + echo "✓ .NET 4.0 Reference Assemblies extracted to workspace" + } + + # Extract .NET 4.5 Reference Assemblies + echo "Extracting .NET 4.5 Reference Assemblies..." + Expand-Archive -Path "temp_ref_assemblies/net45_ref.zip" -DestinationPath "temp_ref_assemblies/net45" -Force + if (Test-Path "temp_ref_assemblies/net45/build/.NETFramework/v4.5") { + echo "✓ .NET 4.5 Reference Assemblies extracted to workspace" + } - name: Restore NuGet packages run: nuget restore ./OptimizelySDK.NETFramework.sln - name: Build & strongly name assemblies - run: msbuild /p:SignAssembly=true /p:AssemblyOriginatorKeyFile=$(pwd)/keypair.snk /p:Configuration=Release ./OptimizelySDK.NETFramework.sln + run: | + # Build with workspace-relative reference assembly paths + $Net40RefPath = "$(pwd)\temp_ref_assemblies\net40\build\.NETFramework\v4.0" + $Net45RefPath = "$(pwd)\temp_ref_assemblies\net45\build\.NETFramework\v4.5" + + echo "Using .NET 4.0 Reference Assemblies from: $Net40RefPath" + echo "Using .NET 4.5 Reference Assemblies from: $Net45RefPath" + + msbuild /p:SignAssembly=true /p:AssemblyOriginatorKeyFile=$(pwd)/keypair.snk /p:Configuration=Release /p:FrameworkPathOverride="$Net45RefPath" ./OptimizelySDK.NETFramework.sln - name: Install & Run NUnit tests run: | - nuget install NUnit.Console -Version 3.15.2 -DirectDownload -OutputDirectory . + nuget install NUnit.Console -Version 3.18.1 -DirectDownload -OutputDirectory . # https://docs.nunit.org/articles/nunit/running-tests/Console-Command-Line.html - ./NUnit.ConsoleRunner.3.15.2\tools\nunit3-console.exe /timeout 10000 /process Separate ./OptimizelySDK.Tests/bin/Release/OptimizelySDK.Tests.dll + ./NUnit.ConsoleRunner.3.18.1\tools\nunit3-console.exe /timeout 10000 /process Separate ./OptimizelySDK.Tests/bin/Release/OptimizelySDK.Tests.dll + - name: Cleanup reference assemblies + run: Remove-Item -Path "temp_ref_assemblies" -Recurse -Force netStandard16: name: Build Standard 1.6 @@ -65,7 +103,7 @@ jobs: CURRENT_BRANCH: ${{ github.head_ref || github.ref_name }} steps: - name: Checkout code - uses: actions/checkout@v3 + uses: actions/checkout@v4 - name: Setup .NET uses: actions/setup-dotnet@v2 with: @@ -73,7 +111,7 @@ jobs: - name: Restore dependencies run: dotnet restore OptimizelySDK.NetStandard16/OptimizelySDK.NetStandard16.csproj - name: Build & strongly name assemblies - run: dotnet build OptimizelySDK.NetStandard16/OptimizelySDK.NetStandard16.csproj /p:SignAssembly=true /p:AssemblyOriginatorKeyFile=D:\a\csharp-sdk\csharp-sdk\keypair.snk -c Release + run: dotnet build OptimizelySDK.NetStandard16/OptimizelySDK.NetStandard16.csproj /p:SignAssembly=true /p:AssemblyOriginatorKeyFile=$(pwd)/keypair.snk -c Release netStandard20: name: Build Standard 2.0 @@ -88,7 +126,7 @@ jobs: CURRENT_BRANCH: ${{ github.head_ref || github.ref_name }} steps: - name: Checkout code - uses: actions/checkout@v3 + uses: actions/checkout@v4 - name: Setup .NET uses: actions/setup-dotnet@v2 with: @@ -96,7 +134,7 @@ jobs: - name: Restore dependencies run: dotnet restore OptimizelySDK.NetStandard20/OptimizelySDK.NetStandard20.csproj - name: Build & strongly name assemblies - run: dotnet build OptimizelySDK.NetStandard20/OptimizelySDK.NetStandard20.csproj /p:SignAssembly=true /p:AssemblyOriginatorKeyFile=D:\a\csharp-sdk\csharp-sdk\keypair.snk -c Release + run: dotnet build OptimizelySDK.NetStandard20/OptimizelySDK.NetStandard20.csproj /p:SignAssembly=true /p:AssemblyOriginatorKeyFile=$(pwd)/keypair.snk -c Release integration_tests: name: Run Integration Tests @@ -104,7 +142,6 @@ jobs: uses: optimizely/csharp-sdk/.github/workflows/integration_test.yml@master secrets: CI_USER_TOKEN: ${{ secrets.CI_USER_TOKEN }} - TRAVIS_COM_TOKEN: ${{ secrets.TRAVIS_COM_TOKEN }} fullstack_production_suite: name: Run Performance Tests @@ -114,4 +151,3 @@ jobs: FULLSTACK_TEST_REPO: ProdTesting secrets: CI_USER_TOKEN: ${{ secrets.CI_USER_TOKEN }} - TRAVIS_COM_TOKEN: ${{ secrets.TRAVIS_COM_TOKEN }} diff --git a/.github/workflows/csharp_release.yml b/.github/workflows/csharp_release.yml index 90e680a76..f4c1736cd 100644 --- a/.github/workflows/csharp_release.yml +++ b/.github/workflows/csharp_release.yml @@ -3,111 +3,192 @@ on: release: types: [ published ] # Trigger on published pre-releases and releases + workflow_dispatch: jobs: variables: name: Set Variables runs-on: ubuntu-latest env: - # ⚠️ IMPORTANT: tag should always start with integer & will be used verbatim to string end TAG: ${{ github.event.release.tag_name }} steps: - - name: Set semantic version variable + - name: Extract semantic version from tag id: set_version run: | - TAG=${{ env.TAG }} + # Remove the "v" prefix if it exists and extract the semantic version number SEMANTIC_VERSION=$(echo "${TAG}" | grep -Po "(?<=^|[^0-9])([0-9]+\.[0-9]+\.[0-9]+(\.[0-9]+)?(-[a-zA-Z]+[0-9]*)?)") + SEMANTIC_VERSION=${SEMANTIC_VERSION#"v"} if [ -z "${SEMANTIC_VERSION}" ]; then - echo "Tag did not start with a semantic version number (e.g., #.#.#; #.#.#.#; #.#.#.#-beta)" + echo "Error: Tag '${TAG}' does not start with a valid semantic version number (e.g., #.#.#; #.#.#.#; #.#.#.#-beta)" exit 1 fi + echo "Extracted semantic version: ${SEMANTIC_VERSION}" echo "semantic_version=${SEMANTIC_VERSION}" >> $GITHUB_OUTPUT - - name: Output tag & semantic version - id: outputs - run: | - echo ${{ env.TAG }} - echo ${{ steps.set_version.outputs.semantic_version }} outputs: - tag: ${{ env.TAG }} + tag: $TAG semanticVersion: ${{ steps.set_version.outputs.semantic_version }} buildFrameworkVersions: name: Build Framework versions needs: [ variables ] - runs-on: windows-2019 # required version for Framework 4.0 + runs-on: windows-2022 steps: - name: Checkout code - uses: actions/checkout@v3 + uses: actions/checkout@v4 with: ref: ${{ needs.variables.outputs.tag }} - name: Add msbuild to PATH - uses: microsoft/setup-msbuild@v1 + uses: microsoft/setup-msbuild@v2 - name: Setup NuGet - uses: NuGet/setup-nuget@v1 + uses: nuget/setup-nuget@v2 + - name: Download and Extract .NET Framework Reference Assemblies + run: | + # Create temp directory + New-Item -ItemType Directory -Path "temp_ref_assemblies" -Force + + # Download .NET 4.0 Reference Assemblies + echo "Downloading .NET 4.0 Reference Assemblies..." + Invoke-WebRequest -Uri "https://www.nuget.org/api/v2/package/Microsoft.NETFramework.ReferenceAssemblies.net40/1.0.3" -OutFile "temp_ref_assemblies/net40_ref.zip" + + # Download .NET 4.5 Reference Assemblies + echo "Downloading .NET 4.5 Reference Assemblies..." + Invoke-WebRequest -Uri "https://www.nuget.org/api/v2/package/Microsoft.NETFramework.ReferenceAssemblies.net45/1.0.3" -OutFile "temp_ref_assemblies/net45_ref.zip" + + # Extract .NET 4.0 Reference Assemblies + echo "Extracting .NET 4.0 Reference Assemblies..." + Expand-Archive -Path "temp_ref_assemblies/net40_ref.zip" -DestinationPath "temp_ref_assemblies/net40" -Force + if (Test-Path "temp_ref_assemblies/net40/build/.NETFramework/v4.0") { + echo "✓ .NET 4.0 Reference Assemblies extracted to workspace" + } + + # Extract .NET 4.5 Reference Assemblies + echo "Extracting .NET 4.5 Reference Assemblies..." + Expand-Archive -Path "temp_ref_assemblies/net45_ref.zip" -DestinationPath "temp_ref_assemblies/net45" -Force + if (Test-Path "temp_ref_assemblies/net45/build/.NETFramework/v4.5") { + echo "✓ .NET 4.5 Reference Assemblies extracted to workspace" + } - name: Restore NuGet packages run: nuget restore ./OptimizelySDK.NETFramework.sln - name: Build and strongly name assemblies - run: msbuild /p:SignAssembly=true /p:AssemblyOriginatorKeyFile=$(pwd)/keypair.snk /p:Configuration=Release ./OptimizelySDK.NETFramework.sln + run: | + # Build with workspace-relative reference assembly paths + $Net40RefPath = "$(pwd)\temp_ref_assemblies\net40\build\.NETFramework\v4.0" + $Net45RefPath = "$(pwd)\temp_ref_assemblies\net45\build\.NETFramework\v4.5" + + echo "Using .NET 4.0 Reference Assemblies from: $Net40RefPath" + echo "Using .NET 4.5 Reference Assemblies from: $Net45RefPath" + + msbuild /p:SignAssembly=true /p:AssemblyOriginatorKeyFile=$(pwd)/keypair.snk /p:Configuration=Release /p:FrameworkPathOverride="$Net45RefPath" ./OptimizelySDK.NETFramework.sln + - name: Cleanup reference assemblies + run: Remove-Item -Path "temp_ref_assemblies" -Recurse -Force - name: Upload Framework artifacts - uses: actions/upload-artifact@v2 + uses: actions/upload-artifact@v4 with: - name: nuget-files + name: unsigned-dlls if-no-files-found: error path: ./**/bin/Release/**/Optimizely*.dll buildStandard16: name: Build Standard 1.6 version needs: [ variables ] - runs-on: windows-latest + runs-on: windows-2022 steps: - name: Checkout code - uses: actions/checkout@v3 + uses: actions/checkout@v4 with: ref: ${{ needs.variables.outputs.tag }} - name: Setup .NET - uses: actions/setup-dotnet@v2 + uses: actions/setup-dotnet@v4 - name: Restore dependencies run: dotnet restore OptimizelySDK.NetStandard16/OptimizelySDK.NetStandard16.csproj - name: Build and strongly name assemblies run: dotnet build OptimizelySDK.NetStandard16/OptimizelySDK.NetStandard16.csproj /p:SignAssembly=true /p:AssemblyOriginatorKeyFile=$(pwd)/keypair.snk -c Release - name: Upload Standard 1.6 artifact - uses: actions/upload-artifact@v2 + uses: actions/upload-artifact@v4 with: - name: nuget-files + name: unsigned-dlls if-no-files-found: error path: ./**/bin/Release/**/Optimizely*.dll buildStandard20: name: Build Standard 2.0 version needs: [ variables ] - runs-on: windows-latest + runs-on: windows-2022 steps: - name: Checkout code - uses: actions/checkout@v3 + uses: actions/checkout@v4 with: ref: ${{ needs.variables.outputs.tag }} - name: Setup .NET - uses: actions/setup-dotnet@v2 + uses: actions/setup-dotnet@v4 - name: Restore dependencies run: dotnet restore OptimizelySDK.NetStandard20/OptimizelySDK.NetStandard20.csproj - name: Build and strongly name Standard 2.0 project run: dotnet build OptimizelySDK.NetStandard20/OptimizelySDK.NetStandard20.csproj /p:SignAssembly=true /p:AssemblyOriginatorKeyFile=$(pwd)/keypair.snk -c Release - name: Build and strongly name assemblies - uses: actions/upload-artifact@v2 + uses: actions/upload-artifact@v4 with: - name: nuget-files + name: unsigned-dlls if-no-files-found: error path: ./**/bin/Release/**/Optimizely*.dll - pack: - name: Sign & pack NuGet package + sign: + name: Send DLLs for signing needs: [ variables, buildFrameworkVersions, buildStandard16, buildStandard20 ] runs-on: ubuntu-latest + env: + # TODO: Replace actual values + SIGNING_SERVER_PRIVATE_KEY: ${{ secrets.SIGNING_SERVER_PRIVATE_KEY }} + SIGNING_SERVER_HOST: ${{ secrets.SIGNING_SERVER_HOST }} + SIGNING_SERVER_UPLOAD_PATH: /path/to/UPLOAD/directory + SIGNING_SERVER_DOWNLOAD_PATH: /path/to/DOWNLOAD/directory + steps: + # TODO: Remove this when we're ready to automate + - name: Temporarily halt progress + run: exit 1 + - name: Download the unsigned files + uses: actions/download-artifact@v4 + with: + name: unsigned-dlls + path: ./unsigned-dlls + - name: Setup SSH + uses: shimataro/ssh-key-action@v2 + with: + key: $SIGNING_SERVER_PRIVATE_KEY + - name: Send files to signing server + run: scp -r ./unsigned-dlls $SIGNING_SERVER_HOST:$SIGNING_SERVER_UPLOAD_PATH + - name: Wait for artifact to be published + run: | + for i in {1..60}; do + # Replace with actual path + if ssh $SIGNING_SERVER_HOST "ls $SIGNING_SERVER_DOWNLOAD_PATH"; then + exit 0 + fi + sleep 10 + done + exit 1 + - name: Download signed files + run: | + mkdir ./signed-dlls + scp -r $SIGNING_SERVER_HOST:$SIGNING_SERVER_DOWNLOAD_PATH ./signed-dlls + - name: Delete signed files from server + run: ssh $SIGNING_SERVER_HOST "rm -rf $SIGNING_SERVER_DOWNLOAD_PATH/*" + - name: Upload signed files + uses: actions/upload-artifact@v4 + with: + name: signed-dlls + if-no-files-found: error + path: ./signed-dlls + + pack: + name: Pack NuGet package + needs: [ variables, sign ] + runs-on: ubuntu-latest env: VERSION: ${{ needs.variables.outputs.semanticVersion }} steps: - name: Checkout code - uses: actions/checkout@v3 + uses: actions/checkout@v4 with: ref: ${{ needs.variables.outputs.tag }} - name: Install mono @@ -115,55 +196,25 @@ jobs: sudo apt update sudo apt install -y mono-devel - name: Download NuGet files - uses: actions/download-artifact@v2 + uses: actions/download-artifact@v4 with: - name: nuget-files - path: ./nuget-files + name: signed-dlls + path: ./signed-dlls - name: Organize files run: | - pushd ./nuget-files + pushd ./signed-dlls # Move all dlls to the root directory - find . -type f -name "*.dll" -exec mv {} . \; + find . -type f -name "*.dll" -exec mv {} . popd # Create directories mkdir -p nuget/lib/net35/ nuget/lib/net40/ nuget/lib/net45/ nuget/lib/netstandard1.6/ nuget/lib/netstandard2.0/ pushd ./nuget # Move files to directories - mv ../nuget-files/OptimizelySDK.Net35.dll lib/net35/ - mv ../nuget-files/OptimizelySDK.Net40.dll lib/net40/ - mv ../nuget-files/OptimizelySDK.dll lib/net45/ - mv ../nuget-files/OptimizelySDK.NetStandard16.dll lib/netstandard1.6/ - mv ../nuget-files/OptimizelySDK.NetStandard20.dll lib/netstandard2.0/ - popd - - name: Setup signing prerequisites - env: - CERTIFICATE_P12: ${{ secrets.CERTIFICATE_P12 }} - CERTIFICATE_PASSWORD: ${{ secrets.CERTIFICATE_PASSWORD }} - run: | - pushd ./nuget - echo $CERTIFICATE_P12 | base64 --decode > authenticode.pfx - openssl pkcs12 -in authenticode.pfx -nocerts -nodes -legacy -out key.pem -password env:CERTIFICATE_PASSWORD - openssl rsa -in key.pem -outform PVK -pvk-none -out authenticode.pvk - openssl pkcs12 -in authenticode.pfx -nokeys -nodes -legacy -out cert.pem -password env:CERTIFICATE_PASSWORD - openssl crl2pkcs7 -nocrl -certfile cert.pem -outform DER -out authenticode.spc - popd - - name: Sign the DLLs - run: | - pushd ./nuget - find . -type f -name "*.dll" -print0 | while IFS= read -r -d '' file; do - echo "Signing ${file}" - signcode \ - -spc ./authenticode.spc \ - -v ./authenticode.pvk \ - -a sha1 -$ commercial \ - -n "Optimizely, Inc" \ - -i "https://www.optimizely.com/" \ - -t "http://timestamp.digicert.com" \ - -tr 10 \ - ${file} - rm ${file}.bak - done - rm *.spc *.pem *.pvk *.pfx + mv ../signed-dlls/OptimizelySDK.Net35.dll lib/net35/ + mv ../signed-dlls/OptimizelySDK.Net40.dll lib/net40/ + mv ../signed-dlls/OptimizelySDK.dll lib/net45/ + mv ../signed-dlls/OptimizelySDK.NetStandard16.dll lib/netstandard1.6/ + mv ../signed-dlls/OptimizelySDK.NetStandard20.dll lib/netstandard2.0/ popd - name: Create nuspec # Uses env.VERSION in OptimizelySDK.nuspec.template @@ -176,27 +227,29 @@ jobs: nuget pack OptimizelySDK.nuspec popd - name: Upload nupkg artifact - uses: actions/upload-artifact@v2 + uses: actions/upload-artifact@v4 with: name: nuget-package if-no-files-found: error path: ./nuget/Optimizely.SDK.${{ env.VERSION }}.nupkg publish: - name: Publish package to NuGet + name: Publish package to NuGet after reviewing the artifact needs: [ variables, pack ] runs-on: ubuntu-latest + # Review the `nuget-package` artifact ensuring the dlls are + # organized and signed before approving. + environment: 'i-reviewed-nuget-package-artifact' env: VERSION: ${{ needs.variables.outputs.semanticVersion }} steps: - name: Download NuGet files - uses: actions/download-artifact@v2 + uses: actions/download-artifact@v4 with: name: nuget-package path: ./nuget - name: Setup .NET - uses: actions/setup-dotnet@v3 + uses: actions/setup-dotnet@v4 - name: Publish NuGet package - # Unset secrets.NUGET_API_KEY to simulate dry run run: | dotnet nuget push ./nuget/Optimizely.SDK.${{ env.VERSION }}.nupkg --source https://api.nuget.org/v3/index.json --api-key ${{ secrets.NUGET_API_KEY }} diff --git a/.github/workflows/integration_test.yml b/.github/workflows/integration_test.yml index 423e2dfed..b56cc8817 100644 --- a/.github/workflows/integration_test.yml +++ b/.github/workflows/integration_test.yml @@ -9,8 +9,6 @@ on: secrets: CI_USER_TOKEN: required: true - TRAVIS_COM_TOKEN: - required: true jobs: test: runs-on: ubuntu-latest @@ -19,19 +17,21 @@ jobs: with: # You should create a personal access token and store it in your repository token: ${{ secrets.CI_USER_TOKEN }} - repository: 'optimizely/travisci-tools' - path: 'home/runner/travisci-tools' + repository: 'optimizely/ci-helper-tools' + path: 'home/runner/ci-helper-tools' ref: 'master' - name: set SDK Branch if PR + env: + HEAD_REF: ${{ github.head_ref }} if: ${{ github.event_name == 'pull_request' }} run: | - echo "SDK_BRANCH=${{ github.head_ref }}" >> $GITHUB_ENV - echo "TRAVIS_BRANCH=${{ github.head_ref }}" >> $GITHUB_ENV + echo "SDK_BRANCH=$HEAD_REF" >> $GITHUB_ENV - name: set SDK Branch if not pull request + env: + REF_NAME: ${{ github.ref_name }} if: ${{ github.event_name != 'pull_request' }} run: | - echo "SDK_BRANCH=${{ github.ref_name }}" >> $GITHUB_ENV - echo "TRAVIS_BRANCH=${{ github.ref_name }}" >> $GITHUB_ENV + echo "SDK_BRANCH=$REF_NAME" >> $GITHUB_ENV - name: Trigger build env: SDK: csharp @@ -47,9 +47,8 @@ jobs: PULL_REQUEST_SHA: ${{ github.event.pull_request.head.sha }} PULL_REQUEST_NUMBER: ${{ github.event.pull_request.number }} UPSTREAM_SHA: ${{ github.sha }} - TOKEN: ${{ secrets.TRAVIS_COM_TOKEN }} EVENT_MESSAGE: ${{ github.event.message }} HOME: 'home/runner' run: | echo "$GITHUB_CONTEXT" - home/runner/travisci-tools/trigger-script-with-status-update.sh + home/runner/ci-helper-tools/trigger-script-with-status-update.sh diff --git a/.github/workflows/sonarqube.yml b/.github/workflows/sonarqube.yml deleted file mode 100644 index b60e311dd..000000000 --- a/.github/workflows/sonarqube.yml +++ /dev/null @@ -1,45 +0,0 @@ -name: SonarQube -on: - push: - branches: - - dsier/sonarqube -jobs: - build: - name: Build - runs-on: windows-latest - steps: - - name: Set up JDK 11 - uses: actions/setup-java@v1 - with: - java-version: 1.11 - - uses: actions/checkout@v2 - with: - fetch-depth: 0 # Shallow clones should be disabled for a better relevancy of analysis - - name: Cache SonarCloud packages - uses: actions/cache@v1 - with: - path: ~\sonar\cache - key: ${{ runner.os }}-sonar - restore-keys: ${{ runner.os }}-sonar - - name: Cache SonarCloud scanner - id: cache-sonar-scanner - uses: actions/cache@v1 - with: - path: .\.sonar\scanner - key: ${{ runner.os }}-sonar-scanner - restore-keys: ${{ runner.os }}-sonar-scanner - - name: Install SonarCloud scanner - if: steps.cache-sonar-scanner.outputs.cache-hit != 'true' - shell: powershell - run: | - New-Item -Path .\.sonar\scanner -ItemType Directory - dotnet tool update dotnet-sonarscanner --tool-path .\.sonar\scanner - - name: Build and analyze - env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # Needed to get PR information, if any - SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }} - shell: powershell - run: | - .\.sonar\scanner\dotnet-sonarscanner begin /k:"csharpsdk" /o:"optidevx" /d:sonar.login="${{ secrets.SONAR_TOKEN }}" /d:sonar.host.url="https://sonarcloud.io" - dotnet build .\OptimizelySDK\ - .\.sonar\scanner\dotnet-sonarscanner end /d:sonar.login="${{ secrets.SONAR_TOKEN diff --git a/CHANGELOG.md b/CHANGELOG.md index 7b9620be0..dca45cda2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,85 @@ # Optimizely C# SDK Changelog +## 4.1.0 +November 7th, 2024 + +### Enhancement + +- Added support for batch processing in `DecideAll` and `DecideForKeys`, enabling more efficient handling of multiple decisions in the User Profile Service. ([#375](https://github.com/optimizely/csharp-sdk/pull/375)) + +### Bug Fixes +- GitHub Actions YAML files vulnerable to script injections ([#372](https://github.com/optimizely/csharp-sdk/pull/372)) + +## 4.0.0 +January 16th, 2024 + +### New Features + +#### Advanced Audience Targeting + +The 4.0.0 release introduces a new primary feature, [Advanced Audience Targeting]( https://docs.developers.optimizely.com/feature-experimentation/docs/optimizely-data-platform-advanced-audience-targeting) + enabled through integration with [Optimizely Data Platform (ODP)](https://docs.developers.optimizely.com/optimizely-data-platform/docs) ( + [#305](https://github.com/optimizely/csharp-sdk/pull/305), + [#310](https://github.com/optimizely/csharp-sdk/pull/310), + [#311](https://github.com/optimizely/csharp-sdk/pull/311), + [#315](https://github.com/optimizely/csharp-sdk/pull/315), + [#321](https://github.com/optimizely/csharp-sdk/pull/321), + [#322](https://github.com/optimizely/csharp-sdk/pull/322), + [#323](https://github.com/optimizely/csharp-sdk/pull/323), + [#324](https://github.com/optimizely/csharp-sdk/pull/324) + ). + +You can use ODP, a high-performance [Customer Data Platform (CDP)]( https://www.optimizely.com/optimization-glossary/customer-data-platform/), to easily create complex +real-time segments (RTS) using first-party and 50+ third-party data sources out of the box. You can create custom schemas that support the user attributes important +for your business, and stitch together user behavior done on different devices to better understand and target your customers for personalized user experiences. ODP can +be used as a single source of truth for these segments in any Optimizely or 3rd party tool. + +With ODP accounts integrated into Optimizely projects, you can build audiences using segments pre-defined in ODP. The SDK will fetch the segments for given users and +make decisions using the segments. For access to ODP audience targeting in your Feature Experimentation account, please contact your Optimizely Customer Success Manager. + +This version includes the following changes: +- New API added to `OptimizelyUserContext`: + - `FetchQualifiedSegments()`: this API will retrieve user segments from the ODP server. The fetched segments will be used for audience evaluation. The fetched data will be stored in the local cache to avoid repeated network delays. + - When an `OptimizelyUserContext` is created, the SDK will automatically send an identify request to the ODP server to facilitate observing user activities. +- New APIs added to `OptimizelyClient`: + - `SendOdpEvent()`: customers can build/send arbitrary ODP events that will bind user identifiers and data to user profiles in ODP. + +For details, refer to our documentation pages: +- [Advanced Audience Targeting](https://docs.developers.optimizely.com/feature-experimentation/docs/optimizely-data-platform-advanced-audience-targeting) +- [Server SDK Support](https://docs.developers.optimizely.com/feature-experimentation/v1.0/docs/advanced-audience-targeting-for-server-side-sdks) +- [Initialize C# SDK](https://docs.developers.optimizely.com/feature-experimentation/docs/initialize-sdk-csharp) +- [OptimizelyUserContext C# SDK](https://docs.developers.optimizely.com/feature-experimentation/docs/optimizelyusercontext-csharp) +- [Advanced Audience Targeting segment qualification methods](https://docs.developers.optimizely.com/feature-experimentation/docs/advanced-audience-targeting-segment-qualification-methods-csharp) +- [Send Optimizely Data Platform data using Advanced Audience Targeting](https://docs.developers.optimizely.com/feature-experimentation/docs/send-odp-data-using-advanced-audience-targeting-csharp) + +#### Polling warning + +Add warning to polling intervals below 30 seconds ([#365](https://github.com/optimizely/csharp-sdk/pull/365)) + +### Breaking Changes +- `OdpManager` in the SDK is enabled by default. Unless an ODP account is integrated into the Optimizely projects, most `OdpManager` functions will be ignored. If needed, `OdpManager` can be disabled when `OptimizelyClient` is instantiated. +- `ProjectConfigManager` interface additions + implementing class updates +- `Evaluate()` updates in `BaseCondition` + +### Bug Fixes +- Return Latest Experiment When Duplicate Keys in Config enhancement + +### Documentation +- Corrections to markdown files in docs directory ([#368](https://github.com/optimizely/csharp-sdk/pull/368)) +- GitHub template updates ([#366](https://github.com/optimizely/csharp-sdk/pull/366)) + +## 3.11.4 +July 26th, 2023 + +### Bug Fixes +- Fix Last-Modified date & time format for If-Modified-Since ([#361](https://github.com/optimizely/csharp-sdk/pull/361)) + +## 3.11.3 +July 18th, 2023 + +### Bug Fixes +- Last-Modified in header not found and used to reduce polling payload ([#355](https://github.com/optimizely/csharp-sdk/pull/355)). + ## 4.0.0-beta April 28th, 2023 diff --git a/LICENSE b/LICENSE index 089978b9d..2f8be7813 100644 --- a/LICENSE +++ b/LICENSE @@ -187,7 +187,7 @@ same "printed page" as the copyright notice for easier identification within third-party archives. - Copyright 2016 Optimizely + Copyright 2016-2024, Optimizely, Inc. and contributors Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/OptimizelySDK.DemoApp/Properties/AssemblyInfo.cs b/OptimizelySDK.DemoApp/Properties/AssemblyInfo.cs index ef42316d9..147aa1a83 100644 --- a/OptimizelySDK.DemoApp/Properties/AssemblyInfo.cs +++ b/OptimizelySDK.DemoApp/Properties/AssemblyInfo.cs @@ -37,6 +37,6 @@ // // You can specify all the values or you can default the Revision and Build Numbers // by using the '*' as shown below: -[assembly: AssemblyVersion("4.0.0.0")] -[assembly: AssemblyFileVersion("4.0.0.0")] -[assembly: AssemblyInformationalVersion("4.0.0-beta")] // Used by Nuget. +[assembly: AssemblyVersion("4.1.0.0")] +[assembly: AssemblyFileVersion("4.1.0.0")] +[assembly: AssemblyInformationalVersion("4.1.0")] // Used by NuGet. diff --git a/OptimizelySDK.DemoApp/Scripts/README.md b/OptimizelySDK.DemoApp/Scripts/README.md index ff1e9551c..12510e26f 100644 --- a/OptimizelySDK.DemoApp/Scripts/README.md +++ b/OptimizelySDK.DemoApp/Scripts/README.md @@ -7,7 +7,6 @@

- Build Status Stable Release Size bitHound Overall Score Istanbul Code Coverage @@ -34,7 +33,7 @@ to make it possible to position it near a given reference element. The engine is completely modular and most of its features are implemented as **modifiers** (similar to middlewares or plugins). -The whole code base is written in ES2015 and its features are automatically tested on real browsers thanks to [SauceLabs](https://saucelabs.com/) and [TravisCI](https://travis-ci.org/). +The whole code base is written in ES2015 and its features are automatically tested on real browsers thanks to [SauceLabs](https://saucelabs.com/). Popper.js has zero dependencies. No jQuery, no LoDash, nothing. It's used by big companies like [Twitter in Bootstrap v4](https://getbootstrap.com/), [Microsoft in WebClipper](https://github.com/OneNoteDev/WebClipper) and [Atlassian in AtlasKit](https://aui-cdn.atlassian.com/atlaskit/registry/). diff --git a/OptimizelySDK.Net35/OptimizelySDK.Net35.csproj b/OptimizelySDK.Net35/OptimizelySDK.Net35.csproj index 8daf74ce3..e441df535 100644 --- a/OptimizelySDK.Net35/OptimizelySDK.Net35.csproj +++ b/OptimizelySDK.Net35/OptimizelySDK.Net35.csproj @@ -88,6 +88,15 @@ Entity\Experiment.cs + + Entity\Cmab.cs + + + Entity\Holdout.cs + + + Entity\ExperimentCore.cs + Entity\FeatureDecision.cs @@ -209,9 +218,15 @@ Bucketing\UserProfile.cs + + Bucketing\UserProfileTracker.cs + Bucketing\ExperimentUtils + + Utils\HoldoutConfig.cs + Bucketing\UserProfileUtil @@ -356,4 +371,4 @@ --> - \ No newline at end of file + diff --git a/OptimizelySDK.Net35/Properties/AssemblyInfo.cs b/OptimizelySDK.Net35/Properties/AssemblyInfo.cs index 69b04e7f4..dd5b9ab24 100644 --- a/OptimizelySDK.Net35/Properties/AssemblyInfo.cs +++ b/OptimizelySDK.Net35/Properties/AssemblyInfo.cs @@ -37,6 +37,6 @@ // // You can specify all the values or you can default the Build and Revision Numbers // by using the '*' as shown below: -[assembly: AssemblyVersion("4.0.0.0")] -[assembly: AssemblyFileVersion("4.0.0.0")] -[assembly: AssemblyInformationalVersion("4.0.0-beta")] // Used by Nuget. +[assembly: AssemblyVersion("4.1.0.0")] +[assembly: AssemblyFileVersion("4.1.0.0")] +[assembly: AssemblyInformationalVersion("4.1.0")] // Used by NuGet. diff --git a/OptimizelySDK.Net40/OptimizelySDK.Net40.csproj b/OptimizelySDK.Net40/OptimizelySDK.Net40.csproj index a0f98b775..c11502808 100644 --- a/OptimizelySDK.Net40/OptimizelySDK.Net40.csproj +++ b/OptimizelySDK.Net40/OptimizelySDK.Net40.csproj @@ -90,6 +90,15 @@ Entity\Experiment.cs + + Entity\Cmab.cs + + + Entity\Holdout.cs + + + Entity\ExperimentCore.cs + Entity\FeatureDecision.cs @@ -208,9 +217,15 @@ Bucketing\UserProfile.cs + + Bucketing\UserProfileTracker.cs + Bucketing\ExperimentUtils + + Utils\HoldoutConfig.cs + Bucketing\UserProfileUtil @@ -366,4 +381,4 @@ - \ No newline at end of file + diff --git a/OptimizelySDK.Net40/Properties/AssemblyInfo.cs b/OptimizelySDK.Net40/Properties/AssemblyInfo.cs index c3e01c002..48b0cb1d0 100644 --- a/OptimizelySDK.Net40/Properties/AssemblyInfo.cs +++ b/OptimizelySDK.Net40/Properties/AssemblyInfo.cs @@ -37,6 +37,6 @@ // // You can specify all the values or you can default the Build and Revision Numbers // by using the '*' as shown below: -[assembly: AssemblyVersion("4.0.0.0")] -[assembly: AssemblyFileVersion("4.0.0.0")] -[assembly: AssemblyInformationalVersion("4.0.0-beta")] // Used by Nuget. +[assembly: AssemblyVersion("4.1.0.0")] +[assembly: AssemblyFileVersion("4.1.0.0")] +[assembly: AssemblyInformationalVersion("4.1.0")] // Used by NuGet. diff --git a/OptimizelySDK.NetStandard16/OptimizelySDK.NetStandard16.csproj b/OptimizelySDK.NetStandard16/OptimizelySDK.NetStandard16.csproj index 329b8b726..1490ba147 100644 --- a/OptimizelySDK.NetStandard16/OptimizelySDK.NetStandard16.csproj +++ b/OptimizelySDK.NetStandard16/OptimizelySDK.NetStandard16.csproj @@ -26,6 +26,9 @@ + + + @@ -64,6 +67,7 @@ + @@ -72,6 +76,7 @@ + @@ -159,5 +164,7 @@ + + diff --git a/OptimizelySDK.NetStandard16/Properties/AssemblyInfo.cs b/OptimizelySDK.NetStandard16/Properties/AssemblyInfo.cs index 7ba7db50d..f82a11ad0 100644 --- a/OptimizelySDK.NetStandard16/Properties/AssemblyInfo.cs +++ b/OptimizelySDK.NetStandard16/Properties/AssemblyInfo.cs @@ -37,6 +37,6 @@ // // You can specify all the values or you can default the Build and Revision Numbers // by using the '*' as shown below: -[assembly: AssemblyVersion("4.0.0")] -[assembly: AssemblyFileVersion("4.0.0.0")] -[assembly: AssemblyInformationalVersion("4.0.0-beta")] // Used by Nuget. +[assembly: AssemblyVersion("4.1.0")] +[assembly: AssemblyFileVersion("4.1.0.0")] +[assembly: AssemblyInformationalVersion("4.1.0")] // Used by NuGet. diff --git a/OptimizelySDK.NetStandard20/OptimizelySDK.NetStandard20.csproj b/OptimizelySDK.NetStandard20/OptimizelySDK.NetStandard20.csproj index 6d7ea6382..2ba52d483 100644 --- a/OptimizelySDK.NetStandard20/OptimizelySDK.NetStandard20.csproj +++ b/OptimizelySDK.NetStandard20/OptimizelySDK.NetStandard20.csproj @@ -133,6 +133,9 @@ Bucketing\UserProfile.cs + + Bucketing\UserProfileTracker.cs + Bucketing\UserProfileService.cs @@ -175,7 +178,30 @@ Entity\Experiment.cs - + + Entity\Cmab.cs + + + Cmab\ICmabClient.cs + + + Cmab\DefaultCmabClient.cs + + + Cmab\CmabRetryConfig.cs + + + Cmab\CmabModels.cs + + + Cmab\CmabConstants.cs + + + Entity\Holdout.cs + + + Entity\ExperimentCore.cs + Entity\FeatureDecision.cs @@ -328,6 +354,9 @@ Utils\ExperimentUtils.cs + + Utils\HoldoutConfig.cs + Utils\Schema.cs diff --git a/OptimizelySDK.NetStandard20/Properties/AssemblyInfo.cs b/OptimizelySDK.NetStandard20/Properties/AssemblyInfo.cs index e493466c5..72640cfa1 100644 --- a/OptimizelySDK.NetStandard20/Properties/AssemblyInfo.cs +++ b/OptimizelySDK.NetStandard20/Properties/AssemblyInfo.cs @@ -37,6 +37,6 @@ // // You can specify all the values or you can default the Build and Revision Numbers // by using the '*' as shown below: -[assembly: AssemblyVersion("4.0.0.0")] -[assembly: AssemblyFileVersion("4.0.0.0")] -[assembly: AssemblyInformationalVersion("4.0.0-beta")] // Used by Nuget. +[assembly: AssemblyVersion("4.1.0.0")] +[assembly: AssemblyFileVersion("4.1.0.0")] +[assembly: AssemblyInformationalVersion("4.1.0")] // Used by NuGet. diff --git a/OptimizelySDK.Tests/Assertions.cs b/OptimizelySDK.Tests/Assertions.cs index 9dfe2f7ba..3544d6212 100644 --- a/OptimizelySDK.Tests/Assertions.cs +++ b/OptimizelySDK.Tests/Assertions.cs @@ -488,7 +488,7 @@ public static void AreEqual(Experiment expected, Experiment actual) Assert.AreEqual(expected.GroupId, actual.GroupId); Assert.AreEqual(expected.GroupPolicy, actual.GroupPolicy); Assert.AreEqual(expected.Id, actual.Id); - Assert.AreEqual(expected.IsExperimentRunning, actual.IsExperimentRunning); + Assert.AreEqual(expected.isRunning, actual.isRunning); Assert.AreEqual(expected.IsInMutexGroup, actual.IsInMutexGroup); Assert.AreEqual(expected.Key, actual.Key); Assert.AreEqual(expected.LayerId, actual.LayerId); @@ -500,6 +500,33 @@ public static void AreEqual(Experiment expected, Experiment actual) AreEquivalent(expected.Variations, actual.Variations); } + public static void AreEqual(ExperimentCore expected, ExperimentCore actual) + { + if (expected == null && actual == null) + { + return; + } + + Assert.IsNotNull(expected, "Expected ExperimentCore should not be null"); + Assert.IsNotNull(actual, "Actual ExperimentCore should not be null"); + + Assert.AreEqual(expected.AudienceConditions, actual.AudienceConditions); + Assert.AreEqual(expected.AudienceConditionsList, actual.AudienceConditionsList); + Assert.AreEqual(expected.AudienceConditionsString, actual.AudienceConditionsString); + AreEquivalent(expected.AudienceIds, actual.AudienceIds); + Assert.AreEqual(expected.AudienceIdsList, actual.AudienceIdsList); + Assert.AreEqual(expected.AudienceIdsString, actual.AudienceIdsString); + Assert.AreEqual(expected.Id, actual.Id); + Assert.AreEqual(expected.isRunning, actual.isRunning); + Assert.AreEqual(expected.Key, actual.Key); + Assert.AreEqual(expected.LayerId, actual.LayerId); + Assert.AreEqual(expected.Status, actual.Status); + AreEquivalent(expected.TrafficAllocation, actual.TrafficAllocation); + AreEquivalent(expected.VariationIdToVariationMap, actual.VariationIdToVariationMap); + AreEquivalent(expected.VariationKeyToVariationMap, actual.VariationKeyToVariationMap); + AreEquivalent(expected.Variations, actual.Variations); + } + #endregion Experiment #region FeatureDecision @@ -507,6 +534,8 @@ public static void AreEqual(Experiment expected, Experiment actual) public static void AreEqual(FeatureDecision expected, FeatureDecision actual) { AreEqual(expected.Experiment, actual.Experiment); + AreEqual(expected.Variation, actual.Variation); + Assert.AreEqual(expected.Source, actual.Source); } #endregion FeatureDecision diff --git a/OptimizelySDK.Tests/BucketerHoldoutTest.cs b/OptimizelySDK.Tests/BucketerHoldoutTest.cs new file mode 100644 index 000000000..742d82158 --- /dev/null +++ b/OptimizelySDK.Tests/BucketerHoldoutTest.cs @@ -0,0 +1,369 @@ +/* + * Copyright 2025, Optimizely + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +using System.IO; +using Moq; +using Newtonsoft.Json; +using Newtonsoft.Json.Linq; +using NUnit.Framework; +using OptimizelySDK.Bucketing; +using OptimizelySDK.Config; +using OptimizelySDK.Entity; +using OptimizelySDK.Logger; +using OptimizelySDK.OptimizelyDecisions; + +namespace OptimizelySDK.Tests +{ + [TestFixture] + public class BucketerHoldoutTest + { + private Mock LoggerMock; + private Bucketer Bucketer; + private TestBucketer TestBucketer; + private ProjectConfig Config; + private JObject TestData; + private const string TestUserId = "test_user_id"; + private const string TestBucketingId = "test_bucketing_id"; + + [SetUp] + public void Initialize() + { + LoggerMock = new Mock(); + + // Load holdout test data + var testDataPath = Path.Combine(TestContext.CurrentContext.TestDirectory, + "TestData", "HoldoutTestData.json"); + var jsonContent = File.ReadAllText(testDataPath); + TestData = JObject.Parse(jsonContent); + + // Use datafile with holdouts for proper config setup + var datafileWithHoldouts = TestData["datafileWithHoldouts"].ToString(); + Config = DatafileProjectConfig.Create(datafileWithHoldouts, LoggerMock.Object, + new ErrorHandler.NoOpErrorHandler()); + TestBucketer = new TestBucketer(LoggerMock.Object); + + // Verify that the config contains holdouts + Assert.IsNotNull(Config.Holdouts, "Config should have holdouts"); + Assert.IsTrue(Config.Holdouts.Length > 0, "Config should contain holdouts"); + } + + [Test] + public void TestBucketHoldout_ValidTrafficAllocation() + { + // Test user bucketed within traffic allocation range + // Use the global holdout from config which has multiple variations + var holdout = Config.GetHoldout("holdout_global_1"); + Assert.IsNotNull(holdout, "Holdout should exist in config"); + + // Set bucket value to be within first variation's traffic allocation (0-5000 range) + TestBucketer.SetBucketValues(new[] { 2500 }); + + var result = TestBucketer.Bucket(Config, holdout, TestBucketingId, TestUserId); + + Assert.IsNotNull(result.ResultObject); + Assert.AreEqual("var_1", result.ResultObject.Id); + Assert.AreEqual("control", result.ResultObject.Key); + + // Verify logging + LoggerMock.Verify(l => l.Log(LogLevel.DEBUG, + It.Is(s => s.Contains($"Assigned bucket [2500] to user [{TestUserId}]"))), + Times.Once); + } + + [Test] + public void TestBucketHoldout_UserOutsideAllocation() + { + // Test user not bucketed when outside traffic allocation range + var holdoutJson = TestData["globalHoldout"].ToString(); + var holdout = JsonConvert.DeserializeObject(holdoutJson); + + // Modify traffic allocation to be smaller (0-1000 range = 10%) + holdout.TrafficAllocation[0].EndOfRange = 1000; + + // Set bucket value outside traffic allocation range + TestBucketer.SetBucketValues(new[] { 1500 }); + + var result = TestBucketer.Bucket(Config, holdout, TestBucketingId, TestUserId); + + Assert.IsNull(result.ResultObject.Id); + Assert.IsNull(result.ResultObject.Key); + + // Verify user was assigned bucket value but no variation was found + LoggerMock.Verify(l => l.Log(LogLevel.DEBUG, + It.Is(s => s.Contains($"Assigned bucket [1500] to user [{TestUserId}]"))), + Times.Once); + } + + [Test] + public void TestBucketHoldout_NoTrafficAllocation() + { + // Test holdout with empty traffic allocation + var holdoutJson = TestData["globalHoldout"].ToString(); + var holdout = JsonConvert.DeserializeObject(holdoutJson); + + // Clear traffic allocation + holdout.TrafficAllocation = new TrafficAllocation[0]; + + TestBucketer.SetBucketValues(new[] { 5000 }); + + var result = TestBucketer.Bucket(Config, holdout, TestBucketingId, TestUserId); + + Assert.IsNull(result.ResultObject.Id); + Assert.IsNull(result.ResultObject.Key); + + // Verify bucket was assigned but no variation found + LoggerMock.Verify(l => l.Log(LogLevel.DEBUG, + It.Is(s => s.Contains($"Assigned bucket [5000] to user [{TestUserId}]"))), + Times.Once); + } + + [Test] + public void TestBucketHoldout_InvalidVariationId() + { + // Test holdout with invalid variation ID in traffic allocation + var holdoutJson = TestData["globalHoldout"].ToString(); + var holdout = JsonConvert.DeserializeObject(holdoutJson); + + // Set traffic allocation to point to non-existent variation + holdout.TrafficAllocation[0].EntityId = "invalid_variation_id"; + + TestBucketer.SetBucketValues(new[] { 5000 }); + + var result = TestBucketer.Bucket(Config, holdout, TestBucketingId, TestUserId); + + Assert.IsNull(result.ResultObject.Id); + Assert.IsNull(result.ResultObject.Key); + + // Verify bucket was assigned + LoggerMock.Verify(l => l.Log(LogLevel.DEBUG, + It.Is(s => s.Contains($"Assigned bucket [5000] to user [{TestUserId}]"))), + Times.Once); + } + + [Test] + public void TestBucketHoldout_EmptyVariations() + { + // Test holdout with no variations - use holdout from datafile that has no variations + var holdout = Config.GetHoldout("holdout_empty_1"); + Assert.IsNotNull(holdout, "Empty holdout should exist in config"); + Assert.AreEqual(0, holdout.Variations?.Length ?? 0, "Holdout should have no variations"); + + TestBucketer.SetBucketValues(new[] { 5000 }); + + var result = TestBucketer.Bucket(Config, holdout, TestBucketingId, TestUserId); + + Assert.IsNull(result.ResultObject.Id); + Assert.IsNull(result.ResultObject.Key); + + // Verify bucket was assigned + LoggerMock.Verify(l => l.Log(LogLevel.DEBUG, + It.Is(s => s.Contains($"Assigned bucket [5000] to user [{TestUserId}]"))), + Times.Once); + } + + [Test] + public void TestBucketHoldout_EmptyExperimentKey() + { + // Test holdout with empty key + var holdoutJson = TestData["globalHoldout"].ToString(); + var holdout = JsonConvert.DeserializeObject(holdoutJson); + + // Clear holdout key + holdout.Key = ""; + + TestBucketer.SetBucketValues(new[] { 5000 }); + + var result = TestBucketer.Bucket(Config, holdout, TestBucketingId, TestUserId); + + // Should return empty variation for invalid experiment key + Assert.IsNotNull(result.ResultObject); + Assert.IsNull(result.ResultObject.Id); + Assert.IsNull(result.ResultObject.Key); + } + + [Test] + public void TestBucketHoldout_NullExperimentKey() + { + // Test holdout with null key + var holdoutJson = TestData["globalHoldout"].ToString(); + var holdout = JsonConvert.DeserializeObject(holdoutJson); + + // Set holdout key to null + holdout.Key = null; + + TestBucketer.SetBucketValues(new[] { 5000 }); + + var result = TestBucketer.Bucket(Config, holdout, TestBucketingId, TestUserId); + + // Should return empty variation for null experiment key + Assert.IsNotNull(result.ResultObject); + Assert.IsNull(result.ResultObject.Id); + Assert.IsNull(result.ResultObject.Key); + } + + [Test] + public void TestBucketHoldout_MultipleVariationsInRange() + { + // Test holdout with multiple variations and user buckets into first one + var holdoutJson = TestData["globalHoldout"].ToString(); + var holdout = JsonConvert.DeserializeObject(holdoutJson); + + // Add a second variation + var variation2 = new Variation + { + Id = "var_2", + Key = "treatment", + FeatureEnabled = true + }; + holdout.Variations = new[] { holdout.Variations[0], variation2 }; + + // Set traffic allocation for first variation (0-5000) and second (5000-10000) + holdout.TrafficAllocation = new[] + { + new TrafficAllocation { EntityId = "var_1", EndOfRange = 5000 }, + new TrafficAllocation { EntityId = "var_2", EndOfRange = 10000 } + }; + + // Test user buckets into first variation + TestBucketer.SetBucketValues(new[] { 2500 }); + var result = TestBucketer.Bucket(Config, holdout, TestBucketingId, TestUserId); + + Assert.IsNotNull(result.ResultObject); + Assert.AreEqual("var_1", result.ResultObject.Id); + Assert.AreEqual("control", result.ResultObject.Key); + } + + [Test] + public void TestBucketHoldout_MultipleVariationsInSecondRange() + { + // Test holdout with multiple variations and user buckets into second one + // Use the global holdout from config which now has multiple variations + var holdout = Config.GetHoldout("holdout_global_1"); + Assert.IsNotNull(holdout, "Holdout should exist in config"); + + // Verify holdout has multiple variations + Assert.IsTrue(holdout.Variations.Length >= 2, "Holdout should have multiple variations"); + Assert.AreEqual("var_1", holdout.Variations[0].Id); + Assert.AreEqual("var_2", holdout.Variations[1].Id); + + // Test user buckets into second variation (bucket value 7500 should be in 5000-10000 range) + TestBucketer.SetBucketValues(new[] { 7500 }); + var result = TestBucketer.Bucket(Config, holdout, TestBucketingId, TestUserId); + + Assert.IsNotNull(result.ResultObject); + Assert.AreEqual("var_2", result.ResultObject.Id); + Assert.AreEqual("treatment", result.ResultObject.Key); + } + + [Test] + public void TestBucketHoldout_EdgeCaseBoundaryValues() + { + // Test edge cases at traffic allocation boundaries + var holdoutJson = TestData["globalHoldout"].ToString(); + var holdout = JsonConvert.DeserializeObject(holdoutJson); + + // Set traffic allocation to 5000 (50%) + holdout.TrafficAllocation[0].EndOfRange = 5000; + + // Test exact boundary value (should be included) + TestBucketer.SetBucketValues(new[] { 4999 }); + var result = TestBucketer.Bucket(Config, holdout, TestBucketingId, TestUserId); + + Assert.IsNotNull(result.ResultObject); + Assert.AreEqual("var_1", result.ResultObject.Id); + + // Test value just outside boundary (should not be included) + TestBucketer.SetBucketValues(new[] { 5000 }); + result = TestBucketer.Bucket(Config, holdout, TestBucketingId, TestUserId); + + Assert.IsNull(result.ResultObject.Id); + } + + [Test] + public void TestBucketHoldout_ConsistentBucketingWithSameInputs() + { + // Test that same inputs produce consistent results + // Use holdout from config instead of creating at runtime + var holdout = Config.GetHoldout("holdout_global_1"); + Assert.IsNotNull(holdout, "Holdout should exist in config"); + + // Create a real bucketer (not test bucketer) for consistent hashing + var realBucketer = new Bucketing.Bucketer(LoggerMock.Object); + var result1 = realBucketer.Bucket(Config, holdout, TestBucketingId, TestUserId); + var result2 = realBucketer.Bucket(Config, holdout, TestBucketingId, TestUserId); + + // Results should be identical + Assert.IsNotNull(result1); + Assert.IsNotNull(result2); + + if (result1.ResultObject?.Id != null) + { + Assert.AreEqual(result1.ResultObject.Id, result2.ResultObject.Id); + Assert.AreEqual(result1.ResultObject.Key, result2.ResultObject.Key); + } + else + { + Assert.IsNull(result2.ResultObject?.Id); + } + } + + [Test] + public void TestBucketHoldout_DifferentBucketingIdsProduceDifferentResults() + { + // Test that different bucketing IDs can produce different results + // Use holdout from config instead of creating at runtime + var holdout = Config.GetHoldout("holdout_global_1"); + Assert.IsNotNull(holdout, "Holdout should exist in config"); + + // Create a real bucketer (not test bucketer) for real hashing behavior + var realBucketer = new Bucketing.Bucketer(LoggerMock.Object); + var result1 = realBucketer.Bucket(Config, holdout, "bucketingId1", TestUserId); + var result2 = realBucketer.Bucket(Config, holdout, "bucketingId2", TestUserId); + + // Results may be different (though not guaranteed due to hashing) + // This test mainly ensures no exceptions are thrown with different inputs + Assert.IsNotNull(result1); + Assert.IsNotNull(result2); + Assert.IsNotNull(result1.ResultObject); + Assert.IsNotNull(result2.ResultObject); + } + + [Test] + public void TestBucketHoldout_VerifyDecisionReasons() + { + // Test that decision reasons are properly populated + var holdoutJson = TestData["globalHoldout"].ToString(); + var holdout = JsonConvert.DeserializeObject(holdoutJson); + + TestBucketer.SetBucketValues(new[] { 5000 }); + var result = TestBucketer.Bucket(Config, holdout, TestBucketingId, TestUserId); + + Assert.IsNotNull(result.DecisionReasons); + // Decision reasons should be populated from the bucketing process + // The exact content depends on whether the user was bucketed or not + } + + [TearDown] + public void TearDown() + { + LoggerMock = null; + Bucketer = null; + TestBucketer = null; + Config = null; + TestData = null; + } + } +} diff --git a/OptimizelySDK.Tests/CmabTests/DefaultCmabClientTest.cs b/OptimizelySDK.Tests/CmabTests/DefaultCmabClientTest.cs new file mode 100644 index 000000000..87a80e339 --- /dev/null +++ b/OptimizelySDK.Tests/CmabTests/DefaultCmabClientTest.cs @@ -0,0 +1,186 @@ +/* +* Copyright 2025, Optimizely +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +using System; +using System.Collections.Generic; +using System.Net; +using System.Net.Http; +using System.Threading; +using System.Threading.Tasks; +using Moq; +using Moq.Protected; +using NUnit.Framework; +using OptimizelySDK.Cmab; +using OptimizelySDK.ErrorHandler; +using OptimizelySDK.Exceptions; +using OptimizelySDK.Logger; + +namespace OptimizelySDK.Tests.CmabTests +{ + [TestFixture] + public class DefaultCmabClientTest + { + private class ResponseStep + { + public HttpStatusCode Status { get; private set; } + public string Body { get; private set; } + public ResponseStep(HttpStatusCode status, string body) + { + Status = status; + Body = body; + } + } + + private static HttpClient MakeClient(params ResponseStep[] sequence) + { + var handler = new Mock(MockBehavior.Strict); + var queue = new Queue(sequence); + + handler.Protected().Setup>("SendAsync", + ItExpr.IsAny(), + ItExpr.IsAny()).Returns((HttpRequestMessage _, CancellationToken __) => + { + if (queue.Count == 0) + throw new InvalidOperationException("No more mocked responses available."); + + var step = queue.Dequeue(); + var response = new HttpResponseMessage(step.Status); + if (step.Body != null) + { + response.Content = new StringContent(step.Body); + } + return Task.FromResult(response); + }); + + return new HttpClient(handler.Object); + } + + private static HttpClient MakeClientExceptionSequence(params Exception[] sequence) + { + var handler = new Mock(MockBehavior.Strict); + var queue = new Queue(sequence); + + handler.Protected().Setup>("SendAsync", + ItExpr.IsAny(), + ItExpr.IsAny()).Returns((HttpRequestMessage _, CancellationToken __) => + { + if (queue.Count == 0) + throw new InvalidOperationException("No more mocked exceptions available."); + + var ex = queue.Dequeue(); + var tcs = new TaskCompletionSource(); + tcs.SetException(ex); + return tcs.Task; + }); + + return new HttpClient(handler.Object); + } + + private static string ValidBody(string variationId = "v1") + => $"{{\"predictions\":[{{\"variation_id\":\"{variationId}\"}}]}}"; + + [Test] + public void FetchDecisionReturnsSuccessNoRetry() + { + var http = MakeClient(new ResponseStep(HttpStatusCode.OK, ValidBody("v1"))); + var client = new DefaultCmabClient(http, retryConfig: null, logger: new NoOpLogger(), errorHandler: new NoOpErrorHandler()); + var result = client.FetchDecision("rule-1", "user-1", null, "uuid-1"); + + Assert.AreEqual("v1", result); + } + + [Test] + public void FetchDecisionHttpExceptionNoRetry() + { + var http = MakeClientExceptionSequence(new HttpRequestException("boom")); + var client = new DefaultCmabClient(http, retryConfig: null); + + Assert.Throws(() => + client.FetchDecision("rule-1", "user-1", null, "uuid-1")); + } + + [Test] + public void FetchDecisionNon2xxNoRetry() + { + var http = MakeClient(new ResponseStep(HttpStatusCode.InternalServerError, null)); + var client = new DefaultCmabClient(http, retryConfig: null); + + Assert.Throws(() => + client.FetchDecision("rule-1", "user-1", null, "uuid-1")); + } + + [Test] + public void FetchDecisionInvalidJsonNoRetry() + { + var http = MakeClient(new ResponseStep(HttpStatusCode.OK, "not json")); + var client = new DefaultCmabClient(http, retryConfig: null); + + Assert.Throws(() => + client.FetchDecision("rule-1", "user-1", null, "uuid-1")); + } + + [Test] + public void FetchDecisionInvalidStructureNoRetry() + { + var http = MakeClient(new ResponseStep(HttpStatusCode.OK, "{\"predictions\":[]}")); + var client = new DefaultCmabClient(http, retryConfig: null); + + Assert.Throws(() => + client.FetchDecision("rule-1", "user-1", null, "uuid-1")); + } + + [Test] + public void FetchDecisionSuccessWithRetryFirstTry() + { + var http = MakeClient(new ResponseStep(HttpStatusCode.OK, ValidBody("v2"))); + var retry = new CmabRetryConfig(maxRetries: 2, initialBackoff: TimeSpan.Zero, maxBackoff: TimeSpan.FromSeconds(1), backoffMultiplier: 2.0); + var client = new DefaultCmabClient(http, retry); + var result = client.FetchDecision("rule-1", "user-1", null, "uuid-1"); + + Assert.AreEqual("v2", result); + } + + [Test] + public void FetchDecisionSuccessWithRetryThirdTry() + { + var http = MakeClient( + new ResponseStep(HttpStatusCode.InternalServerError, null), + new ResponseStep(HttpStatusCode.InternalServerError, null), + new ResponseStep(HttpStatusCode.OK, ValidBody("v3")) + ); + var retry = new CmabRetryConfig(maxRetries: 2, initialBackoff: TimeSpan.Zero, maxBackoff: TimeSpan.FromSeconds(1), backoffMultiplier: 2.0); + var client = new DefaultCmabClient(http, retry); + var result = client.FetchDecision("rule-1", "user-1", null, "uuid-1"); + + Assert.AreEqual("v3", result); + } + + [Test] + public void FetchDecisionExhaustsAllRetries() + { + var http = MakeClient( + new ResponseStep(HttpStatusCode.InternalServerError, null), + new ResponseStep(HttpStatusCode.InternalServerError, null), + new ResponseStep(HttpStatusCode.InternalServerError, null) + ); + var retry = new CmabRetryConfig(maxRetries: 2, initialBackoff: TimeSpan.Zero, maxBackoff: TimeSpan.FromSeconds(1), backoffMultiplier: 2.0); + var client = new DefaultCmabClient(http, retry); + + Assert.Throws(() => + client.FetchDecision("rule-1", "user-1", null, "uuid-1")); + } + } +} diff --git a/OptimizelySDK.Tests/DecisionServiceHoldoutTest.cs b/OptimizelySDK.Tests/DecisionServiceHoldoutTest.cs new file mode 100644 index 000000000..3d34e151c --- /dev/null +++ b/OptimizelySDK.Tests/DecisionServiceHoldoutTest.cs @@ -0,0 +1,335 @@ +/* + * Copyright 2025, Optimizely + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using Moq; +using Newtonsoft.Json.Linq; +using NUnit.Framework; +using OptimizelySDK.Bucketing; +using OptimizelySDK.Config; +using OptimizelySDK.Entity; +using OptimizelySDK.ErrorHandler; +using OptimizelySDK.Event; +using OptimizelySDK.Event.Entity; +using OptimizelySDK.Logger; +using OptimizelySDK.OptimizelyDecisions; + +namespace OptimizelySDK.Tests +{ + [TestFixture] + public class DecisionServiceHoldoutTest + { + private Mock LoggerMock; + private Mock EventProcessorMock; + private DecisionService DecisionService; + private DatafileProjectConfig Config; + private JObject TestData; + private Optimizely OptimizelyInstance; + + private const string TestUserId = "testUserId"; + private const string TestBucketingId = "testBucketingId"; + + [SetUp] + public void Initialize() + { + LoggerMock = new Mock(); + EventProcessorMock = new Mock(); + + // Load test data + var testDataPath = Path.Combine(TestContext.CurrentContext.TestDirectory, + "TestData", "HoldoutTestData.json"); + var jsonContent = File.ReadAllText(testDataPath); + TestData = JObject.Parse(jsonContent); + + // Use datafile with holdouts for proper config setup + var datafileWithHoldouts = TestData["datafileWithHoldouts"].ToString(); + Config = DatafileProjectConfig.Create(datafileWithHoldouts, LoggerMock.Object, + new ErrorHandler.NoOpErrorHandler()) as DatafileProjectConfig; + + // Use real Bucketer instead of mock + var realBucketer = new Bucketer(LoggerMock.Object); + DecisionService = new DecisionService(realBucketer, + new ErrorHandler.NoOpErrorHandler(), null, LoggerMock.Object); + + // Create an Optimizely instance for creating user contexts + var eventDispatcher = new Event.Dispatcher.DefaultEventDispatcher(LoggerMock.Object); + OptimizelyInstance = new Optimizely(datafileWithHoldouts, eventDispatcher, LoggerMock.Object); + + // Verify that the config contains holdouts + Assert.IsNotNull(Config.Holdouts, "Config should have holdouts"); + Assert.IsTrue(Config.Holdouts.Length > 0, "Config should contain holdouts"); + } + + [Test] + public void TestGetVariationsForFeatureList_HoldoutActiveVariationBucketed() + { + // Test GetVariationsForFeatureList with holdout that has an active variation + var featureFlag = Config.FeatureKeyMap["test_flag_1"]; // Use actual feature flag from test data + var holdout = Config.GetHoldout("holdout_included_1"); // This holdout includes flag_1 + Assert.IsNotNull(holdout, "Holdout should exist in config"); + + // Create user context + var userContext = new OptimizelyUserContext(OptimizelyInstance, TestUserId, null, + new ErrorHandler.NoOpErrorHandler(), LoggerMock.Object); + + var result = DecisionService.GetVariationsForFeatureList( + new List { featureFlag }, userContext, Config, + new UserAttributes(), new OptimizelyDecideOption[0]); + + Assert.IsNotNull(result); + Assert.IsTrue(result.Count > 0, "Should have at least one decision"); + + // Find the holdout decision + var holdoutDecision = result.FirstOrDefault(r => r.ResultObject?.Source == FeatureDecision.DECISION_SOURCE_HOLDOUT); + Assert.IsNotNull(holdoutDecision, "Should have a holdout decision"); + + // Verify that we got a valid variation (real bucketer should determine this based on traffic allocation) + Assert.IsNotNull(holdoutDecision.ResultObject?.Variation, "Should have a variation"); + } + + [Test] + public void TestGetVariationsForFeatureList_HoldoutInactiveNoBucketing() + { + // Test that inactive holdouts don't bucket users + var featureFlag = Config.FeatureKeyMap["test_flag_1"]; // Use actual feature flag from test data + + // Get one of the holdouts that's actually processed for test_flag_1 (based on debug output) + var holdout = Config.GetHoldout("holdout_global_1"); // global_holdout is one of the holdouts being processed + Assert.IsNotNull(holdout, "Holdout should exist in config"); + + // Mock holdout as inactive + holdout.Status = "Paused"; + + var userContext = new OptimizelyUserContext(OptimizelyInstance, TestUserId, null, + new ErrorHandler.NoOpErrorHandler(), LoggerMock.Object); + + var result = DecisionService.GetVariationsForFeatureList( + new List { featureFlag }, userContext, Config, + new UserAttributes(), new OptimizelyDecideOption[0]); + + // Verify appropriate log message for inactive holdout + LoggerMock.Verify(l => l.Log(LogLevel.INFO, + It.Is(s => s.Contains("Holdout") && s.Contains("is not running"))), + Times.AtLeastOnce); + } + + [Test] + public void TestGetVariationsForFeatureList_HoldoutUserNotBucketed() + { + // Test when user is not bucketed into holdout (outside traffic allocation) + var featureFlag = Config.FeatureKeyMap["test_flag_1"]; // Use actual feature flag from test data + var holdout = Config.GetHoldout("holdout_included_1"); // This holdout includes flag_1 + Assert.IsNotNull(holdout, "Holdout should exist in config"); + + var userContext = new OptimizelyUserContext(OptimizelyInstance, TestUserId, null, + new ErrorHandler.NoOpErrorHandler(), LoggerMock.Object); + + var result = DecisionService.GetVariationsForFeatureList( + new List { featureFlag }, userContext, Config, + new UserAttributes(), new OptimizelyDecideOption[0]); + + // With real bucketer, we can't guarantee specific bucketing results + // but we can verify the method executes successfully + Assert.IsNotNull(result, "Result should not be null"); + } + + [Test] + public void TestGetVariationsForFeatureList_HoldoutWithUserAttributes() + { + // Test holdout evaluation with user attributes for audience targeting + var featureFlag = Config.FeatureKeyMap["test_flag_1"]; // Use actual feature flag from test data + var holdout = Config.GetHoldout("holdout_included_1"); // This holdout includes flag_1 + Assert.IsNotNull(holdout, "Holdout should exist in config"); + + var userAttributes = new UserAttributes + { + { "browser", "chrome" }, + { "location", "us" } + }; + + var userContext = new OptimizelyUserContext(OptimizelyInstance, TestUserId, userAttributes, + new ErrorHandler.NoOpErrorHandler(), LoggerMock.Object); + + var result = DecisionService.GetVariationsForFeatureList( + new List { featureFlag }, userContext, Config, + userAttributes, new OptimizelyDecideOption[0]); + + Assert.IsNotNull(result, "Result should not be null"); + + // With real bucketer, we can't guarantee specific variations but can verify execution + // Additional assertions would depend on the holdout configuration and user bucketing + } + + [Test] + public void TestGetVariationsForFeatureList_MultipleHoldouts() + { + // Test multiple holdouts for a single feature flag + var featureFlag = Config.FeatureKeyMap["test_flag_1"]; // Use actual feature flag from test data + + var userContext = new OptimizelyUserContext(OptimizelyInstance, TestUserId, null, + new ErrorHandler.NoOpErrorHandler(), LoggerMock.Object); + + var result = DecisionService.GetVariationsForFeatureList( + new List { featureFlag }, userContext, Config, + new UserAttributes(), new OptimizelyDecideOption[0]); + + Assert.IsNotNull(result, "Result should not be null"); + + // With real bucketer, we can't guarantee specific bucketing results + // but we can verify the method executes successfully + } + + [Test] + public void TestGetVariationsForFeatureList_Holdout_EmptyUserId() + { + // Test GetVariationsForFeatureList with empty user ID + var featureFlag = Config.FeatureKeyMap["test_flag_1"]; // Use actual feature flag from test data + + var userContext = new OptimizelyUserContext(OptimizelyInstance, "", null, + new ErrorHandler.NoOpErrorHandler(), LoggerMock.Object); + + var result = DecisionService.GetVariationsForFeatureList( + new List { featureFlag }, userContext, Config, + new UserAttributes(), new OptimizelyDecideOption[0]); + + Assert.IsNotNull(result); + + // Empty user ID should still allow holdout bucketing (matches Swift SDK behavior) + // The Swift SDK's testBucketToVariation_EmptyBucketingId shows empty string is valid + var holdoutDecisions = result.Where(r => r.ResultObject?.Source == FeatureDecision.DECISION_SOURCE_HOLDOUT).ToList(); + + // Should not log error about invalid user ID since empty string is valid for bucketing + LoggerMock.Verify(l => l.Log(LogLevel.ERROR, + It.Is(s => s.Contains("User ID") && (s.Contains("null") || s.Contains("empty")))), + Times.Never); + } + + [Test] + public void TestGetVariationsForFeatureList_Holdout_DecisionReasons() + { + // Test that decision reasons are properly populated for holdouts + var featureFlag = Config.FeatureKeyMap["test_flag_1"]; // Use actual feature flag from test data + var holdout = Config.GetHoldout("holdout_included_1"); // This holdout includes flag_1 + Assert.IsNotNull(holdout, "Holdout should exist in config"); + + var userContext = new OptimizelyUserContext(OptimizelyInstance, TestUserId, null, + new ErrorHandler.NoOpErrorHandler(), LoggerMock.Object); + + var result = DecisionService.GetVariationsForFeatureList( + new List { featureFlag }, userContext, Config, + new UserAttributes(), new OptimizelyDecideOption[0]); + + Assert.IsNotNull(result, "Result should not be null"); + + // With real bucketer, we expect proper decision reasons to be generated + // Find any decision with reasons + var decisionWithReasons = result.FirstOrDefault(r => r.DecisionReasons != null && r.DecisionReasons.ToReport().Count > 0); + + if (decisionWithReasons != null) + { + Assert.IsTrue(decisionWithReasons.DecisionReasons.ToReport().Count > 0, "Should have decision reasons"); + } + } + + [Test] + public void TestImpressionEventForHoldout() + { + var featureFlag = Config.FeatureKeyMap["test_flag_1"]; + var userAttributes = new UserAttributes(); + + var eventDispatcher = new Event.Dispatcher.DefaultEventDispatcher(LoggerMock.Object); + var optimizelyWithMockedEvents = new Optimizely( + TestData["datafileWithHoldouts"].ToString(), + eventDispatcher, + LoggerMock.Object, + new ErrorHandler.NoOpErrorHandler(), + null, // userProfileService + false, // skipJsonValidation + EventProcessorMock.Object + ); + + EventProcessorMock.Setup(ep => ep.Process(It.IsAny())); + + var userContext = optimizelyWithMockedEvents.CreateUserContext(TestUserId, userAttributes); + var decision = userContext.Decide(featureFlag.Key); + + Assert.IsNotNull(decision, "Decision should not be null"); + Assert.IsNotNull(decision.RuleKey, "RuleKey should not be null"); + + var actualHoldout = Config.Holdouts?.FirstOrDefault(h => h.Key == decision.RuleKey); + + Assert.IsNotNull(actualHoldout, + $"RuleKey '{decision.RuleKey}' should correspond to a holdout experiment"); + Assert.AreEqual(featureFlag.Key, decision.FlagKey, "Flag key should match"); + + var holdoutVariation = actualHoldout.Variations.FirstOrDefault(v => v.Key == decision.VariationKey); + + Assert.IsNotNull(holdoutVariation, + $"Variation '{decision.VariationKey}' should be from the chosen holdout '{actualHoldout.Key}'"); + + Assert.AreEqual(holdoutVariation.FeatureEnabled, decision.Enabled, + "Enabled flag should match holdout variation's featureEnabled value"); + + EventProcessorMock.Verify(ep => ep.Process(It.IsAny()), Times.Once, + "Impression event should be processed exactly once for holdout decision"); + + EventProcessorMock.Verify(ep => ep.Process(It.Is(ie => + ie.Experiment.Key == actualHoldout.Key && + ie.Experiment.Id == actualHoldout.Id && + ie.Timestamp > 0 && + ie.UserId == TestUserId + )), Times.Once, "Impression event should contain correct holdout experiment details"); + } + + [Test] + public void TestImpressionEventForHoldout_DisableDecisionEvent() + { + var featureFlag = Config.FeatureKeyMap["test_flag_1"]; + var userAttributes = new UserAttributes(); + + var eventDispatcher = new Event.Dispatcher.DefaultEventDispatcher(LoggerMock.Object); + var optimizelyWithMockedEvents = new Optimizely( + TestData["datafileWithHoldouts"].ToString(), + eventDispatcher, + LoggerMock.Object, + new ErrorHandler.NoOpErrorHandler(), + null, // userProfileService + false, // skipJsonValidation + EventProcessorMock.Object + ); + + EventProcessorMock.Setup(ep => ep.Process(It.IsAny())); + + var userContext = optimizelyWithMockedEvents.CreateUserContext(TestUserId, userAttributes); + var decision = userContext.Decide(featureFlag.Key, new[] { OptimizelyDecideOption.DISABLE_DECISION_EVENT }); + + Assert.IsNotNull(decision, "Decision should not be null"); + Assert.IsNotNull(decision.RuleKey, "User should be bucketed into a holdout"); + + var chosenHoldout = Config.Holdouts?.FirstOrDefault(h => h.Key == decision.RuleKey); + + Assert.IsNotNull(chosenHoldout, $"Holdout '{decision.RuleKey}' should exist in config"); + + Assert.AreEqual(featureFlag.Key, decision.FlagKey, "Flag key should match"); + + EventProcessorMock.Verify(ep => ep.Process(It.IsAny()), Times.Never, + "No impression event should be processed when DISABLE_DECISION_EVENT option is used"); + } + } +} diff --git a/OptimizelySDK.Tests/DecisionServiceTest.cs b/OptimizelySDK.Tests/DecisionServiceTest.cs index 633847ae1..8fbedf23c 100644 --- a/OptimizelySDK.Tests/DecisionServiceTest.cs +++ b/OptimizelySDK.Tests/DecisionServiceTest.cs @@ -1,6 +1,6 @@ /** * - * Copyright 2017-2021, Optimizely and contributors + * Copyright 2017-2021, 2024 Optimizely and contributors * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -65,7 +65,7 @@ public void SetUp() DecisionService = new DecisionService(new Bucketer(LoggerMock.Object), ErrorHandlerMock.Object, null, LoggerMock.Object); DecisionServiceMock = new Mock(BucketerMock.Object, - ErrorHandlerMock.Object, null, LoggerMock.Object) + ErrorHandlerMock.Object, null, LoggerMock.Object) { CallBase = true }; DecisionReasons = new DecisionReasons(); @@ -150,6 +150,11 @@ public void TestGetVariationLogsErrorWhenUserProfileMapItsNull() var decisionService = new DecisionService(BucketerMock.Object, ErrorHandlerMock.Object, UserProfileServiceMock.Object, LoggerMock.Object); var options = new OptimizelyDecideOption[] { OptimizelyDecideOption.INCLUDE_REASONS }; + var optlyObject = new Optimizely(TestData.Datafile, new ValidEventDispatcher(), + LoggerMock.Object); + OptimizelyUserContextMock = new Mock(optlyObject, + WhitelistedUserId, new UserAttributes(), ErrorHandlerMock.Object, + LoggerMock.Object); OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns(GenericUserId); var variationResult = decisionService.GetVariation(experiment, @@ -157,8 +162,10 @@ public void TestGetVariationLogsErrorWhenUserProfileMapItsNull() Assert.AreEqual(variationResult.DecisionReasons.ToReport(true)[0], "We were unable to get a user profile map from the UserProfileService."); Assert.AreEqual(variationResult.DecisionReasons.ToReport(true)[1], - "Audiences for experiment \"etag3\" collectively evaluated to FALSE"); + "No previously activated variation of experiment \"etag3\" for user \"genericUserId\" found in user profile."); Assert.AreEqual(variationResult.DecisionReasons.ToReport(true)[2], + "Audiences for experiment \"etag3\" collectively evaluated to FALSE"); + Assert.AreEqual(variationResult.DecisionReasons.ToReport(true)[3], "User \"genericUserId\" does not meet conditions to be in experiment \"etag3\"."); } @@ -291,6 +298,9 @@ public void TestBucketReturnsVariationStoredInUserProfile() { var experiment = ProjectConfig.Experiments[6]; var variation = experiment.Variations[0]; + var variationResult = Result.NewResult( + experiment.Variations[0], + DecisionReasons); var decision = new Decision(variation.Id); var userProfile = new UserProfile(UserProfileId, new Dictionary @@ -300,8 +310,10 @@ public void TestBucketReturnsVariationStoredInUserProfile() UserProfileServiceMock.Setup(_ => _.Lookup(UserProfileId)).Returns(userProfile.ToMap()); - var decisionService = new DecisionService(BucketerMock.Object, ErrorHandlerMock.Object, - UserProfileServiceMock.Object, LoggerMock.Object); + BucketerMock. + Setup(bm => bm.Bucket(ProjectConfig, experiment, It.IsAny(), + It.IsAny())). + Returns(variationResult); var optlyObject = new Optimizely(TestData.Datafile, new ValidEventDispatcher(), LoggerMock.Object); @@ -310,6 +322,8 @@ public void TestBucketReturnsVariationStoredInUserProfile() LoggerMock.Object); OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns(UserProfileId); + var decisionService = new DecisionService(BucketerMock.Object, ErrorHandlerMock.Object, + UserProfileServiceMock.Object, LoggerMock.Object); var actualVariation = decisionService.GetVariation(experiment, OptimizelyUserContextMock.Object, ProjectConfig); @@ -736,7 +750,8 @@ public void TestGetVariationForFeatureExperimentGivenNonMutexGroupAndUserIsBucke DecisionServiceMock.Setup(ds => ds.GetVariation( ProjectConfig.GetExperimentFromKey("test_experiment_multivariate"), OptimizelyUserContextMock.Object, ProjectConfig, - It.IsAny())). + It.IsAny(), It.IsAny(), + It.IsAny())). Returns(variation); var featureFlag = ProjectConfig.GetFeatureFlagFromKey("multi_variate_feature"); @@ -789,13 +804,18 @@ public void TestGetVariationForFeatureExperimentGivenMutexGroupAndUserIsBucketed [Test] public void TestGetVariationForFeatureExperimentGivenMutexGroupAndUserNotBucketed() { - var mutexExperiment = ProjectConfig.GetExperimentFromKey("group_experiment_1"); + var optlyObject = new Optimizely(TestData.Datafile, new ValidEventDispatcher(), + LoggerMock.Object); + OptimizelyUserContextMock = new Mock(optlyObject, + WhitelistedUserId, new UserAttributes(), ErrorHandlerMock.Object, + LoggerMock.Object); OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns("user1"); DecisionServiceMock. Setup(ds => ds.GetVariation(It.IsAny(), It.IsAny(), ProjectConfig, - It.IsAny())). + It.IsAny(), It.IsAny(), + It.IsAny())). Returns(Result.NullResult(null)); var featureFlag = ProjectConfig.GetFeatureFlagFromKey("boolean_feature"); @@ -856,7 +876,7 @@ public void TestGetVariationForFeatureRolloutWhenRolloutIsNotInDataFile() ds.GetVariationForFeatureExperiment(It.IsAny(), It.IsAny(), It.IsAny(), ProjectConfig, - new OptimizelyDecideOption[] { })). + new OptimizelyDecideOption[] { }, null)). Returns(null); var optlyObject = new Optimizely(TestData.Datafile, new ValidEventDispatcher(), LoggerMock.Object); @@ -1201,7 +1221,7 @@ public void TestGetVariationForFeatureWhenTheUserIsBucketedIntoFeatureExperiment DecisionServiceMock.Setup(ds => ds.GetVariationForFeatureExperiment( It.IsAny(), It.IsAny(), It.IsAny(), ProjectConfig, - It.IsAny())). + It.IsAny(), null)). Returns(expectedDecision); OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns("user1"); @@ -1228,7 +1248,7 @@ public void DecisionServiceMock.Setup(ds => ds.GetVariationForFeatureExperiment( It.IsAny(), It.IsAny(), It.IsAny(), ProjectConfig, - It.IsAny())). + It.IsAny(), null)). Returns(Result.NullResult(null)); DecisionServiceMock.Setup(ds => ds.GetVariationForFeatureRollout( It.IsAny(), It.IsAny(), @@ -1262,7 +1282,7 @@ public void ds.GetVariationForFeatureExperiment(It.IsAny(), It.IsAny(), It.IsAny(), ProjectConfig, - new OptimizelyDecideOption[] { })). + new OptimizelyDecideOption[] { }, null)). Returns(Result.NullResult(null)); DecisionServiceMock. Setup(ds => ds.GetVariationForFeatureRollout(It.IsAny(), @@ -1309,6 +1329,11 @@ public void TestGetVariationForFeatureWhenTheUserIsBuckedtedInBothExperimentAndR WhitelistedUserId, userAttributes, ErrorHandlerMock.Object, LoggerMock.Object); OptimizelyUserContextMock.Setup(ouc => ouc.GetUserId()).Returns(UserProfileId); + BucketerMock. + Setup(bm => bm.Bucket(ProjectConfig, experiment, It.IsAny(), + It.IsAny())). + Returns(variation); + DecisionServiceMock.Setup(ds => ds.GetVariation(experiment, OptimizelyUserContextMock.Object, ProjectConfig, It.IsAny())). diff --git a/OptimizelySDK.Tests/EntityTests/HoldoutTests.cs b/OptimizelySDK.Tests/EntityTests/HoldoutTests.cs new file mode 100644 index 000000000..a0f16fd0d --- /dev/null +++ b/OptimizelySDK.Tests/EntityTests/HoldoutTests.cs @@ -0,0 +1,184 @@ +/* + * Copyright 2025, Optimizely + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +using System; +using System.IO; +using Newtonsoft.Json; +using Newtonsoft.Json.Linq; +using NUnit.Framework; +using OptimizelySDK.Entity; + +namespace OptimizelySDK.Tests +{ + [TestFixture] + public class HoldoutTests + { + private JObject testData; + + [SetUp] + public void Setup() + { + // Load test data + var testDataPath = Path.Combine(TestContext.CurrentContext.TestDirectory, + "TestData", "HoldoutTestData.json"); + var jsonContent = File.ReadAllText(testDataPath); + testData = JObject.Parse(jsonContent); + } + + [Test] + public void TestHoldoutDeserialization() + { + // Test global holdout deserialization + var globalHoldoutJson = testData["globalHoldout"].ToString(); + var globalHoldout = JsonConvert.DeserializeObject(globalHoldoutJson); + + Assert.IsNotNull(globalHoldout); + Assert.AreEqual("holdout_global_1", globalHoldout.Id); + Assert.AreEqual("global_holdout", globalHoldout.Key); + Assert.AreEqual("Running", globalHoldout.Status); + Assert.IsNotNull(globalHoldout.Variations); + Assert.AreEqual(1, globalHoldout.Variations.Length); + Assert.IsNotNull(globalHoldout.TrafficAllocation); + Assert.AreEqual(1, globalHoldout.TrafficAllocation.Length); + Assert.IsNotNull(globalHoldout.IncludedFlags); + Assert.AreEqual(0, globalHoldout.IncludedFlags.Length); + Assert.IsNotNull(globalHoldout.ExcludedFlags); + Assert.AreEqual(0, globalHoldout.ExcludedFlags.Length); + } + + [Test] + public void TestHoldoutWithIncludedFlags() + { + var includedHoldoutJson = testData["includedFlagsHoldout"].ToString(); + var includedHoldout = JsonConvert.DeserializeObject(includedHoldoutJson); + + Assert.IsNotNull(includedHoldout); + Assert.AreEqual("holdout_included_1", includedHoldout.Id); + Assert.AreEqual("included_holdout", includedHoldout.Key); + Assert.IsNotNull(includedHoldout.IncludedFlags); + Assert.AreEqual(2, includedHoldout.IncludedFlags.Length); + Assert.Contains("flag_1", includedHoldout.IncludedFlags); + Assert.Contains("flag_2", includedHoldout.IncludedFlags); + Assert.IsNotNull(includedHoldout.ExcludedFlags); + Assert.AreEqual(0, includedHoldout.ExcludedFlags.Length); + } + + [Test] + public void TestHoldoutWithExcludedFlags() + { + var excludedHoldoutJson = testData["excludedFlagsHoldout"].ToString(); + var excludedHoldout = JsonConvert.DeserializeObject(excludedHoldoutJson); + + Assert.IsNotNull(excludedHoldout); + Assert.AreEqual("holdout_excluded_1", excludedHoldout.Id); + Assert.AreEqual("excluded_holdout", excludedHoldout.Key); + Assert.IsNotNull(excludedHoldout.IncludedFlags); + Assert.AreEqual(0, excludedHoldout.IncludedFlags.Length); + Assert.IsNotNull(excludedHoldout.ExcludedFlags); + Assert.AreEqual(2, excludedHoldout.ExcludedFlags.Length); + Assert.Contains("flag_3", excludedHoldout.ExcludedFlags); + Assert.Contains("flag_4", excludedHoldout.ExcludedFlags); + } + + [Test] + public void TestHoldoutWithEmptyFlags() + { + var globalHoldoutJson = testData["globalHoldout"].ToString(); + var globalHoldout = JsonConvert.DeserializeObject(globalHoldoutJson); + + Assert.IsNotNull(globalHoldout); + Assert.IsNotNull(globalHoldout.IncludedFlags); + Assert.AreEqual(0, globalHoldout.IncludedFlags.Length); + Assert.IsNotNull(globalHoldout.ExcludedFlags); + Assert.AreEqual(0, globalHoldout.ExcludedFlags.Length); + } + + [Test] + public void TestHoldoutEquality() + { + var holdoutJson = testData["globalHoldout"].ToString(); + var holdout1 = JsonConvert.DeserializeObject(holdoutJson); + var holdout2 = JsonConvert.DeserializeObject(holdoutJson); + + Assert.IsNotNull(holdout1); + Assert.IsNotNull(holdout2); + } + + [Test] + public void TestHoldoutStatusParsing() + { + var globalHoldoutJson = testData["globalHoldout"].ToString(); + var globalHoldout = JsonConvert.DeserializeObject(globalHoldoutJson); + + Assert.IsNotNull(globalHoldout); + Assert.AreEqual("Running", globalHoldout.Status); + } + + [Test] + public void TestHoldoutVariationsDeserialization() + { + var holdoutJson = testData["includedFlagsHoldout"].ToString(); + var holdout = JsonConvert.DeserializeObject(holdoutJson); + + Assert.IsNotNull(holdout); + Assert.IsNotNull(holdout.Variations); + Assert.AreEqual(1, holdout.Variations.Length); + + var variation = holdout.Variations[0]; + Assert.AreEqual("var_2", variation.Id); + Assert.AreEqual("treatment", variation.Key); + Assert.AreEqual(true, variation.FeatureEnabled); + } + + [Test] + public void TestHoldoutTrafficAllocationDeserialization() + { + var holdoutJson = testData["excludedFlagsHoldout"].ToString(); + var holdout = JsonConvert.DeserializeObject(holdoutJson); + + Assert.IsNotNull(holdout); + Assert.IsNotNull(holdout.TrafficAllocation); + Assert.AreEqual(1, holdout.TrafficAllocation.Length); + + var trafficAllocation = holdout.TrafficAllocation[0]; + Assert.AreEqual("var_3", trafficAllocation.EntityId); + Assert.AreEqual(10000, trafficAllocation.EndOfRange); + } + + [Test] + public void TestHoldoutNullSafety() + { + // Test that holdout can handle null/missing includedFlags and excludedFlags + var minimalHoldoutJson = @"{ + ""id"": ""test_holdout"", + ""key"": ""test_key"", + ""status"": ""Running"", + ""variations"": [], + ""trafficAllocation"": [], + ""audienceIds"": [], + ""audienceConditions"": [] + }"; + + var holdout = JsonConvert.DeserializeObject(minimalHoldoutJson); + + Assert.IsNotNull(holdout); + Assert.AreEqual("test_holdout", holdout.Id); + Assert.AreEqual("test_key", holdout.Key); + Assert.IsNotNull(holdout.IncludedFlags); + Assert.IsNotNull(holdout.ExcludedFlags); + } + } +} diff --git a/OptimizelySDK.Tests/EventTests/EventBuilderTest.cs b/OptimizelySDK.Tests/EventTests/EventBuilderTest.cs index c869d831b..8b4c3ad54 100644 --- a/OptimizelySDK.Tests/EventTests/EventBuilderTest.cs +++ b/OptimizelySDK.Tests/EventTests/EventBuilderTest.cs @@ -115,7 +115,7 @@ public void TestCreateImpressionEventNoAttributes() { "anonymize_ip", false }, }; - var expectedLogEvent = new LogEvent("https://logx.optimizely.com/v1/events", + var expectedLogEvent = new LogEvent(EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -207,7 +207,7 @@ public void TestCreateImpressionEventWithAttributes() { "anonymize_ip", false }, }; - var expectedLogEvent = new LogEvent("https://logx.optimizely.com/v1/events", + var expectedLogEvent = new LogEvent(EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -327,7 +327,7 @@ public void TestCreateImpressionEventWithTypedAttributes() { "anonymize_ip", false }, }; - var expectedLogEvent = new LogEvent("https://logx.optimizely.com/v1/events", + var expectedLogEvent = new LogEvent(EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -441,7 +441,7 @@ public void TestCreateImpressionEventRemovesInvalidAttributesFromPayload() { "anonymize_ip", false }, }; - var expectedLogEvent = new LogEvent("https://logx.optimizely.com/v1/events", + var expectedLogEvent = new LogEvent(EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -531,7 +531,7 @@ public void TestCreateConversionEventNoAttributesNoValue() }; var expectedEvent = new LogEvent( - "https://logx.optimizely.com/v1/events", + EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -617,7 +617,7 @@ public void TestCreateConversionEventWithAttributesNoValue() }; var expectedEvent = new LogEvent( - "https://logx.optimizely.com/v1/events", + EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -709,7 +709,7 @@ public void TestCreateConversionEventNoAttributesWithValue() }; var expectedEvent = new LogEvent( - "https://logx.optimizely.com/v1/events", + EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -809,7 +809,7 @@ public void TestCreateConversionEventWithAttributesWithValue() }; var expectedEvent = new LogEvent( - "https://logx.optimizely.com/v1/events", + EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -909,7 +909,7 @@ public void TestCreateConversionEventNoAttributesWithInvalidValue() }; var expectedEvent = new LogEvent( - "https://logx.optimizely.com/v1/events", + EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -1003,7 +1003,7 @@ public void TestConversionEventWithNumericTag() }; var expectedEvent = new LogEvent( - "https://logx.optimizely.com/v1/events", + EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -1096,7 +1096,7 @@ public void TestConversionEventWithFalsyNumericAndRevenueValues() }; var expectedEvent = new LogEvent( - "https://logx.optimizely.com/v1/events", + EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -1189,7 +1189,7 @@ public void TestConversionEventWithNumericValue1() }; var expectedEvent = new LogEvent( - "https://logx.optimizely.com/v1/events", + EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -1282,7 +1282,7 @@ public void TestConversionEventWithRevenueValue1() }; var expectedEvent = new LogEvent( - "https://logx.optimizely.com/v1/events", + EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -1381,7 +1381,7 @@ public void TestCreateConversionEventWithBucketingIDAttribute() }; var expectedEvent = new LogEvent( - "https://logx.optimizely.com/v1/events", + EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -1487,7 +1487,7 @@ public void TestCreateImpressionEventWithBucketingIDAttribute() { "anonymize_ip", false }, }; - var expectedLogEvent = new LogEvent("https://logx.optimizely.com/v1/events", + var expectedLogEvent = new LogEvent(EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -1587,7 +1587,7 @@ public void TestCreateImpressionEventWhenBotFilteringIsProvidedInDatafile() { "anonymize_ip", false }, }; - var expectedLogEvent = new LogEvent("https://logx.optimizely.com/v1/events", + var expectedLogEvent = new LogEvent(EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -1680,7 +1680,7 @@ public void TestCreateImpressionEventWhenBotFilteringIsNotProvidedInDatafile() { "anonymize_ip", false }, }; - var expectedLogEvent = new LogEvent("https://logx.optimizely.com/v1/events", + var expectedLogEvent = new LogEvent(EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -1770,7 +1770,7 @@ public void TestCreateConversionEventWhenBotFilteringIsProvidedInDatafile() }; var expectedEvent = new LogEvent( - "https://logx.optimizely.com/v1/events", + EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -1856,7 +1856,7 @@ public void TestCreateConversionEventWhenBotFilteringIsNotProvidedInDatafile() }; var expectedEvent = new LogEvent( - "https://logx.optimizely.com/v1/events", + EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -1989,7 +1989,7 @@ public void TestCreateConversionEventWhenEventUsedInMultipleExp() var expectedLogEvent = new LogEvent( - "https://logx.optimizely.com/v1/events", + EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -2082,7 +2082,7 @@ public void TestCreateConversionEventRemovesInvalidAttributesFromPayload() }; var expectedEvent = new LogEvent( - "https://logx.optimizely.com/v1/events", + EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary diff --git a/OptimizelySDK.Tests/EventTests/EventFactoryTest.cs b/OptimizelySDK.Tests/EventTests/EventFactoryTest.cs index 3199a8ae3..8c839d675 100644 --- a/OptimizelySDK.Tests/EventTests/EventFactoryTest.cs +++ b/OptimizelySDK.Tests/EventTests/EventFactoryTest.cs @@ -66,6 +66,208 @@ public void Assert.IsNull(impressionEvent); } + [Test] + public void TestCreateImpressionEventNoAttributesEU() + { + var guid = Guid.NewGuid(); + var timeStamp = TestData.SecondsSince1970(); + + var payloadParams = new Dictionary + { + { + "visitors", new object[] + { + new Dictionary() + { + { + "snapshots", new object[] + { + new Dictionary + { + { + "decisions", new object[] + { + new Dictionary + { + { "campaign_id", "7719770039" }, + { "experiment_id", "7716830082" }, + { "variation_id", "7722370027" }, + { + "metadata", + new Dictionary + { + { "rule_type", "experiment" }, + { "rule_key", "test_experiment" }, + { "flag_key", "test_experiment" }, + { "variation_key", "control" }, + { "enabled", false }, + } + }, + }, + } + }, + { + "events", new object[] + { + new Dictionary + { + { "entity_id", "7719770039" }, + { "timestamp", timeStamp }, + { "uuid", guid }, + { "key", "campaign_activated" }, + }, + } + }, + }, + } + }, + { + "attributes", new object[] + { + new Dictionary + { + { "entity_id", ControlAttributes.BOT_FILTERING_ATTRIBUTE }, + { "key", ControlAttributes.BOT_FILTERING_ATTRIBUTE }, + { "type", "custom" }, + { "value", true }, + }, + } + }, + { "visitor_id", TestUserId }, + }, + } + }, + { "project_id", "7720880029" }, + { "account_id", "1592310167" }, + { "enrich_decisions", true }, + { "client_name", "csharp-sdk" }, + { "client_version", Optimizely.SDK_VERSION }, + { "revision", "15" }, + { "anonymize_ip", false }, + }; + + var expectedLogEvent = new LogEvent(EventFactory.EventEndpoints["EU"], + payloadParams, + "POST", + new Dictionary + { + { "Content-Type", "application/json" }, + }); + + Config.Region = "EU"; + var impressionEvent = UserEventFactory.CreateImpressionEvent( + Config, Config.GetExperimentFromKey("test_experiment"), "7722370027", TestUserId, + null, "test_experiment", "experiment"); + + var logEvent = EventFactory.CreateLogEvent(impressionEvent, Logger); + + TestData.ChangeGUIDAndTimeStamp(expectedLogEvent.Params, impressionEvent.Timestamp, + Guid.Parse(impressionEvent.UUID)); + + Assert.IsTrue(TestData.CompareObjects(expectedLogEvent, logEvent)); + } + + [Test] + public void TestCreateImpressionEventNoAttributesInvalid() + { + var guid = Guid.NewGuid(); + var timeStamp = TestData.SecondsSince1970(); + + var payloadParams = new Dictionary + { + { + "visitors", new object[] + { + new Dictionary() + { + { + "snapshots", new object[] + { + new Dictionary + { + { + "decisions", new object[] + { + new Dictionary + { + { "campaign_id", "7719770039" }, + { "experiment_id", "7716830082" }, + { "variation_id", "7722370027" }, + { + "metadata", + new Dictionary + { + { "rule_type", "experiment" }, + { "rule_key", "test_experiment" }, + { "flag_key", "test_experiment" }, + { "variation_key", "control" }, + { "enabled", false }, + } + }, + }, + } + }, + { + "events", new object[] + { + new Dictionary + { + { "entity_id", "7719770039" }, + { "timestamp", timeStamp }, + { "uuid", guid }, + { "key", "campaign_activated" }, + }, + } + }, + }, + } + }, + { + "attributes", new object[] + { + new Dictionary + { + { "entity_id", ControlAttributes.BOT_FILTERING_ATTRIBUTE }, + { "key", ControlAttributes.BOT_FILTERING_ATTRIBUTE }, + { "type", "custom" }, + { "value", true }, + }, + } + }, + { "visitor_id", TestUserId }, + }, + } + }, + { "project_id", "7720880029" }, + { "account_id", "1592310167" }, + { "enrich_decisions", true }, + { "client_name", "csharp-sdk" }, + { "client_version", Optimizely.SDK_VERSION }, + { "revision", "15" }, + { "anonymize_ip", false }, + }; + + var expectedLogEvent = new LogEvent(EventFactory.EventEndpoints["US"], + payloadParams, + "POST", + new Dictionary + { + { "Content-Type", "application/json" }, + }); + + Config.Region = "ZZ"; + var impressionEvent = UserEventFactory.CreateImpressionEvent( + Config, Config.GetExperimentFromKey("test_experiment"), "7722370027", TestUserId, + null, "test_experiment", "experiment"); + + var logEvent = EventFactory.CreateLogEvent(impressionEvent, Logger); + + TestData.ChangeGUIDAndTimeStamp(expectedLogEvent.Params, impressionEvent.Timestamp, + Guid.Parse(impressionEvent.UUID)); + + Assert.IsTrue(TestData.CompareObjects(expectedLogEvent, logEvent)); + } + [Test] public void TestCreateImpressionEventNoAttributes() { @@ -146,7 +348,7 @@ public void TestCreateImpressionEventNoAttributes() { "anonymize_ip", false }, }; - var expectedLogEvent = new LogEvent("https://logx.optimizely.com/v1/events", + var expectedLogEvent = new LogEvent(EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -251,7 +453,7 @@ public void TestCreateImpressionEventWithAttributes() { "anonymize_ip", false }, }; - var expectedLogEvent = new LogEvent("https://logx.optimizely.com/v1/events", + var expectedLogEvent = new LogEvent(EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -383,7 +585,7 @@ public void TestCreateImpressionEventWithTypedAttributes() { "anonymize_ip", false }, }; - var expectedLogEvent = new LogEvent("https://logx.optimizely.com/v1/events", + var expectedLogEvent = new LogEvent(EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -509,7 +711,7 @@ public void TestCreateImpressionEventRemovesInvalidAttributesFromPayload() { "anonymize_ip", false }, }; - var expectedLogEvent = new LogEvent("https://logx.optimizely.com/v1/events", + var expectedLogEvent = new LogEvent(EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -642,7 +844,7 @@ public void TestCreateImpressionEventRemovesInvalidAttributesFromPayloadRollout( { "anonymize_ip", false }, }; - var expectedLogEvent = new LogEvent("https://logx.optimizely.com/v1/events", + var expectedLogEvent = new LogEvent(EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -735,7 +937,170 @@ public void TestCreateConversionEventNoAttributesNoValue() }; var expectedEvent = new LogEvent( - "https://logx.optimizely.com/v1/events", + EventFactory.EventEndpoints["US"], + payloadParams, + "POST", + new Dictionary + { + { "Content-Type", "application/json" }, + }); + var experimentToVariationMap = new Dictionary + { + { "7716830082", new Variation { Id = "7722370027", Key = "control" } }, + }; + + var conversionEvent = + UserEventFactory.CreateConversionEvent(Config, "purchase", TestUserId, null, null); + var logEvent = EventFactory.CreateLogEvent(conversionEvent, Logger); + + TestData.ChangeGUIDAndTimeStamp(expectedEvent.Params, conversionEvent.Timestamp, + Guid.Parse(conversionEvent.UUID)); + + Assert.IsTrue(TestData.CompareObjects(expectedEvent, logEvent)); + } + + [Test] + public void TestCreateConversionEventNoAttributesNoValueEU() + { + var guid = Guid.NewGuid(); + var timeStamp = TestData.SecondsSince1970(); + + var payloadParams = new Dictionary + { + { + "visitors", new object[] + { + new Dictionary + { + { + "snapshots", new object[] + { + new Dictionary + { + { + "events", new object[] + { + new Dictionary + { + { "entity_id", "7718020063" }, + { "timestamp", timeStamp }, + { "uuid", guid }, + { "key", "purchase" }, + }, + } + }, + }, + } + }, + { "visitor_id", TestUserId }, + { + "attributes", new object[] + { + new Dictionary + { + { "entity_id", ControlAttributes.BOT_FILTERING_ATTRIBUTE }, + { "key", ControlAttributes.BOT_FILTERING_ATTRIBUTE }, + { "type", "custom" }, + { "value", true }, + }, + } + }, + }, + } + }, + { "project_id", "7720880029" }, + { "enrich_decisions", true }, + { "account_id", "1592310167" }, + { "client_name", "csharp-sdk" }, + { "client_version", Optimizely.SDK_VERSION }, + { "revision", "15" }, + { "anonymize_ip", false }, + }; + + var expectedEvent = new LogEvent( + EventFactory.EventEndpoints["EU"], + payloadParams, + "POST", + new Dictionary + { + { "Content-Type", "application/json" }, + }); + var experimentToVariationMap = new Dictionary + { + { "7716830082", new Variation { Id = "7722370027", Key = "control" } }, + }; + + Config.Region = "EU"; + var conversionEvent = + UserEventFactory.CreateConversionEvent(Config, "purchase", TestUserId, null, null); + var logEvent = EventFactory.CreateLogEvent(conversionEvent, Logger); + + TestData.ChangeGUIDAndTimeStamp(expectedEvent.Params, conversionEvent.Timestamp, + Guid.Parse(conversionEvent.UUID)); + + Assert.IsTrue(TestData.CompareObjects(expectedEvent, logEvent)); + } + + [Test] + public void TestCreateConversionEventNoAttributesNoValueInvalid() + { + var guid = Guid.NewGuid(); + var timeStamp = TestData.SecondsSince1970(); + + var payloadParams = new Dictionary + { + { + "visitors", new object[] + { + new Dictionary + { + { + "snapshots", new object[] + { + new Dictionary + { + { + "events", new object[] + { + new Dictionary + { + { "entity_id", "7718020063" }, + { "timestamp", timeStamp }, + { "uuid", guid }, + { "key", "purchase" }, + }, + } + }, + }, + } + }, + { "visitor_id", TestUserId }, + { + "attributes", new object[] + { + new Dictionary + { + { "entity_id", ControlAttributes.BOT_FILTERING_ATTRIBUTE }, + { "key", ControlAttributes.BOT_FILTERING_ATTRIBUTE }, + { "type", "custom" }, + { "value", true }, + }, + } + }, + }, + } + }, + { "project_id", "7720880029" }, + { "enrich_decisions", true }, + { "account_id", "1592310167" }, + { "client_name", "csharp-sdk" }, + { "client_version", Optimizely.SDK_VERSION }, + { "revision", "15" }, + { "anonymize_ip", false }, + }; + + var expectedEvent = new LogEvent( + EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -747,6 +1112,7 @@ public void TestCreateConversionEventNoAttributesNoValue() { "7716830082", new Variation { Id = "7722370027", Key = "control" } }, }; + Config.Region = "ZZ"; var conversionEvent = UserEventFactory.CreateConversionEvent(Config, "purchase", TestUserId, null, null); var logEvent = EventFactory.CreateLogEvent(conversionEvent, Logger); @@ -823,7 +1189,7 @@ public void TestCreateConversionEventWithAttributesNoValue() }; var expectedEvent = new LogEvent( - "https://logx.optimizely.com/v1/events", + EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -918,7 +1284,7 @@ public void TestCreateConversionEventNoAttributesWithValue() }; var expectedEvent = new LogEvent( - "https://logx.optimizely.com/v1/events", + EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -1020,7 +1386,7 @@ public void TestCreateConversionEventWithAttributesWithValue() }; var expectedEvent = new LogEvent( - "https://logx.optimizely.com/v1/events", + EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -1122,7 +1488,7 @@ public void TestCreateConversionEventNoAttributesWithInvalidValue() }; var expectedEvent = new LogEvent( - "https://logx.optimizely.com/v1/events", + EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -1218,7 +1584,7 @@ public void TestConversionEventWithNumericTag() }; var expectedEvent = new LogEvent( - "https://logx.optimizely.com/v1/events", + EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -1316,7 +1682,7 @@ public void TestConversionEventWithFalsyNumericAndRevenueValues() }; var expectedEvent = new LogEvent( - "https://logx.optimizely.com/v1/events", + EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -1412,7 +1778,7 @@ public void TestConversionEventWithNumericValue1() }; var expectedEvent = new LogEvent( - "https://logx.optimizely.com/v1/events", + EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -1507,7 +1873,7 @@ public void TestConversionEventWithRevenueValue1() }; var expectedEvent = new LogEvent( - "https://logx.optimizely.com/v1/events", + EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -1609,7 +1975,7 @@ public void TestCreateConversionEventWithBucketingIDAttribute() }; var expectedEvent = new LogEvent( - "https://logx.optimizely.com/v1/events", + EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -1727,7 +2093,7 @@ public void TestCreateImpressionEventWithBucketingIDAttribute() { "anonymize_ip", false }, }; - var expectedLogEvent = new LogEvent("https://logx.optimizely.com/v1/events", + var expectedLogEvent = new LogEvent(EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -1838,7 +2204,7 @@ public void TestCreateImpressionEventWhenBotFilteringIsProvidedInDatafile() { "anonymize_ip", false }, }; - var expectedLogEvent = new LogEvent("https://logx.optimizely.com/v1/events", + var expectedLogEvent = new LogEvent(EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -1945,7 +2311,7 @@ public void TestCreateImpressionEventWhenBotFilteringIsNotProvidedInDatafile() { "anonymize_ip", false }, }; - var expectedLogEvent = new LogEvent("https://logx.optimizely.com/v1/events", + var expectedLogEvent = new LogEvent(EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -2039,7 +2405,7 @@ public void TestCreateConversionEventWhenBotFilteringIsProvidedInDatafile() }; var expectedEvent = new LogEvent( - "https://logx.optimizely.com/v1/events", + EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -2128,7 +2494,7 @@ public void TestCreateConversionEventWhenBotFilteringIsNotProvidedInDatafile() }; var expectedEvent = new LogEvent( - "https://logx.optimizely.com/v1/events", + EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -2250,7 +2616,7 @@ public void TestCreateConversionEventWhenEventUsedInMultipleExp() var expectedLogEvent = new LogEvent( - "https://logx.optimizely.com/v1/events", + EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary @@ -2358,7 +2724,7 @@ public void TestCreateConversionEventRemovesInvalidAttributesFromPayload() }; var expectedEvent = new LogEvent( - "https://logx.optimizely.com/v1/events", + EventFactory.EventEndpoints["US"], payloadParams, "POST", new Dictionary diff --git a/OptimizelySDK.Tests/EventTests/TestForwardingEventDispatcher.cs b/OptimizelySDK.Tests/EventTests/TestForwardingEventDispatcher.cs index 01eca1ee6..9b7cf5336 100644 --- a/OptimizelySDK.Tests/EventTests/TestForwardingEventDispatcher.cs +++ b/OptimizelySDK.Tests/EventTests/TestForwardingEventDispatcher.cs @@ -18,7 +18,7 @@ public class TestForwardingEventDispatcher : IEventDispatcher public void DispatchEvent(LogEvent logEvent) { Assert.AreEqual(logEvent.HttpVerb, "POST"); - Assert.AreEqual(logEvent.Url, EventFactory.EVENT_ENDPOINT); + Assert.AreEqual(logEvent.Url, EventFactory.EventEndpoints["US"]); IsUpdated = true; } } diff --git a/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs b/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs index 426240c54..2ff8071de 100644 --- a/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs +++ b/OptimizelySDK.Tests/OdpTests/LruCacheTest.cs @@ -208,5 +208,113 @@ public void ShouldHandleWhenCacheIsReset() Assert.AreEqual(0, cache.CurrentCacheKeysForTesting().Length); } + + [Test] + public void ShouldHandleRemoveNonExistentKey() + { + var cache = new LruCache>(); + cache.Save("user1", _segments1And2); + cache.Save("user2", _segments3And4); + + // Remove a key that doesn't exist + cache.Remove("user3"); + + // Existing keys should still be there + Assert.AreEqual(_segments1And2, cache.Lookup("user1")); + Assert.AreEqual(_segments3And4, cache.Lookup("user2")); + } + + [Test] + public void ShouldHandleRemoveExistingKey() + { + var cache = new LruCache>(); + + cache.Save("user1", _segments1And2); + cache.Save("user2", _segments3And4); + cache.Save("user3", _segments5And6); + + Assert.AreEqual(_segments1And2, cache.Lookup("user1")); + Assert.AreEqual(_segments3And4, cache.Lookup("user2")); + Assert.AreEqual(_segments5And6, cache.Lookup("user3")); + + cache.Remove("user2"); + + Assert.AreEqual(_segments1And2, cache.Lookup("user1")); + Assert.IsNull(cache.Lookup("user2")); + Assert.AreEqual(_segments5And6, cache.Lookup("user3")); + } + + [Test] + public void ShouldHandleRemoveFromZeroSizedCache() + { + var cache = new LruCache>(0); + + cache.Save("user1", _segments1And2); + cache.Remove("user1"); + + Assert.IsNull(cache.Lookup("user1")); + Assert.AreEqual(0, cache.CurrentCacheKeysForTesting().Length); + } + + [Test] + public void ShouldHandleRemoveAndAddBack() + { + var cache = new LruCache>(); + + cache.Save("user1", _segments1And2); + cache.Save("user2", _segments3And4); + cache.Save("user3", _segments5And6); + + // Remove user2 and add it back with different data + cache.Remove("user2"); + cache.Save("user2", _segments1And2); + + Assert.AreEqual(_segments1And2, cache.Lookup("user1")); + Assert.AreEqual(_segments1And2, cache.Lookup("user2")); + Assert.AreEqual(_segments5And6, cache.Lookup("user3")); + + Assert.AreEqual(3, cache.CurrentCacheKeysForTesting().Length); + } + + [Test] + public void ShouldHandleThreadSafetyWithRemove() + { + var cache = new LruCache(100); + + for (int i = 1; i <= 100; i++) + { + cache.Save($"key{i}", $"value{i}"); + } + + var threads = new List(); + + for (int i = 1; i <= 50; i++) + { + int localI = i; // Capture variable for closure + var thread = new Thread(() => cache.Remove($"key{localI}")); + threads.Add(thread); + thread.Start(); + } + + // Wait for all threads to complete + foreach (var thread in threads) + { + thread.Join(); + } + + for (int i = 1; i <= 100; i++) + { + if (i <= 50) + { + Assert.IsNull(cache.Lookup($"key{i}"), $"key{i} should be removed"); + } + else + { + Assert.AreEqual($"value{i}", cache.Lookup($"key{i}"), $"key{i} should still exist"); + } + } + + Assert.AreEqual(50, cache.CurrentCacheKeysForTesting().Length); + } } } diff --git a/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj b/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj index 6792d934c..01469f77a 100644 --- a/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj +++ b/OptimizelySDK.Tests/OptimizelySDK.Tests.csproj @@ -70,6 +70,7 @@ + @@ -106,6 +107,9 @@ + + + @@ -119,6 +123,7 @@ + @@ -126,12 +131,16 @@ + + + PreserveNewest + diff --git a/OptimizelySDK.Tests/OptimizelyTest.cs b/OptimizelySDK.Tests/OptimizelyTest.cs index 5dab3aec6..034b4bc0e 100644 --- a/OptimizelySDK.Tests/OptimizelyTest.cs +++ b/OptimizelySDK.Tests/OptimizelyTest.cs @@ -339,6 +339,12 @@ public void TestDecisionNotificationSentWhenSendFlagDecisionsFalseAndFeature() { "decisionEventDispatched", true }, + { + "experimentId", "7718750065" + }, + { + "variationId", "7713030086" + } }))), Times.Once); EventDispatcherMock.Verify(dispatcher => dispatcher.DispatchEvent(It.IsAny()), Times.Once); @@ -405,6 +411,12 @@ public void TestDecisionNotificationSentWhenSendFlagDecisionsTrueAndFeature() { "decisionEventDispatched", true }, + { + "experimentId", "7718750065" + }, + { + "variationId", "7713030086" + } }))), Times.Once); EventDispatcherMock.Verify(dispatcher => dispatcher.DispatchEvent(It.IsAny()), Times.Once); @@ -476,6 +488,12 @@ public void TestDecisionNotificationNotSentWhenSendFlagDecisionsFalseAndRollout( { "decisionEventDispatched", false }, + { + "experimentId", experiment.Id + }, + { + "variationId", variation.Id + } }))), Times.Once); EventDispatcherMock.Verify(dispatcher => dispatcher.DispatchEvent(It.IsAny()), Times.Never); @@ -547,6 +565,12 @@ public void TestDecisionNotificationSentWhenSendFlagDecisionsTrueAndRollout() { "decisionEventDispatched", true }, + { + "experimentId", experiment.Id + }, + { + "variationId", variation.Id + } }))), Times.Once); EventDispatcherMock.Verify(dispatcher => dispatcher.DispatchEvent(It.IsAny()), Times.Once); @@ -2361,8 +2385,7 @@ public void Assert.AreEqual(expectedValue, variableValue); LoggerMock.Verify(l => l.Log(LogLevel.INFO, - $@"Got variable value ""{variableValue}"" for variable ""{variableKey - }"" of feature flag ""{featureKey}"".")); + $@"Got variable value ""{variableValue}"" for variable ""{variableKey}"" of feature flag ""{featureKey}"".")); } [Test] @@ -2406,8 +2429,7 @@ public void Assert.AreEqual(expectedValue, variableValue); LoggerMock.Verify(l => l.Log(LogLevel.INFO, - $@"Got variable value ""{variableValue}"" for variable ""{variableKey - }"" of feature flag ""{featureKey}"".")); + $@"Got variable value ""{variableValue}"" for variable ""{variableKey}"" of feature flag ""{featureKey}"".")); } [Test] @@ -2439,8 +2461,7 @@ public void Assert.AreEqual(expectedValue, variableValue); LoggerMock.Verify(l => l.Log(LogLevel.INFO, - $@"Feature ""{featureKey}"" is not enabled for user {TestUserId - }. Returning the default variable value ""{variableValue}"".")); + $@"Feature ""{featureKey}"" is not enabled for user {TestUserId}. Returning the default variable value ""{variableValue}"".")); } [Test] @@ -2484,8 +2505,7 @@ public void Assert.AreEqual(expectedValue, variableValue); LoggerMock.Verify(l => l.Log(LogLevel.INFO, - $@"Feature ""{featureKey}"" is not enabled for user {TestUserId - }. Returning the default variable value ""{variableValue}"".")); + $@"Feature ""{featureKey}"" is not enabled for user {TestUserId}. Returning the default variable value ""{variableValue}"".")); } [Test] @@ -2515,8 +2535,7 @@ public void Assert.AreEqual(expectedValue, variableValue); LoggerMock.Verify(l => l.Log(LogLevel.INFO, - $@"Got variable value ""true"" for variable ""{variableKey}"" of feature flag ""{ - featureKey}"".")); + $@"Got variable value ""true"" for variable ""{variableKey}"" of feature flag ""{featureKey}"".")); } [Test] @@ -2562,8 +2581,7 @@ public void Assert.AreEqual(expectedStringValue, variableValue.GetValue("string_var")); LoggerMock.Verify(l => l.Log(LogLevel.INFO, - $@"Got variable value ""{variableValue}"" for variable ""{variableKey - }"" of feature flag ""{featureKey}"".")); + $@"Got variable value ""{variableValue}"" for variable ""{variableKey}"" of feature flag ""{featureKey}"".")); } [Test] @@ -2609,8 +2627,7 @@ public void Assert.AreEqual(expectedStringValue, variableValue.GetValue("string_var")); LoggerMock.Verify(l => l.Log(LogLevel.INFO, - $@"Got variable value ""{variableValue}"" for variable ""{variableKey - }"" of feature flag ""{featureKey}"".")); + $@"Got variable value ""{variableValue}"" for variable ""{variableKey}"" of feature flag ""{featureKey}"".")); } [Test] @@ -2654,8 +2671,7 @@ public void Assert.AreEqual(expectedValue, variableValue); LoggerMock.Verify(l => l.Log(LogLevel.INFO, - $@"Got variable value ""{variableValue}"" for variable ""{variableKey - }"" of feature flag ""{featureKey}"".")); + $@"Got variable value ""{variableValue}"" for variable ""{variableKey}"" of feature flag ""{featureKey}"".")); } [Test] @@ -2684,8 +2700,7 @@ public void variableKey, TestUserId, null); Assert.AreEqual(expectedValue, variableValue); LoggerMock.Verify(l => l.Log(LogLevel.INFO, - $@"Feature ""{featureKey}"" is not enabled for user {TestUserId - }. Returning the default variable value ""true"".")); + $@"Feature ""{featureKey}"" is not enabled for user {TestUserId}. Returning the default variable value ""true"".")); } [Test] @@ -2728,8 +2743,7 @@ public void Assert.AreEqual(expectedValue, variableValue); LoggerMock.Verify(l => l.Log(LogLevel.INFO, - $@"Feature ""{featureKey}"" is not enabled for user {TestUserId - }. Returning the default variable value ""{variableValue}"".")); + $@"Feature ""{featureKey}"" is not enabled for user {TestUserId}. Returning the default variable value ""{variableValue}"".")); } [Test] @@ -2758,8 +2772,7 @@ public void Assert.AreEqual(expectedValue, variableValue); LoggerMock.Verify(l => l.Log(LogLevel.INFO, - $@"User ""{TestUserId}"" is not in any variation for feature flag ""{featureKey - }"", returning default value ""{variableValue}"".")); + $@"User ""{TestUserId}"" is not in any variation for feature flag ""{featureKey}"", returning default value ""{variableValue}"".")); } #endregion Feature Toggle Tests @@ -2822,8 +2835,7 @@ public void TestGetFeatureVariableValueForTypeGivenFeatureKeyOrVariableKeyNotFou LoggerMock.Verify(l => l.Log(LogLevel.ERROR, $@"Feature key ""{featureKey}"" is not in datafile.")); LoggerMock.Verify(l => l.Log(LogLevel.ERROR, - $@"No feature variable was found for key ""{variableKey - }"" in feature flag ""double_single_variable_feature"".")); + $@"No feature variable was found for key ""{variableKey}"" in feature flag ""double_single_variable_feature"".")); } // Should return null and log error message when variable type is invalid. @@ -2851,17 +2863,13 @@ public void TestGetFeatureVariableValueForTypeGivenInvalidVariableType() "string_single_variable_feature", "json_var", TestUserId, null, variableTypeInt)); LoggerMock.Verify(l => l.Log(LogLevel.ERROR, - $@"Variable is of type ""double"", but you requested it as type ""{variableTypeBool - }"".")); + $@"Variable is of type ""double"", but you requested it as type ""{variableTypeBool}"".")); LoggerMock.Verify(l => l.Log(LogLevel.ERROR, - $@"Variable is of type ""boolean"", but you requested it as type ""{ - variableTypeDouble}"".")); + $@"Variable is of type ""boolean"", but you requested it as type ""{variableTypeDouble}"".")); LoggerMock.Verify(l => l.Log(LogLevel.ERROR, - $@"Variable is of type ""integer"", but you requested it as type ""{ - variableTypeString}"".")); + $@"Variable is of type ""integer"", but you requested it as type ""{variableTypeString}"".")); LoggerMock.Verify(l => l.Log(LogLevel.ERROR, - $@"Variable is of type ""string"", but you requested it as type ""{variableTypeInt - }"".")); + $@"Variable is of type ""string"", but you requested it as type ""{variableTypeInt}"".")); } [Test] @@ -2913,8 +2921,7 @@ public void TestGetFeatureVariableValueForTypeGivenFeatureFlagIsNotEnabledForUse Assert.AreEqual(expectedValue, variableValue); LoggerMock.Verify(l => l.Log(LogLevel.INFO, - $@"Feature ""{featureKey}"" is not enabled for user {TestUserId - }. Returning the default variable value ""{variableValue}"".")); + $@"Feature ""{featureKey}"" is not enabled for user {TestUserId}. Returning the default variable value ""{variableValue}"".")); } // Should return default value and log message when feature is enabled for the user @@ -2954,9 +2961,7 @@ public void Assert.AreEqual(expectedValue, variableValue); LoggerMock.Verify(l => l.Log(LogLevel.INFO, - $@"Variable ""{variableKey - }"" is not used in variation ""control"", returning default value ""{expectedValue - }"".")); + $@"Variable ""{variableKey}"" is not used in variation ""control"", returning default value ""{expectedValue}"".")); } // Should return variable value from variation and log message when feature is enabled for the user @@ -2994,8 +2999,7 @@ public void Assert.AreEqual(expectedValue, variableValue); LoggerMock.Verify(l => l.Log(LogLevel.INFO, - $@"Got variable value ""{variableValue}"" for variable ""{variableKey - }"" of feature flag ""{featureKey}"".")); + $@"Got variable value ""{variableValue}"" for variable ""{variableKey}"" of feature flag ""{featureKey}"".")); } // Verify that GetFeatureVariableValueForType returns correct variable value for rollout rule. @@ -3149,8 +3153,7 @@ public void TestIsFeatureEnabledGivenFeatureFlagIsEnabledAndUserIsNotBeingExperi // SendImpressionEvent() does not get called. LoggerMock.Verify(l => l.Log(LogLevel.INFO, - $@"The user ""{TestUserId}"" is not being experimented on feature ""{featureKey - }""."), Times.Once); + $@"The user ""{TestUserId}"" is not being experimented on feature ""{featureKey}""."), Times.Once); LoggerMock.Verify(l => l.Log(LogLevel.INFO, $@"Feature flag ""{featureKey}"" is enabled for user ""{TestUserId}"".")); @@ -3183,8 +3186,7 @@ public void TestIsFeatureEnabledGivenFeatureFlagIsEnabledAndUserIsBeingExperimen // SendImpressionEvent() gets called. LoggerMock.Verify(l => l.Log(LogLevel.INFO, - $@"The user ""{TestUserId}"" is not being experimented on feature ""{featureKey - }""."), Times.Never); + $@"The user ""{TestUserId}"" is not being experimented on feature ""{featureKey}""."), Times.Never); LoggerMock.Verify(l => l.Log(LogLevel.INFO, $@"Feature flag ""{featureKey}"" is enabled for user ""{TestUserId}"".")); @@ -3218,8 +3220,7 @@ public void TestIsFeatureEnabledGivenFeatureFlagIsNotEnabledAndUserIsBeingExperi // SendImpressionEvent() gets called. LoggerMock.Verify(l => l.Log(LogLevel.INFO, - $@"The user ""{TestUserId}"" is not being experimented on feature ""{featureKey - }""."), Times.Never); + $@"The user ""{TestUserId}"" is not being experimented on feature ""{featureKey}""."), Times.Never); LoggerMock.Verify(l => l.Log(LogLevel.INFO, $@"Feature flag ""{featureKey}"" is not enabled for user ""{TestUserId}"".")); @@ -3489,7 +3490,7 @@ public void TestTrackListener(UserAttributes userAttributes, EventTags eventTags var variation = Result.NewResult(Config.GetVariationFromKey(experimentKey, variationKey), DecisionReasons); - var logEvent = new LogEvent("https://logx.optimizely.com/v1/events", + var logEvent = new LogEvent(EventFactory.EventEndpoints["US"], OptimizelyHelper.SingleParameter, "POST", new Dictionary()); diff --git a/OptimizelySDK.Tests/OptimizelyUserContextHoldoutTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextHoldoutTest.cs new file mode 100644 index 000000000..978d207aa --- /dev/null +++ b/OptimizelySDK.Tests/OptimizelyUserContextHoldoutTest.cs @@ -0,0 +1,665 @@ +/* + * Copyright 2025, Optimizely + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using Moq; +using Newtonsoft.Json.Linq; +using NUnit.Framework; +using OptimizelySDK.Bucketing; +using OptimizelySDK.Config; +using OptimizelySDK.Entity; +using OptimizelySDK.ErrorHandler; +using OptimizelySDK.Event; +using OptimizelySDK.Event.Dispatcher; +using OptimizelySDK.Logger; +using OptimizelySDK.Notifications; +using OptimizelySDK.OptimizelyDecisions; +using OptimizelySDK.Utils; + +namespace OptimizelySDK.Tests +{ + [TestFixture] + public class OptimizelyUserContextHoldoutTest + { + private Mock LoggerMock; + private Mock EventDispatcherMock; + private DatafileProjectConfig Config; + private JObject TestData; + private Optimizely OptimizelyInstance; + + private const string TestUserId = "testUserId"; + private const string TestBucketingId = "testBucketingId"; + + [SetUp] + public void Initialize() + { + LoggerMock = new Mock(); + EventDispatcherMock = new Mock(); + + // Load test data + var testDataPath = Path.Combine(TestContext.CurrentContext.TestDirectory, + "TestData", "HoldoutTestData.json"); + var jsonContent = File.ReadAllText(testDataPath); + TestData = JObject.Parse(jsonContent); + + // Use datafile with holdouts for proper config setup + var datafileWithHoldouts = TestData["datafileWithHoldouts"].ToString(); + + // Create an Optimizely instance with the test data + OptimizelyInstance = new Optimizely(datafileWithHoldouts, EventDispatcherMock.Object, LoggerMock.Object); + + // Get the config from the Optimizely instance to ensure they're synchronized + Config = OptimizelyInstance.ProjectConfigManager.GetConfig() as DatafileProjectConfig; + + // Verify that the config contains holdouts + Assert.IsNotNull(Config.Holdouts, "Config should have holdouts"); + Assert.IsTrue(Config.Holdouts.Length > 0, "Config should contain holdouts"); + } + + #region Core Holdout Functionality Tests + + [Test] + public void TestDecide_GlobalHoldout() + { + // Test Decide() method with global holdout decision + var featureFlag = Config.FeatureKeyMap["test_flag_1"]; + Assert.IsNotNull(featureFlag, "Feature flag should exist"); + + var userContext = OptimizelyInstance.CreateUserContext(TestUserId, + new UserAttributes { { "country", "us" } }); + + var decision = userContext.Decide("test_flag_1"); + + Assert.IsNotNull(decision, "Decision should not be null"); + Assert.AreEqual("test_flag_1", decision.FlagKey, "Flag key should match"); + + // With real bucketer, we can't guarantee specific variation but can verify structure + // The decision should either be from holdout, experiment, or rollout + Assert.IsTrue(!string.IsNullOrEmpty(decision.VariationKey) || decision.VariationKey == null, + "Variation key should be valid or null"); + } + + [Test] + public void TestDecide_IncludedFlagsHoldout() + { + // Test holdout with includedFlags configuration + var featureFlag = Config.FeatureKeyMap["test_flag_1"]; + Assert.IsNotNull(featureFlag, "Feature flag should exist"); + + // Check if there's a holdout that includes this flag + var includedHoldout = Config.Holdouts.FirstOrDefault(h => + h.IncludedFlags != null && h.IncludedFlags.Contains(featureFlag.Id)); + + if (includedHoldout != null) + { + var userContext = OptimizelyInstance.CreateUserContext(TestUserId, + new UserAttributes { { "country", "us" } }); + + var decision = userContext.Decide("test_flag_1"); + + Assert.IsNotNull(decision, "Decision should not be null"); + Assert.AreEqual("test_flag_1", decision.FlagKey, "Flag key should match"); + + // Verify decision is valid + Assert.IsTrue(decision.VariationKey != null || decision.VariationKey == null, + "Decision should have valid structure"); + } + else + { + Assert.Inconclusive("No included holdout found for test_flag_1"); + } + } + + [Test] + public void TestDecide_ExcludedFlagsHoldout() + { + // Test holdout with excludedFlags configuration + // Based on test data, flag_3 and flag_4 are excluded by holdout_excluded_1 + var userContext = OptimizelyInstance.CreateUserContext(TestUserId, + new UserAttributes { { "country", "us" } }); + + // Test with an excluded flag (test_flag_3 maps to flag_3) + var excludedDecision = userContext.Decide("test_flag_3"); + + Assert.IsNotNull(excludedDecision, "Decision should not be null for excluded flag"); + Assert.AreEqual("test_flag_3", excludedDecision.FlagKey, "Flag key should match"); + + // For excluded flags, the decision should not come from the excluded holdout + // The excluded holdout has key "excluded_holdout" + Assert.AreNotEqual("excluded_holdout", excludedDecision.RuleKey, + "Decision should not come from excluded holdout for flag_3"); + + // Also test with a non-excluded flag (test_flag_1 maps to flag_1) + var nonExcludedDecision = userContext.Decide("test_flag_1"); + + Assert.IsNotNull(nonExcludedDecision, "Decision should not be null for non-excluded flag"); + Assert.AreEqual("test_flag_1", nonExcludedDecision.FlagKey, "Flag key should match"); + + // For non-excluded flags, they can potentially be affected by holdouts + // (depending on other holdout configurations like global or included holdouts) + } + + [Test] + public void TestDecideAll_MultipleHoldouts() + { + // Test DecideAll() with multiple holdouts affecting different flags + var userContext = OptimizelyInstance.CreateUserContext(TestUserId, + new UserAttributes { { "country", "us" } }); + + var decisions = userContext.DecideAll(); + + Assert.IsNotNull(decisions, "Decisions should not be null"); + Assert.IsTrue(decisions.Count > 0, "Should have at least one decision"); + + // Verify each decision has proper structure + foreach (var kvp in decisions) + { + var flagKey = kvp.Key; + var decision = kvp.Value; + + Assert.AreEqual(flagKey, decision.FlagKey, $"Flag key should match for {flagKey}"); + Assert.IsNotNull(decision, $"Decision should not be null for {flagKey}"); + + // Decision should have either a variation or be properly null + Assert.IsTrue(decision.VariationKey != null || decision.VariationKey == null, + $"Decision structure should be valid for {flagKey}"); + } + } + + [Test] + public void TestDecide_HoldoutImpressionEvent() + { + // Test that impression events are sent for holdout decisions + var userContext = OptimizelyInstance.CreateUserContext(TestUserId, + new UserAttributes { { "country", "us" } }); + + var decision = userContext.Decide("test_flag_1"); + + Assert.IsNotNull(decision, "Decision should not be null"); + + // Verify that event dispatcher was called + // Note: With real bucketer, we can't guarantee holdout selection, + // but we can verify event structure + EventDispatcherMock.Verify( + e => e.DispatchEvent(It.IsAny()), + Times.AtLeastOnce, + "Event should be dispatched for decision" + ); + } + + [Test] + public void TestDecide_HoldoutWithDecideOptions() + { + // Test decide options (like ExcludeVariables) with holdout decisions + var userContext = OptimizelyInstance.CreateUserContext(TestUserId, + new UserAttributes { { "country", "us" } }); + + // Test with exclude variables option + var decisionWithVariables = userContext.Decide("test_flag_1"); + var decisionWithoutVariables = userContext.Decide("test_flag_1", + new OptimizelyDecideOption[] { OptimizelyDecideOption.EXCLUDE_VARIABLES }); + + Assert.IsNotNull(decisionWithVariables, "Decision with variables should not be null"); + Assert.IsNotNull(decisionWithoutVariables, "Decision without variables should not be null"); + + // When variables are excluded, the Variables object should be empty + Assert.IsTrue(decisionWithoutVariables.Variables.ToDictionary().Count == 0, + "Variables should be empty when excluded"); + } + + [Test] + public void TestDecide_HoldoutWithAudienceTargeting() + { + // Test holdout decisions with different user attributes for audience targeting + var featureFlag = Config.FeatureKeyMap["test_flag_1"]; + Assert.IsNotNull(featureFlag, "Feature flag should exist"); + + // Test with matching attributes + var userContextMatch = OptimizelyInstance.CreateUserContext(TestUserId, + new UserAttributes { { "country", "us" } }); + var decisionMatch = userContextMatch.Decide("test_flag_1"); + + // Test with non-matching attributes + var userContextNoMatch = OptimizelyInstance.CreateUserContext(TestUserId, + new UserAttributes { { "country", "ca" } }); + var decisionNoMatch = userContextNoMatch.Decide("test_flag_1"); + + Assert.IsNotNull(decisionMatch, "Decision with matching attributes should not be null"); + Assert.IsNotNull(decisionNoMatch, "Decision with non-matching attributes should not be null"); + + // Both decisions should have proper structure regardless of targeting + Assert.AreEqual("test_flag_1", decisionMatch.FlagKey, "Flag key should match"); + Assert.AreEqual("test_flag_1", decisionNoMatch.FlagKey, "Flag key should match"); + } + + [Test] + public void TestDecide_InactiveHoldout() + { + // Test decide when holdout is not running + var featureFlag = Config.FeatureKeyMap["test_flag_1"]; + Assert.IsNotNull(featureFlag, "Feature flag should exist"); + + // Find a holdout and set it to inactive + var holdout = Config.Holdouts.FirstOrDefault(); + if (holdout != null) + { + var originalStatus = holdout.Status; + holdout.Status = "Paused"; // Make holdout inactive + + try + { + var userContext = OptimizelyInstance.CreateUserContext(TestUserId, + new UserAttributes { { "country", "us" } }); + + var decision = userContext.Decide("test_flag_1"); + + Assert.IsNotNull(decision, "Decision should not be null even with inactive holdout"); + Assert.AreEqual("test_flag_1", decision.FlagKey, "Flag key should match"); + + // Should not get decision from the inactive holdout + if (!string.IsNullOrEmpty(decision.RuleKey)) + { + Assert.AreNotEqual(holdout.Key, decision.RuleKey, + "Decision should not come from inactive holdout"); + } + } + finally + { + holdout.Status = originalStatus; // Restore original status + } + } + else + { + Assert.Inconclusive("No holdout found to test inactive scenario"); + } + } + + [Test] + public void TestDecide_EmptyUserId() + { + // Test decide with empty user ID (should still work per Swift SDK behavior) + var userContext = OptimizelyInstance.CreateUserContext("", + new UserAttributes { { "country", "us" } }); + + var decision = userContext.Decide("test_flag_1"); + + Assert.IsNotNull(decision, "Decision should not be null with empty user ID"); + Assert.AreEqual("test_flag_1", decision.FlagKey, "Flag key should match"); + + // Should not log error about invalid user ID since empty string is valid for bucketing + LoggerMock.Verify(l => l.Log(LogLevel.ERROR, + It.Is(s => s.Contains("User ID") && (s.Contains("null") || s.Contains("empty")))), + Times.Never); + } + + [Test] + public void TestDecide_WithDecisionReasons() + { + // Test that decision reasons are properly populated for holdout decisions + var userContext = OptimizelyInstance.CreateUserContext(TestUserId, + new UserAttributes { { "country", "us" } }); + + var decision = userContext.Decide("test_flag_1", + new OptimizelyDecideOption[] { OptimizelyDecideOption.INCLUDE_REASONS }); + + Assert.IsNotNull(decision, "Decision should not be null"); + Assert.AreEqual("test_flag_1", decision.FlagKey, "Flag key should match"); + + // Decision reasons should be populated when requested + Assert.IsNotNull(decision.Reasons, "Decision reasons should not be null"); + // With real bucketer, we expect some decision reasons to be generated + Assert.IsTrue(decision.Reasons.Length >= 0, "Decision reasons should be present"); + } + + [Test] + public void TestDecide_HoldoutPriority() + { + // Test holdout evaluation priority (global vs included vs excluded) + var featureFlag = Config.FeatureKeyMap["test_flag_1"]; + Assert.IsNotNull(featureFlag, "Feature flag should exist"); + + // Check if we have multiple holdouts + var globalHoldouts = Config.Holdouts.Where(h => + h.IncludedFlags == null || h.IncludedFlags.Length == 0).ToList(); + var includedHoldouts = Config.Holdouts.Where(h => + h.IncludedFlags != null && h.IncludedFlags.Contains(featureFlag.Id)).ToList(); + + if (globalHoldouts.Count > 0 || includedHoldouts.Count > 0) + { + var userContext = OptimizelyInstance.CreateUserContext(TestUserId, + new UserAttributes { { "country", "us" } }); + + var decision = userContext.Decide("test_flag_1"); + + Assert.IsNotNull(decision, "Decision should not be null"); + Assert.AreEqual("test_flag_1", decision.FlagKey, "Flag key should match"); + + // Decision should be valid regardless of which holdout is selected + Assert.IsTrue(decision.VariationKey != null || decision.VariationKey == null, + "Decision should have valid structure"); + } + else + { + Assert.Inconclusive("No holdouts found to test priority"); + } + } + + #endregion + + #region Holdout Decision Reasons Tests + + [Test] + public void TestDecideReasons_WithIncludeReasonsOption() + { + var featureKey = "test_flag_1"; + + // Create user context + var userContext = OptimizelyInstance.CreateUserContext(TestUserId); + + // Call decide with reasons option + var decision = userContext.Decide(featureKey, new OptimizelyDecideOption[] { OptimizelyDecideOption.INCLUDE_REASONS }); + + // Assertions + Assert.AreEqual(featureKey, decision.FlagKey, "Expected flagKey to match"); + Assert.IsNotNull(decision.Reasons, "Decision reasons should not be null"); + Assert.IsTrue(decision.Reasons.Length >= 0, "Decision reasons should be present"); + } + + [Test] + public void TestDecideReasons_WithoutIncludeReasonsOption() + { + var featureKey = "test_flag_1"; + + // Create user context + var userContext = OptimizelyInstance.CreateUserContext(TestUserId); + + // Call decide WITHOUT reasons option + var decision = userContext.Decide(featureKey); + + // Assertions + Assert.AreEqual(featureKey, decision.FlagKey, "Expected flagKey to match"); + Assert.IsNotNull(decision.Reasons, "Decision reasons should not be null"); + Assert.AreEqual(0, decision.Reasons.Length, "Should not include reasons when not requested"); + } + + [Test] + public void TestDecideReasons_UserBucketedIntoHoldoutVariation() + { + var featureKey = "test_flag_1"; + + // Create user context that should be bucketed into holdout + var userContext = OptimizelyInstance.CreateUserContext(TestUserId, + new UserAttributes { { "country", "us" } }); + + // Call decide with reasons + var decision = userContext.Decide(featureKey, new OptimizelyDecideOption[] { OptimizelyDecideOption.INCLUDE_REASONS }); + + // Assertions + Assert.AreEqual(featureKey, decision.FlagKey, "Expected flagKey to match"); + Assert.IsNotNull(decision.Reasons, "Decision reasons should not be null"); + Assert.IsTrue(decision.Reasons.Length > 0, "Should have decision reasons"); + + // Check for specific holdout bucketing messages (matching C# DecisionService patterns) + var reasonsText = string.Join(" ", decision.Reasons); + var hasHoldoutBucketingMessage = decision.Reasons.Any(r => + r.Contains("is bucketed into holdout variation") || + r.Contains("is not bucketed into holdout variation")); + + Assert.IsTrue(hasHoldoutBucketingMessage, + "Should contain holdout bucketing decision message"); + } + + [Test] + public void TestDecideReasons_HoldoutNotRunning() + { + // This test would require a holdout with inactive status + // For now, test that the structure is correct and reasons are generated + var featureKey = "test_flag_1"; + + var userContext = OptimizelyInstance.CreateUserContext(TestUserId); + var decision = userContext.Decide(featureKey, new OptimizelyDecideOption[] { OptimizelyDecideOption.INCLUDE_REASONS }); + + // Verify reasons are generated (specific holdout status would depend on test data configuration) + Assert.IsNotNull(decision.Reasons, "Decision reasons should not be null"); + Assert.IsTrue(decision.Reasons.Length > 0, "Should have decision reasons"); + + // Check if any holdout status messages are present + var hasHoldoutStatusMessage = decision.Reasons.Any(r => + r.Contains("is not running") || + r.Contains("is running") || + r.Contains("holdout")); + + // Note: This assertion may pass or fail depending on holdout configuration in test data + // The important thing is that reasons are being generated + } + + [Test] + public void TestDecideReasons_UserMeetsAudienceConditions() + { + var featureKey = "test_flag_1"; + + // Create user context with attributes that should match audience conditions + var userContext = OptimizelyInstance.CreateUserContext(TestUserId, + new UserAttributes { { "country", "us" } }); + + // Call decide with reasons + var decision = userContext.Decide(featureKey, new OptimizelyDecideOption[] { OptimizelyDecideOption.INCLUDE_REASONS }); + + // Assertions + Assert.AreEqual(featureKey, decision.FlagKey, "Expected flagKey to match"); + Assert.IsNotNull(decision.Reasons, "Decision reasons should not be null"); + Assert.IsTrue(decision.Reasons.Length > 0, "Should have decision reasons"); + + // Check for audience evaluation messages (matching C# ExperimentUtils patterns) + var hasAudienceEvaluation = decision.Reasons.Any(r => + r.Contains("Audiences for experiment") && r.Contains("collectively evaluated to")); + + Assert.IsTrue(hasAudienceEvaluation, + "Should contain audience evaluation result message"); + } + + [Test] + public void TestDecideReasons_UserDoesNotMeetHoldoutConditions() + { + var featureKey = "test_flag_1"; + + // Since the test holdouts have empty audience conditions (they match everyone), + // let's test with a holdout that's not running to simulate condition failure + // First, let's verify what's actually happening + var userContext = OptimizelyInstance.CreateUserContext(TestUserId, + new UserAttributes { { "country", "unknown_country" } }); + + // Call decide with reasons + var decision = userContext.Decide(featureKey, new OptimizelyDecideOption[] { OptimizelyDecideOption.INCLUDE_REASONS }); + + // Assertions + Assert.AreEqual(featureKey, decision.FlagKey, "Expected flagKey to match"); + Assert.IsNotNull(decision.Reasons, "Decision reasons should not be null"); + Assert.IsTrue(decision.Reasons.Length > 0, "Should have decision reasons"); + + // Since the current test data holdouts have no audience restrictions, + // they evaluate to TRUE for any user. This is actually correct behavior. + // The test should verify that when audience conditions ARE met, we get appropriate messages. + var hasAudienceEvaluation = decision.Reasons.Any(r => + r.Contains("collectively evaluated to TRUE") || + r.Contains("collectively evaluated to FALSE") || + r.Contains("does not meet conditions")); + + Assert.IsTrue(hasAudienceEvaluation, + "Should contain audience evaluation message (TRUE or FALSE)"); + + // For this specific case with empty audience conditions, expect TRUE evaluation + var hasTrueEvaluation = decision.Reasons.Any(r => + r.Contains("collectively evaluated to TRUE")); + + Assert.IsTrue(hasTrueEvaluation, + "With empty audience conditions, should evaluate to TRUE"); + } + + [Test] + public void TestDecideReasons_HoldoutEvaluationReasoning() + { + var featureKey = "test_flag_1"; + + // Since the current test data doesn't include non-running holdouts, + // this test documents the expected behavior when a holdout is not running + var userContext = OptimizelyInstance.CreateUserContext(TestUserId); + + var decision = userContext.Decide(featureKey, new OptimizelyDecideOption[] { OptimizelyDecideOption.INCLUDE_REASONS }); + + // Assertions + Assert.AreEqual(featureKey, decision.FlagKey, "Expected flagKey to match"); + Assert.IsNotNull(decision.Reasons, "Decision reasons should not be null"); + Assert.IsTrue(decision.Reasons.Length > 0, "Should have decision reasons"); + + // Note: If we had a non-running holdout in the test data, we would expect: + // decision.Reasons.Any(r => r.Contains("is not running")) + + // For now, verify we get some form of holdout evaluation reasoning + var hasHoldoutReasoning = decision.Reasons.Any(r => + r.Contains("holdout") || + r.Contains("bucketed into")); + + Assert.IsTrue(hasHoldoutReasoning, + "Should contain holdout-related reasoning"); + } + + [Test] + public void TestDecideReasons_HoldoutDecisionContainsRelevantReasons() + { + var featureKey = "test_flag_1"; + + // Create user context that might be bucketed into holdout + var userContext = OptimizelyInstance.CreateUserContext(TestUserId, + new UserAttributes { { "country", "us" } }); + + // Call decide with reasons + var decision = userContext.Decide(featureKey, new OptimizelyDecideOption[] { OptimizelyDecideOption.INCLUDE_REASONS }); + + // Assertions + Assert.AreEqual(featureKey, decision.FlagKey, "Expected flagKey to match"); + Assert.IsNotNull(decision.Reasons, "Decision reasons should not be null"); + Assert.IsTrue(decision.Reasons.Length > 0, "Should have decision reasons"); + + // Check if reasons contain holdout-related information + var reasonsText = string.Join(" ", decision.Reasons); + + // Verify that reasons provide information about the decision process + Assert.IsTrue(!string.IsNullOrWhiteSpace(reasonsText), "Reasons should contain meaningful information"); + + // Check for any holdout-related keywords in reasons + var hasHoldoutRelatedReasons = decision.Reasons.Any(r => + r.Contains("holdout") || + r.Contains("bucketed") || + r.Contains("audiences") || + r.Contains("conditions")); + + Assert.IsTrue(hasHoldoutRelatedReasons, + "Should contain holdout-related decision reasoning"); + } + + + #endregion + + #region Notification test + + [Test] + public void TestDecide_HoldoutNotificationContent() + { + var capturedNotifications = new List>(); + + NotificationCenter.DecisionCallback notificationCallback = + (decisionType, userId, userAttributes, decisionInfo) => + { + capturedNotifications.Add(new Dictionary(decisionInfo)); + }; + + OptimizelyInstance.NotificationCenter.AddNotification( + NotificationCenter.NotificationType.Decision, + notificationCallback); + + var userContext = OptimizelyInstance.CreateUserContext(TestUserId, + new UserAttributes { { "country", "us" } }); + var decision = userContext.Decide("test_flag_1"); + + Assert.AreEqual(1, capturedNotifications.Count, + "Should have captured exactly one decision notification"); + + var notification = capturedNotifications.First(); + + Assert.IsTrue(notification.ContainsKey("ruleKey"), + "Notification should contain ruleKey"); + + var ruleKey = notification["ruleKey"]?.ToString(); + + Assert.IsNotNull(ruleKey, "RuleKey should not be null"); + + var holdoutExperiment = Config.Holdouts?.FirstOrDefault(h => h.Key == ruleKey); + + Assert.IsNotNull(holdoutExperiment, + $"RuleKey '{ruleKey}' should correspond to a holdout experiment"); + Assert.IsTrue(notification.ContainsKey("flagKey"), + "Holdout notification should contain flagKey"); + Assert.IsTrue(notification.ContainsKey("enabled"), + "Holdout notification should contain enabled flag"); + Assert.IsTrue(notification.ContainsKey("variationKey"), + "Holdout notification should contain variationKey"); + Assert.IsTrue(notification.ContainsKey("experimentId"), + "Holdout notification should contain experimentId"); + Assert.IsTrue(notification.ContainsKey("variationId"), + "Holdout notification should contain variationId"); + + var flagKey = notification["flagKey"]?.ToString(); + + Assert.AreEqual("test_flag_1", flagKey, "FlagKey should match the requested flag"); + + var experimentId = notification["experimentId"]?.ToString(); + Assert.AreEqual(holdoutExperiment.Id, experimentId, + "ExperimentId in notification should match holdout experiment ID"); + + var variationId = notification["variationId"]?.ToString(); + var holdoutVariation = holdoutExperiment.Variations?.FirstOrDefault(v => v.Id == variationId); + + Assert.IsNotNull(holdoutVariation, + $"VariationId '{variationId}' should correspond to a holdout variation"); + + var variationKey = notification["variationKey"]?.ToString(); + + Assert.AreEqual(holdoutVariation.Key, variationKey, + "VariationKey in notification should match holdout variation key"); + + var enabled = notification["enabled"]; + + Assert.IsNotNull(enabled, "Enabled flag should be present in notification"); + Assert.AreEqual(holdoutVariation.FeatureEnabled, (bool)enabled, + "Enabled flag should match holdout variation's featureEnabled value"); + + Assert.IsTrue(Config.FeatureKeyMap.ContainsKey(flagKey), + $"FlagKey '{flagKey}' should exist in config"); + + Assert.IsTrue(notification.ContainsKey("variables"), + "Notification should contain variables"); + Assert.IsTrue(notification.ContainsKey("reasons"), + "Notification should contain reasons"); + Assert.IsTrue(notification.ContainsKey("decisionEventDispatched"), + "Notification should contain decisionEventDispatched"); + } + #endregion + } +} diff --git a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs index 49fd91a43..49b3a903f 100644 --- a/OptimizelySDK.Tests/OptimizelyUserContextTest.cs +++ b/OptimizelySDK.Tests/OptimizelyUserContextTest.cs @@ -1,5 +1,5 @@ /* - * Copyright 2020-2021, 2022-2023 Optimizely and contributors + * Copyright 2020-2021, 2022-2024 Optimizely and contributors * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,7 +16,7 @@ using System; using System.Collections.Generic; -using System.Threading; +using System.Linq; using Castle.Core.Internal; using Moq; using NUnit.Framework; @@ -62,6 +62,22 @@ public void SetUp() LoggerMock.Object, ErrorHandlerMock.Object); } + private Mock MakeUserProfileServiceMock() + { + var projectConfig = DatafileProjectConfig.Create(TestData.Datafile, LoggerMock.Object, + ErrorHandlerMock.Object); + var experiment = projectConfig.Experiments[8]; + var variation = experiment.Variations[0]; + var decision = new Decision(variation.Id); + var userProfile = new UserProfile(UserID, new Dictionary + { + { experiment.Id, decision }, + }); + var userProfileServiceMock = new Mock(); + userProfileServiceMock.Setup(up => up.Lookup(UserID)).Returns(userProfile.ToMap()); + return userProfileServiceMock; + } + [Test] public void OptimizelyUserContextWithAttributes() { @@ -193,7 +209,7 @@ public void SetAttributeToOverrideAttribute() Assert.AreEqual(user.GetAttributes()["k1"], true); } - #region decide + #region Decide [Test] public void TestDecide() @@ -389,6 +405,23 @@ public void DecideInvalidFlagKey() Assert.IsTrue(TestData.CompareObjects(decision, decisionExpected)); } + [Test] + public void DecideNullFlagKey() + { + var user = Optimizely.CreateUserContext(UserID); + user.SetAttribute("browser_type", "chrome"); + + var decisionExpected = OptimizelyDecision.NewErrorDecision( + null, + user, + DecisionMessage.Reason(DecisionMessage.FLAG_KEY_INVALID, "null"), + ErrorHandlerMock.Object, + LoggerMock.Object); + var decision = user.Decide(null); + + Assert.IsTrue(TestData.CompareObjects(decision, decisionExpected)); + } + [Test] public void DecideWhenConfigIsNull() { @@ -409,9 +442,112 @@ public void DecideWhenConfigIsNull() Assert.IsTrue(TestData.CompareObjects(decision, decisionExpected)); } - #endregion decide + [Test] + public void SeparateDecideShouldHaveSameNumberOfUpsSaveAndLookup() + { + var flag1 = "double_single_variable_feature"; + var flag2 = "integer_single_variable_feature"; + var userProfileServiceMock = MakeUserProfileServiceMock(); + var saveArgsCollector = new List>(); + userProfileServiceMock.Setup(up => up.Save(Capture.In(saveArgsCollector))); + var optimizely = new Optimizely(TestData.Datafile, EventDispatcherMock.Object, + LoggerMock.Object, ErrorHandlerMock.Object, userProfileServiceMock.Object); + var user = optimizely.CreateUserContext(UserID); + var flag1UserProfile = new UserProfile(UserID, new Dictionary + { + { "224", new Decision("280") }, + { "122238", new Decision("122240") }, + }); + var flag2UserProfile = new UserProfile(UserID, new Dictionary + { + { "224", new Decision("280") }, + { "122241", new Decision("122242") }, + }); + + user.Decide(flag1); + user.Decide(flag2); + + LoggerMock.Verify( + l => l.Log(LogLevel.INFO, + "We were unable to get a user profile map from the UserProfileService."), + Times.Never); + LoggerMock.Verify( + l => l.Log(LogLevel.ERROR, "The UserProfileService returned an invalid map."), + Times.Never); + userProfileServiceMock.Verify(l => l.Lookup(UserID), Times.Exactly(2)); + userProfileServiceMock.Verify(l => l.Save(It.IsAny>()), + Times.Exactly(2)); + Assert.AreEqual(saveArgsCollector[0], flag1UserProfile.ToMap()); + Assert.AreEqual(saveArgsCollector[1], flag2UserProfile.ToMap()); + } + + [Test] + public void DecideWithUpsShouldOnlyLookupSaveOnce() + { + var flagKeyFromTestDataJson = "double_single_variable_feature"; + var userProfileServiceMock = MakeUserProfileServiceMock(); + var saveArgsCollector = new List>(); + userProfileServiceMock.Setup(up => up.Save(Capture.In(saveArgsCollector))); + var optimizely = new Optimizely(TestData.Datafile, EventDispatcherMock.Object, + LoggerMock.Object, ErrorHandlerMock.Object, userProfileServiceMock.Object); + var user = optimizely.CreateUserContext(UserID); + var expectedUserProfile = new UserProfile(UserID, new Dictionary + { + { "224", new Decision("280") }, + { "122238", new Decision("122240") }, + }); + + user.Decide(flagKeyFromTestDataJson); + + LoggerMock.Verify( + l => l.Log(LogLevel.INFO, + "We were unable to get a user profile map from the UserProfileService."), + Times.Never); + LoggerMock.Verify( + l => l.Log(LogLevel.ERROR, "The UserProfileService returned an invalid map."), + Times.Never); + userProfileServiceMock.Verify(l => l.Lookup(UserID), Times.Once); + userProfileServiceMock.Verify(l => l.Save(It.IsAny>()), + Times.Once); + Assert.AreEqual(saveArgsCollector.First(), expectedUserProfile.ToMap()); + } + + #endregion Decide - #region decideAll + #region DecideForKeys + + [Test] + public void DecideForKeysWithUpsShouldOnlyLookupSaveOnceWithMultipleFlags() + { + var flagKeys = new[] { "double_single_variable_feature", "boolean_feature" }; + var userProfileServiceMock = MakeUserProfileServiceMock(); + var saveArgsCollector = new List>(); + userProfileServiceMock.Setup(up => up.Save(Capture.In(saveArgsCollector))); + var optimizely = new Optimizely(TestData.Datafile, EventDispatcherMock.Object, + LoggerMock.Object, ErrorHandlerMock.Object, userProfileServiceMock.Object); + var userContext = optimizely.CreateUserContext(UserID); + var expectedUserProfile = new UserProfile(UserID, new Dictionary + { + { "224", new Decision("280") }, + { "122238", new Decision("122240") }, + { "7723330021", new Decision(null) }, + { "7718750065", new Decision(null) }, + }); + + userContext.DecideForKeys(flagKeys); + + LoggerMock.Verify( + l => l.Log(LogLevel.INFO, + "We were unable to get a user profile map from the UserProfileService."), + Times.Never); + LoggerMock.Verify( + l => l.Log(LogLevel.ERROR, "The UserProfileService returned an invalid map."), + Times.Never); + userProfileServiceMock.Verify(l => l.Lookup(UserID), Times.Once); + userProfileServiceMock.Verify(l => l.Save(It.IsAny>()), + Times.Once); + Assert.AreEqual(saveArgsCollector.First(), expectedUserProfile.ToMap()); + } [Test] public void DecideForKeysWithOneFlag() @@ -443,6 +579,44 @@ public void DecideForKeysWithOneFlag() Assert.IsTrue(TestData.CompareObjects(decision, expDecision)); } + #endregion DecideForKeys + + #region DecideAll + + [Test] + public void DecideAllWithUpsShouldOnlyLookupSaveOnce() + { + var userProfileServiceMock = MakeUserProfileServiceMock(); + var saveArgsCollector = new List>(); + userProfileServiceMock.Setup(up => up.Save(Capture.In(saveArgsCollector))); + var optimizely = new Optimizely(TestData.Datafile, EventDispatcherMock.Object, + LoggerMock.Object, ErrorHandlerMock.Object, userProfileServiceMock.Object); + var user = optimizely.CreateUserContext(UserID); + var expectedUserProfile = new UserProfile(UserID, new Dictionary + { + { "224", new Decision("280") }, + { "122238", new Decision("122240") }, + { "122241", new Decision("122242") }, + { "122235", new Decision("122236") }, + { "7723330021", new Decision(null) }, + { "7718750065", new Decision(null) }, + }); + + user.DecideAll(); + + LoggerMock.Verify( + l => l.Log(LogLevel.INFO, + "We were unable to get a user profile map from the UserProfileService."), + Times.Never); + LoggerMock.Verify( + l => l.Log(LogLevel.ERROR, "The UserProfileService returned an invalid map."), + Times.Never); + userProfileServiceMock.Verify(l => l.Lookup(UserID), Times.Once); + userProfileServiceMock.Verify(l => l.Save(It.IsAny>()), + Times.Once); + Assert.AreEqual(saveArgsCollector.First(), expectedUserProfile.ToMap()); + } + [Test] public void DecideAllTwoFlag() { @@ -650,7 +824,7 @@ public void DecideAllAllFlags() null, flagKey10, user, - new string[0]); + new[] { "Variable value for key \"any_key\" is invalid or wrong type." }); Assert.IsTrue(TestData.CompareObjects(decisions[flagKey10], expDecision10)); } @@ -924,6 +1098,12 @@ public void TestDecisionNotification() { "decisionEventDispatched", true }, + { + "experimentId", "122235" + }, + { + "variationId", "122236" + }, }; var userAttributes = new UserAttributes diff --git a/OptimizelySDK.Tests/ProjectConfigTest.cs b/OptimizelySDK.Tests/ProjectConfigTest.cs index 55d6e63be..52373b2d5 100644 --- a/OptimizelySDK.Tests/ProjectConfigTest.cs +++ b/OptimizelySDK.Tests/ProjectConfigTest.cs @@ -16,6 +16,7 @@ using System; using System.Collections.Generic; +using System.IO; using System.Linq; using Moq; using Newtonsoft.Json; @@ -1175,9 +1176,7 @@ public void TestGetAttributeIdWithReservedPrefix() Assert.AreEqual(reservedAttrConfig.GetAttributeId(reservedPrefixAttrKey), reservedAttrConfig.GetAttribute(reservedPrefixAttrKey).Id); LoggerMock.Verify(l => l.Log(LogLevel.WARN, - $@"Attribute {reservedPrefixAttrKey} unexpectedly has reserved prefix { - DatafileProjectConfig.RESERVED_ATTRIBUTE_PREFIX - }; using attribute ID instead of reserved attribute name.")); + $@"Attribute {reservedPrefixAttrKey} unexpectedly has reserved prefix {DatafileProjectConfig.RESERVED_ATTRIBUTE_PREFIX}; using attribute ID instead of reserved attribute name.")); } [Test] @@ -1351,5 +1350,145 @@ public void TestProjectConfigWithOtherIntegrationsInCollection() Assert.IsNull(datafileProjectConfig.HostForOdp); Assert.IsNull(datafileProjectConfig.PublicKeyForOdp); } + + #region Holdout Integration Tests + + [Test] + public void TestHoldoutDeserialization_FromDatafile() + { + // Test that holdouts can be deserialized from a datafile with holdouts + var testDataPath = Path.Combine(TestContext.CurrentContext.TestDirectory, + "TestData", "HoldoutTestData.json"); + var jsonContent = File.ReadAllText(testDataPath); + var testData = JObject.Parse(jsonContent); + + var datafileJson = testData["datafileWithHoldouts"].ToString(); + + var datafileProjectConfig = DatafileProjectConfig.Create(datafileJson, + new NoOpLogger(), new NoOpErrorHandler()) as DatafileProjectConfig; + + Assert.IsNotNull(datafileProjectConfig.Holdouts); + Assert.AreEqual(4, datafileProjectConfig.Holdouts.Length); + } + + [Test] + public void TestGetHoldoutsForFlag_Integration() + { + var testDataPath = Path.Combine(TestContext.CurrentContext.TestDirectory, + "TestData", "HoldoutTestData.json"); + var jsonContent = File.ReadAllText(testDataPath); + var testData = JObject.Parse(jsonContent); + + var datafileJson = testData["datafileWithHoldouts"].ToString(); + + var datafileProjectConfig = DatafileProjectConfig.Create(datafileJson, + new NoOpLogger(), new NoOpErrorHandler()) as DatafileProjectConfig; + + // Test GetHoldoutsForFlag method + var holdoutsForFlag1 = datafileProjectConfig.GetHoldoutsForFlag("flag_1"); + Assert.IsNotNull(holdoutsForFlag1); + Assert.AreEqual(4, holdoutsForFlag1.Length); // Global + excluded holdout (applies to all except flag_3/flag_4) + included holdout + empty holdout + + var holdoutsForFlag3 = datafileProjectConfig.GetHoldoutsForFlag("flag_3"); + Assert.IsNotNull(holdoutsForFlag3); + Assert.AreEqual(2, holdoutsForFlag3.Length); // Global + empty holdout (excluded holdout excludes flag_3, included holdout doesn't include flag_3) + + var holdoutsForUnknownFlag = datafileProjectConfig.GetHoldoutsForFlag("unknown_flag"); + Assert.IsNotNull(holdoutsForUnknownFlag); + Assert.AreEqual(3, holdoutsForUnknownFlag.Length); // Global + excluded holdout (unknown_flag not in excluded list) + empty holdout + } + + [Test] + public void TestGetHoldout_Integration() + { + var testDataPath = Path.Combine(TestContext.CurrentContext.TestDirectory, + "TestData", "HoldoutTestData.json"); + var jsonContent = File.ReadAllText(testDataPath); + var testData = JObject.Parse(jsonContent); + + var datafileJson = testData["datafileWithHoldouts"].ToString(); + + var datafileProjectConfig = DatafileProjectConfig.Create(datafileJson, + new NoOpLogger(), new NoOpErrorHandler()) as DatafileProjectConfig; + + // Test GetHoldout method + var globalHoldout = datafileProjectConfig.GetHoldout("holdout_global_1"); + Assert.IsNotNull(globalHoldout); + Assert.AreEqual("holdout_global_1", globalHoldout.Id); + Assert.AreEqual("global_holdout", globalHoldout.Key); + + var invalidHoldout = datafileProjectConfig.GetHoldout("invalid_id"); + Assert.IsNull(invalidHoldout); + } + + [Test] + public void TestMissingHoldoutsField_BackwardCompatibility() + { + // Test that a datafile without holdouts field still works + var datafileWithoutHoldouts = @"{ + ""version"": ""4"", + ""rollouts"": [], + ""projectId"": ""test_project"", + ""experiments"": [], + ""groups"": [], + ""attributes"": [], + ""audiences"": [], + ""layers"": [], + ""events"": [], + ""revision"": ""1"", + ""featureFlags"": [] + }"; + + var datafileProjectConfig = DatafileProjectConfig.Create(datafileWithoutHoldouts, + new NoOpLogger(), new NoOpErrorHandler()) as DatafileProjectConfig; + + Assert.IsNotNull(datafileProjectConfig.Holdouts); + Assert.AreEqual(0, datafileProjectConfig.Holdouts.Length); + + // Methods should still work with empty holdouts + var holdouts = datafileProjectConfig.GetHoldoutsForFlag("any_flag"); + Assert.IsNotNull(holdouts); + Assert.AreEqual(0, holdouts.Length); + + var holdout = datafileProjectConfig.GetHoldout("any_id"); + Assert.IsNull(holdout); + } + + #endregion + + [Test] + public void TestCmabFieldPopulation() + { + + var datafileJson = JObject.Parse(TestData.Datafile); + var experiments = (JArray)datafileJson["experiments"]; + + if (experiments.Count > 0) + { + var firstExperiment = (JObject)experiments[0]; + + firstExperiment["cmab"] = new JObject + { + ["attributeIds"] = new JArray { "7723280020", "7723348204" }, + ["trafficAllocation"] = 4000 + }; + + firstExperiment["trafficAllocation"] = new JArray(); + } + + var modifiedDatafile = datafileJson.ToString(); + var projectConfig = DatafileProjectConfig.Create(modifiedDatafile, LoggerMock.Object, ErrorHandlerMock.Object); + var experimentWithCmab = projectConfig.GetExperimentFromKey("test_experiment"); + + Assert.IsNotNull(experimentWithCmab.Cmab); + Assert.AreEqual(2, experimentWithCmab.Cmab.AttributeIds.Count); + Assert.Contains("7723280020", experimentWithCmab.Cmab.AttributeIds); + Assert.Contains("7723348204", experimentWithCmab.Cmab.AttributeIds); + Assert.AreEqual(4000, experimentWithCmab.Cmab.TrafficAllocation); + + var experimentWithoutCmab = projectConfig.GetExperimentFromKey("paused_experiment"); + + Assert.IsNull(experimentWithoutCmab.Cmab); + } } } diff --git a/OptimizelySDK.Tests/Properties/AssemblyInfo.cs b/OptimizelySDK.Tests/Properties/AssemblyInfo.cs index 8ceae6071..f122893fe 100644 --- a/OptimizelySDK.Tests/Properties/AssemblyInfo.cs +++ b/OptimizelySDK.Tests/Properties/AssemblyInfo.cs @@ -30,6 +30,6 @@ // // You can specify all the values or you can default the Revision and Build Numbers // by using the '*' as shown below: -[assembly: AssemblyVersion("4.0.0.0")] -[assembly: AssemblyFileVersion("4.0.0.0")] -[assembly: AssemblyInformationalVersion("4.0.0-beta")] // Used by Nuget. +[assembly: AssemblyVersion("4.1.0.0")] +[assembly: AssemblyFileVersion("4.1.0.0")] +[assembly: AssemblyInformationalVersion("4.1.0")] // Used by NuGet. diff --git a/OptimizelySDK.Tests/TestData/HoldoutTestData.json b/OptimizelySDK.Tests/TestData/HoldoutTestData.json new file mode 100644 index 000000000..777c0a3ab --- /dev/null +++ b/OptimizelySDK.Tests/TestData/HoldoutTestData.json @@ -0,0 +1,214 @@ +{ + "globalHoldout": { + "id": "holdout_global_1", + "key": "global_holdout", + "status": "Running", + "layerId": "layer_1", + "variations": [ + { + "id": "var_1", + "key": "control", + "featureEnabled": false, + "variables": [] + } + ], + "trafficAllocation": [ + { + "entityId": "var_1", + "endOfRange": 10000 + } + ], + "audienceIds": [], + "audienceConditions": [], + "includedFlags": [], + "excludedFlags": [] + }, + "includedFlagsHoldout": { + "id": "holdout_included_1", + "key": "included_holdout", + "status": "Running", + "layerId": "layer_2", + "variations": [ + { + "id": "var_2", + "key": "treatment", + "featureEnabled": true, + "variables": [] + } + ], + "trafficAllocation": [ + { + "entityId": "var_2", + "endOfRange": 10000 + } + ], + "audienceIds": [], + "audienceConditions": [], + "includedFlags": ["flag_1", "flag_2"], + "excludedFlags": [] + }, + "excludedFlagsHoldout": { + "id": "holdout_excluded_1", + "key": "excluded_holdout", + "status": "Running", + "layerId": "layer_3", + "variations": [ + { + "id": "var_3", + "key": "excluded_var", + "featureEnabled": false, + "variables": [] + } + ], + "trafficAllocation": [ + { + "entityId": "var_3", + "endOfRange": 10000 + } + ], + "audienceIds": [], + "audienceConditions": [], + "includedFlags": [], + "excludedFlags": ["flag_3", "flag_4"] + }, + "datafileWithHoldouts": { + "version": "4", + "rollouts": [], + "projectId": "test_project", + "experiments": [], + "groups": [], + "attributes": [], + "audiences": [], + "layers": [], + "events": [], + "revision": "1", + "accountId": "12345", + "anonymizeIP": false, + "featureFlags": [ + { + "id": "flag_1", + "key": "test_flag_1", + "experimentIds": [], + "rolloutId": "", + "variables": [] + }, + { + "id": "flag_2", + "key": "test_flag_2", + "experimentIds": [], + "rolloutId": "", + "variables": [] + }, + { + "id": "flag_3", + "key": "test_flag_3", + "experimentIds": [], + "rolloutId": "", + "variables": [] + }, + { + "id": "flag_4", + "key": "test_flag_4", + "experimentIds": [], + "rolloutId": "", + "variables": [] + } + ], + "holdouts": [ + { + "id": "holdout_global_1", + "key": "global_holdout", + "status": "Running", + "layerId": "layer_1", + "variations": [ + { + "id": "var_1", + "key": "control", + "featureEnabled": false, + "variables": [] + }, + { + "id": "var_2", + "key": "treatment", + "featureEnabled": true, + "variables": [] + } + ], + "trafficAllocation": [ + { + "entityId": "var_1", + "endOfRange": 5000 + }, + { + "entityId": "var_2", + "endOfRange": 10000 + } + ], + "audienceIds": [], + "audienceConditions": [], + "includedFlags": [], + "excludedFlags": [] + }, + { + "id": "holdout_included_1", + "key": "included_holdout", + "status": "Running", + "layerId": "layer_2", + "variations": [ + { + "id": "var_2", + "key": "treatment", + "featureEnabled": true, + "variables": [] + } + ], + "trafficAllocation": [ + { + "entityId": "var_2", + "endOfRange": 10000 + } + ], + "audienceIds": [], + "audienceConditions": [], + "includedFlags": ["flag_1", "flag_2"], + "excludedFlags": [] + }, + { + "id": "holdout_excluded_1", + "key": "excluded_holdout", + "status": "Running", + "layerId": "layer_3", + "variations": [ + { + "id": "var_3", + "key": "excluded_var", + "featureEnabled": false, + "variables": [] + } + ], + "trafficAllocation": [ + { + "entityId": "var_3", + "endOfRange": 10000 + } + ], + "audienceIds": [], + "audienceConditions": [], + "includedFlags": [], + "excludedFlags": ["flag_3", "flag_4"] + }, + { + "id": "holdout_empty_1", + "key": "empty_holdout", + "status": "Running", + "layerId": "layer_4", + "variations": [], + "trafficAllocation": [], + "audienceIds": [], + "audienceConditions": [], + "includedFlags": [], + "excludedFlags": [] + } + ] + } +} diff --git a/OptimizelySDK.Tests/UtilsTests/HoldoutConfigTests.cs b/OptimizelySDK.Tests/UtilsTests/HoldoutConfigTests.cs new file mode 100644 index 000000000..57593a55e --- /dev/null +++ b/OptimizelySDK.Tests/UtilsTests/HoldoutConfigTests.cs @@ -0,0 +1,344 @@ +/* + * Copyright 2025, Optimizely + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using Newtonsoft.Json; +using Newtonsoft.Json.Linq; +using NUnit.Framework; +using OptimizelySDK.Entity; +using OptimizelySDK.Utils; + +namespace OptimizelySDK.Tests +{ + [TestFixture] + public class HoldoutConfigTests + { + private JObject testData; + private Holdout globalHoldout; + private Holdout includedHoldout; + private Holdout excludedHoldout; + + [SetUp] + public void Setup() + { + // Load test data + var testDataPath = Path.Combine(TestContext.CurrentContext.TestDirectory, + "TestData", "HoldoutTestData.json"); + var jsonContent = File.ReadAllText(testDataPath); + testData = JObject.Parse(jsonContent); + + // Deserialize test holdouts + globalHoldout = JsonConvert.DeserializeObject(testData["globalHoldout"].ToString()); + includedHoldout = JsonConvert.DeserializeObject(testData["includedFlagsHoldout"].ToString()); + excludedHoldout = JsonConvert.DeserializeObject(testData["excludedFlagsHoldout"].ToString()); + } + + [Test] + public void TestEmptyHoldouts_ShouldHaveEmptyMaps() + { + var config = new HoldoutConfig(new Holdout[0]); + + Assert.IsNotNull(config.HoldoutIdMap); + Assert.AreEqual(0, config.HoldoutIdMap.Count); + Assert.IsNotNull(config.GetHoldoutsForFlag("any_flag")); + Assert.AreEqual(0, config.GetHoldoutsForFlag("any_flag").Count); + } + + [Test] + public void TestHoldoutIdMapping() + { + var allHoldouts = new[] { globalHoldout, includedHoldout, excludedHoldout }; + var config = new HoldoutConfig(allHoldouts); + + Assert.IsNotNull(config.HoldoutIdMap); + Assert.AreEqual(3, config.HoldoutIdMap.Count); + + Assert.IsTrue(config.HoldoutIdMap.ContainsKey("holdout_global_1")); + Assert.IsTrue(config.HoldoutIdMap.ContainsKey("holdout_included_1")); + Assert.IsTrue(config.HoldoutIdMap.ContainsKey("holdout_excluded_1")); + + Assert.AreEqual(globalHoldout.Id, config.HoldoutIdMap["holdout_global_1"].Id); + Assert.AreEqual(includedHoldout.Id, config.HoldoutIdMap["holdout_included_1"].Id); + Assert.AreEqual(excludedHoldout.Id, config.HoldoutIdMap["holdout_excluded_1"].Id); + } + + [Test] + public void TestGetHoldoutById() + { + var allHoldouts = new[] { globalHoldout, includedHoldout, excludedHoldout }; + var config = new HoldoutConfig(allHoldouts); + + var retrievedGlobal = config.GetHoldout("holdout_global_1"); + var retrievedIncluded = config.GetHoldout("holdout_included_1"); + var retrievedExcluded = config.GetHoldout("holdout_excluded_1"); + + Assert.IsNotNull(retrievedGlobal); + Assert.AreEqual("holdout_global_1", retrievedGlobal.Id); + Assert.AreEqual("global_holdout", retrievedGlobal.Key); + + Assert.IsNotNull(retrievedIncluded); + Assert.AreEqual("holdout_included_1", retrievedIncluded.Id); + Assert.AreEqual("included_holdout", retrievedIncluded.Key); + + Assert.IsNotNull(retrievedExcluded); + Assert.AreEqual("holdout_excluded_1", retrievedExcluded.Id); + Assert.AreEqual("excluded_holdout", retrievedExcluded.Key); + } + + [Test] + public void TestGetHoldoutById_InvalidId() + { + var allHoldouts = new[] { globalHoldout }; + var config = new HoldoutConfig(allHoldouts); + + var result = config.GetHoldout("invalid_id"); + Assert.IsNull(result); + } + + [Test] + public void TestGlobalHoldoutsForFlag() + { + var allHoldouts = new[] { globalHoldout }; + var config = new HoldoutConfig(allHoldouts); + + var holdoutsForFlag = config.GetHoldoutsForFlag("any_flag_id"); + + Assert.IsNotNull(holdoutsForFlag); + Assert.AreEqual(1, holdoutsForFlag.Count); + Assert.AreEqual("holdout_global_1", holdoutsForFlag[0].Id); + } + + [Test] + public void TestIncludedHoldoutsForFlag() + { + var allHoldouts = new[] { includedHoldout }; + var config = new HoldoutConfig(allHoldouts); + + // Test for included flags + var holdoutsForFlag1 = config.GetHoldoutsForFlag("flag_1"); + var holdoutsForFlag2 = config.GetHoldoutsForFlag("flag_2"); + var holdoutsForOtherFlag = config.GetHoldoutsForFlag("other_flag"); + + Assert.IsNotNull(holdoutsForFlag1); + Assert.AreEqual(1, holdoutsForFlag1.Count); + Assert.AreEqual("holdout_included_1", holdoutsForFlag1[0].Id); + + Assert.IsNotNull(holdoutsForFlag2); + Assert.AreEqual(1, holdoutsForFlag2.Count); + Assert.AreEqual("holdout_included_1", holdoutsForFlag2[0].Id); + + Assert.IsNotNull(holdoutsForOtherFlag); + Assert.AreEqual(0, holdoutsForOtherFlag.Count); + } + + [Test] + public void TestExcludedHoldoutsForFlag() + { + var allHoldouts = new[] { excludedHoldout }; + var config = new HoldoutConfig(allHoldouts); + + // Test for excluded flags - should NOT appear + var holdoutsForFlag3 = config.GetHoldoutsForFlag("flag_3"); + var holdoutsForFlag4 = config.GetHoldoutsForFlag("flag_4"); + var holdoutsForOtherFlag = config.GetHoldoutsForFlag("other_flag"); + + // Excluded flags should not get this holdout + Assert.IsNotNull(holdoutsForFlag3); + Assert.AreEqual(0, holdoutsForFlag3.Count); + + Assert.IsNotNull(holdoutsForFlag4); + Assert.AreEqual(0, holdoutsForFlag4.Count); + + // Other flags should get this global holdout (with exclusions) + Assert.IsNotNull(holdoutsForOtherFlag); + Assert.AreEqual(1, holdoutsForOtherFlag.Count); + Assert.AreEqual("holdout_excluded_1", holdoutsForOtherFlag[0].Id); + } + + [Test] + public void TestHoldoutOrdering_GlobalThenIncluded() + { + // Create additional test holdouts with specific IDs for ordering test + var global1 = CreateTestHoldout("global_1", "g1", new string[0], new string[0]); + var global2 = CreateTestHoldout("global_2", "g2", new string[0], new string[0]); + var included = CreateTestHoldout("included_1", "i1", new[] { "test_flag" }, new string[0]); + + var allHoldouts = new[] { included, global1, global2 }; + var config = new HoldoutConfig(allHoldouts); + + var holdoutsForFlag = config.GetHoldoutsForFlag("test_flag"); + + Assert.IsNotNull(holdoutsForFlag); + Assert.AreEqual(3, holdoutsForFlag.Count); + + // Should be: global1, global2, included (global first, then included) + var ids = holdoutsForFlag.Select(h => h.Id).ToArray(); + Assert.Contains("global_1", ids); + Assert.Contains("global_2", ids); + Assert.Contains("included_1", ids); + + // Included should be last (after globals) + Assert.AreEqual("included_1", holdoutsForFlag.Last().Id); + } + + [Test] + public void TestComplexFlagScenarios_MultipleRules() + { + var global1 = CreateTestHoldout("global_1", "g1", new string[0], new string[0]); + var global2 = CreateTestHoldout("global_2", "g2", new string[0], new string[0]); + var included = CreateTestHoldout("included_1", "i1", new[] { "flag_1" }, new string[0]); + var excluded = CreateTestHoldout("excluded_1", "e1", new string[0], new[] { "flag_2" }); + + var allHoldouts = new[] { included, excluded, global1, global2 }; + var config = new HoldoutConfig(allHoldouts); + + // Test flag_1: should get globals + excluded global + included + var holdoutsForFlag1 = config.GetHoldoutsForFlag("flag_1"); + Assert.AreEqual(4, holdoutsForFlag1.Count); + var flag1Ids = holdoutsForFlag1.Select(h => h.Id).ToArray(); + Assert.Contains("global_1", flag1Ids); + Assert.Contains("global_2", flag1Ids); + Assert.Contains("excluded_1", flag1Ids); // excluded global should appear for other flags + Assert.Contains("included_1", flag1Ids); + + // Test flag_2: should get only regular globals (excluded global should NOT appear) + var holdoutsForFlag2 = config.GetHoldoutsForFlag("flag_2"); + Assert.AreEqual(2, holdoutsForFlag2.Count); + var flag2Ids = holdoutsForFlag2.Select(h => h.Id).ToArray(); + Assert.Contains("global_1", flag2Ids); + Assert.Contains("global_2", flag2Ids); + Assert.IsFalse(flag2Ids.Contains("excluded_1")); // Should be excluded + Assert.IsFalse(flag2Ids.Contains("included_1")); // Not included for this flag + + // Test flag_3: should get globals + excluded global + var holdoutsForFlag3 = config.GetHoldoutsForFlag("flag_3"); + Assert.AreEqual(3, holdoutsForFlag3.Count); + var flag3Ids = holdoutsForFlag3.Select(h => h.Id).ToArray(); + Assert.Contains("global_1", flag3Ids); + Assert.Contains("global_2", flag3Ids); + Assert.Contains("excluded_1", flag3Ids); + } + + [Test] + public void TestExcludedHoldout_ShouldNotAppearInGlobal() + { + var global = CreateTestHoldout("global_1", "global", new string[0], new string[0]); + var excluded = CreateTestHoldout("excluded_1", "excluded", new string[0], new[] { "target_flag" }); + + var allHoldouts = new[] { global, excluded }; + var config = new HoldoutConfig(allHoldouts); + + var holdoutsForTargetFlag = config.GetHoldoutsForFlag("target_flag"); + + Assert.IsNotNull(holdoutsForTargetFlag); + Assert.AreEqual(1, holdoutsForTargetFlag.Count); + Assert.AreEqual("global_1", holdoutsForTargetFlag[0].Id); + // excluded should NOT appear for target_flag + } + + [Test] + public void TestCaching_SecondCallUsesCachedResult() + { + var allHoldouts = new[] { globalHoldout, includedHoldout }; + var config = new HoldoutConfig(allHoldouts); + + // First call + var firstResult = config.GetHoldoutsForFlag("flag_1"); + + // Second call - should use cache + var secondResult = config.GetHoldoutsForFlag("flag_1"); + + Assert.IsNotNull(firstResult); + Assert.IsNotNull(secondResult); + Assert.AreEqual(firstResult.Count, secondResult.Count); + + // Results should be the same (caching working) + for (int i = 0; i < firstResult.Count; i++) + { + Assert.AreEqual(firstResult[i].Id, secondResult[i].Id); + } + } + + [Test] + public void TestNullFlagId_ReturnsEmptyList() + { + var config = new HoldoutConfig(new[] { globalHoldout }); + + var result = config.GetHoldoutsForFlag(null); + + Assert.IsNotNull(result); + Assert.AreEqual(0, result.Count); + } + + [Test] + public void TestEmptyFlagId_ReturnsEmptyList() + { + var config = new HoldoutConfig(new[] { globalHoldout }); + + var result = config.GetHoldoutsForFlag(""); + + Assert.IsNotNull(result); + Assert.AreEqual(0, result.Count); + } + + [Test] + public void TestGetHoldoutsForFlag_WithNullHoldouts() + { + var config = new HoldoutConfig(null); + + var result = config.GetHoldoutsForFlag("any_flag"); + + Assert.IsNotNull(result); + Assert.AreEqual(0, result.Count); + } + + [Test] + public void TestUpdateHoldoutMapping() + { + var config = new HoldoutConfig(new[] { globalHoldout }); + + // Initial state + Assert.AreEqual(1, config.HoldoutIdMap.Count); + + // Update with new holdouts + config.UpdateHoldoutMapping(new[] { globalHoldout, includedHoldout }); + + Assert.AreEqual(2, config.HoldoutIdMap.Count); + Assert.IsTrue(config.HoldoutIdMap.ContainsKey("holdout_global_1")); + Assert.IsTrue(config.HoldoutIdMap.ContainsKey("holdout_included_1")); + } + + // Helper method to create test holdouts + private Holdout CreateTestHoldout(string id, string key, string[] includedFlags, string[] excludedFlags) + { + return new Holdout + { + Id = id, + Key = key, + Status = "Running", + Variations = new Variation[0], + TrafficAllocation = new TrafficAllocation[0], + AudienceIds = new string[0], + AudienceConditions = null, + IncludedFlags = includedFlags, + ExcludedFlags = excludedFlags + }; + } + } +} diff --git a/OptimizelySDK.sln.DotSettings b/OptimizelySDK.sln.DotSettings index 3ccf7ffc1..8ee6e5a47 100644 --- a/OptimizelySDK.sln.DotSettings +++ b/OptimizelySDK.sln.DotSettings @@ -43,10 +43,15 @@ <Policy Inspect="True" Prefix="I" Suffix="" Style="AaBb" /> <Policy Inspect="True" Prefix="" Suffix="" Style="AA_BB" /> <Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /> + <Policy><Descriptor Staticness="Static" AccessRightKinds="Private" Description="Static readonly fields (private)"><ElementKinds><Kind Name="READONLY_FIELD" /></ElementKinds></Descriptor><Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /></Policy> + <Policy><Descriptor Staticness="Any" AccessRightKinds="Any" Description="Enum members"><ElementKinds><Kind Name="ENUM_MEMBER" /></ElementKinds></Descriptor><Policy Inspect="True" Prefix="" Suffix="" Style="AaBb"><ExtraRule Prefix="" Suffix="" Style="AaBb" /></Policy></Policy> + <Policy><Descriptor Staticness="Any" AccessRightKinds="Any" Description="Local constants"><ElementKinds><Kind Name="LOCAL_CONSTANT" /></ElementKinds></Descriptor><Policy Inspect="True" Prefix="" Suffix="" Style="AA_BB" /></Policy> + <Policy><Descriptor Staticness="Any" AccessRightKinds="Any" Description="Interfaces"><ElementKinds><Kind Name="INTERFACE" /></ElementKinds></Descriptor><Policy Inspect="True" Prefix="I" Suffix="" Style="AaBb" /></Policy> True True True True + True True True True diff --git a/OptimizelySDK/Bucketing/Bucketer.cs b/OptimizelySDK/Bucketing/Bucketer.cs index 33df35a30..f891fc76c 100644 --- a/OptimizelySDK/Bucketing/Bucketer.cs +++ b/OptimizelySDK/Bucketing/Bucketer.cs @@ -112,7 +112,7 @@ IEnumerable trafficAllocations /// A customer-assigned value used to create the key for the murmur hash. /// User identifier /// Variation which will be shown to the user - public virtual Result Bucket(ProjectConfig config, Experiment experiment, + public virtual Result Bucket(ProjectConfig config, ExperimentCore experiment, string bucketingId, string userId ) { @@ -127,9 +127,9 @@ public virtual Result Bucket(ProjectConfig config, Experiment experim } // Determine if experiment is in a mutually exclusive group. - if (experiment.IsInMutexGroup) + if (experiment is Experiment exp && exp.IsInMutexGroup) { - var group = config.GetGroup(experiment.GroupId); + var group = config.GetGroup(exp.GroupId); if (string.IsNullOrEmpty(group.Id)) { return Result.NewResult(new Variation(), reasons); @@ -147,13 +147,13 @@ public virtual Result Bucket(ProjectConfig config, Experiment experim if (userExperimentId != experiment.Id) { message = - $"User [{userId}] is not in experiment [{experiment.Key}] of group [{experiment.GroupId}]."; + $"User [{userId}] is not in experiment [{exp.Key}] of group [{exp.GroupId}]."; Logger.Log(LogLevel.INFO, reasons.AddInfo(message)); return Result.NewResult(new Variation(), reasons); } message = - $"User [{userId}] is in experiment [{experiment.Key}] of group [{experiment.GroupId}]."; + $"User [{userId}] is in experiment [{exp.Key}] of group [{exp.GroupId}]."; Logger.Log(LogLevel.INFO, reasons.AddInfo(message)); } diff --git a/OptimizelySDK/Bucketing/DecisionService.cs b/OptimizelySDK/Bucketing/DecisionService.cs index e6088d7e0..7bc8054b8 100644 --- a/OptimizelySDK/Bucketing/DecisionService.cs +++ b/OptimizelySDK/Bucketing/DecisionService.cs @@ -1,5 +1,5 @@ /* -* Copyright 2017-2022, Optimizely +* Copyright 2017-2022, 2024 Optimizely * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,11 +16,13 @@ using System; using System.Collections.Generic; +using System.Linq; using OptimizelySDK.Entity; using OptimizelySDK.ErrorHandler; using OptimizelySDK.Logger; using OptimizelySDK.OptimizelyDecisions; using OptimizelySDK.Utils; +using static OptimizelySDK.Entity.Holdout; namespace OptimizelySDK.Bucketing { @@ -84,9 +86,9 @@ public DecisionService(Bucketer bucketer, IErrorHandler errorHandler, ///

/// Get a Variation of an Experiment for a user to be allocated into. /// - /// The Experiment the user will be bucketed into. - /// Optimizely user context. - /// Project config. + /// The Experiment the user will be bucketed into. + /// Optimizely user context. + /// Project config. /// The Variation the user is allocated into. public virtual Result GetVariation(Experiment experiment, OptimizelyUserContext user, @@ -99,11 +101,11 @@ ProjectConfig config /// /// Get a Variation of an Experiment for a user to be allocated into. /// - /// The Experiment the user will be bucketed into. - /// optimizely user context. - /// Project Config. - /// An array of decision options. - /// The Variation the user is allocated into. + /// The Experiment the user will be bucketed into. + /// Optimizely user context. + /// Project Config. + /// An array of decision options. + /// public virtual Result GetVariation(Experiment experiment, OptimizelyUserContext user, ProjectConfig config, @@ -111,97 +113,107 @@ OptimizelyDecideOption[] options ) { var reasons = new DecisionReasons(); - var userId = user.GetUserId(); + + var ignoreUps = options.Contains(OptimizelyDecideOption.IGNORE_USER_PROFILE_SERVICE); + UserProfileTracker userProfileTracker = null; + + if (UserProfileService != null && !ignoreUps) + { + userProfileTracker = new UserProfileTracker(UserProfileService, user.GetUserId(), + Logger, ErrorHandler); + userProfileTracker.LoadUserProfile(reasons); + } + + var response = GetVariation(experiment, user, config, options, userProfileTracker, + reasons); + + if (UserProfileService != null && !ignoreUps && + userProfileTracker?.ProfileUpdated == true) + { + userProfileTracker.SaveUserProfile(); + } + + return response; + } + + /// + /// Get a Variation of an Experiment for a user to be allocated into. + /// + /// The Experiment the user will be bucketed into. + /// Optimizely user context. + /// Project Config. + /// An array of decision options. + /// A UserProfileTracker object. + /// Set of reasons for the decision. + /// The Variation the user is allocated into. + public virtual Result GetVariation(Experiment experiment, + OptimizelyUserContext user, + ProjectConfig config, + OptimizelyDecideOption[] options, + UserProfileTracker userProfileTracker, + DecisionReasons reasons = null + ) + { + if (reasons == null) + { + reasons = new DecisionReasons(); + } + if (!ExperimentUtils.IsExperimentActive(experiment, Logger)) { + var message = reasons.AddInfo($"Experiment {experiment.Key} is not running."); + Logger.Log(LogLevel.INFO, message); return Result.NullResult(reasons); } - // check if a forced variation is set - var decisionVariationResult = GetForcedVariation(experiment.Key, userId, config); - reasons += decisionVariationResult.DecisionReasons; - var variation = decisionVariationResult.ResultObject; + var userId = user.GetUserId(); + + var decisionVariation = GetForcedVariation(experiment.Key, userId, config); + reasons += decisionVariation.DecisionReasons; + var variation = decisionVariation.ResultObject; if (variation == null) { - decisionVariationResult = GetWhitelistedVariation(experiment, user.GetUserId()); - reasons += decisionVariationResult.DecisionReasons; - - variation = decisionVariationResult.ResultObject; + decisionVariation = GetWhitelistedVariation(experiment, user.GetUserId()); + reasons += decisionVariation.DecisionReasons; + variation = decisionVariation.ResultObject; } if (variation != null) { - decisionVariationResult.SetReasons(reasons); - return decisionVariationResult; + decisionVariation.SetReasons(reasons); + return decisionVariation; } - // fetch the user profile map from the user profile service - var ignoreUPS = Array.Exists(options, - option => option == OptimizelyDecideOption.IGNORE_USER_PROFILE_SERVICE); - - UserProfile userProfile = null; - if (!ignoreUPS && UserProfileService != null) + if (userProfileTracker != null) { - try - { - var userProfileMap = UserProfileService.Lookup(user.GetUserId()); - if (userProfileMap != null && - UserProfileUtil.IsValidUserProfileMap(userProfileMap)) - { - userProfile = UserProfileUtil.ConvertMapToUserProfile(userProfileMap); - decisionVariationResult = - GetStoredVariation(experiment, userProfile, config); - reasons += decisionVariationResult.DecisionReasons; - if (decisionVariationResult.ResultObject != null) - { - return decisionVariationResult.SetReasons(reasons); - } - } - else if (userProfileMap == null) - { - Logger.Log(LogLevel.INFO, - reasons.AddInfo( - "We were unable to get a user profile map from the UserProfileService.")); - } - else - { - Logger.Log(LogLevel.ERROR, - reasons.AddInfo("The UserProfileService returned an invalid map.")); - } - } - catch (Exception exception) + decisionVariation = + GetStoredVariation(experiment, userProfileTracker.UserProfile, config); + reasons += decisionVariation.DecisionReasons; + variation = decisionVariation.ResultObject; + if (variation != null) { - Logger.Log(LogLevel.ERROR, reasons.AddInfo(exception.Message)); - ErrorHandler.HandleError( - new Exceptions.OptimizelyRuntimeException(exception.Message)); + return decisionVariation; } } - var filteredAttributes = user.GetAttributes(); - var doesUserMeetAudienceConditionsResult = - ExperimentUtils.DoesUserMeetAudienceConditions(config, experiment, user, - LOGGING_KEY_TYPE_EXPERIMENT, experiment.Key, Logger); - reasons += doesUserMeetAudienceConditionsResult.DecisionReasons; - if (doesUserMeetAudienceConditionsResult.ResultObject) + var decisionMeetAudience = ExperimentUtils.DoesUserMeetAudienceConditions(config, + experiment, user, + LOGGING_KEY_TYPE_EXPERIMENT, experiment.Key, Logger); + reasons += decisionMeetAudience.DecisionReasons; + if (decisionMeetAudience.ResultObject) { - // Get Bucketing ID from user attributes. - var bucketingIdResult = GetBucketingId(userId, filteredAttributes); - reasons += bucketingIdResult.DecisionReasons; + var bucketingId = GetBucketingId(userId, user.GetAttributes()).ResultObject; - decisionVariationResult = Bucketer.Bucket(config, experiment, - bucketingIdResult.ResultObject, userId); - reasons += decisionVariationResult.DecisionReasons; + decisionVariation = Bucketer.Bucket(config, experiment, bucketingId, userId); + reasons += decisionVariation.DecisionReasons; + variation = decisionVariation.ResultObject; - if (decisionVariationResult.ResultObject?.Key != null) + if (variation != null) { - if (UserProfileService != null && !ignoreUPS) + if (userProfileTracker != null) { - var bucketerUserProfile = userProfile ?? - new UserProfile(userId, - new Dictionary()); - SaveVariation(experiment, decisionVariationResult.ResultObject, - bucketerUserProfile); + userProfileTracker.UpdateUserProfile(experiment, variation); } else { @@ -210,7 +222,7 @@ OptimizelyDecideOption[] options } } - return decisionVariationResult.SetReasons(reasons); + return decisionVariation.SetReasons(reasons); } Logger.Log(LogLevel.INFO, @@ -253,8 +265,7 @@ ProjectConfig config if (experimentToVariationMap.ContainsKey(experimentId) == false) { Logger.Log(LogLevel.DEBUG, - $@"No experiment ""{experimentKey}"" mapped to user ""{userId - }"" in the forced variation map."); + $@"No experiment ""{experimentKey}"" mapped to user ""{userId}"" in the forced variation map."); return Result.NullResult(reasons); } @@ -263,8 +274,7 @@ ProjectConfig config if (string.IsNullOrEmpty(variationId)) { Logger.Log(LogLevel.DEBUG, - $@"No variation mapped to experiment ""{experimentKey - }"" in the forced variation map."); + $@"No variation mapped to experiment ""{experimentKey}"" in the forced variation map."); return Result.NullResult(reasons); } @@ -277,8 +287,7 @@ ProjectConfig config } Logger.Log(LogLevel.DEBUG, - reasons.AddInfo($@"Variation ""{variationKey}"" is mapped to experiment ""{ - experimentKey}"" and user ""{userId}"" in the forced variation map")); + reasons.AddInfo($@"Variation ""{variationKey}"" is mapped to experiment ""{experimentKey}"" and user ""{userId}"" in the forced variation map")); var variation = config.GetVariationFromKey(experimentKey, variationKey); @@ -322,8 +331,7 @@ ProjectConfig config } Logger.Log(LogLevel.DEBUG, - $@"Variation mapped to experiment ""{experimentKey - }"" has been removed for user ""{userId}""."); + $@"Variation mapped to experiment ""{experimentKey}"" has been removed for user ""{userId}""."); return true; } @@ -345,8 +353,7 @@ ProjectConfig config ForcedVariationMap[userId][experimentId] = variationId; Logger.Log(LogLevel.DEBUG, - $@"Set variation ""{variationId}"" for experiment ""{experimentId}"" and user ""{ - userId}"" in the forced variation map."); + $@"Set variation ""{variationId}"" for experiment ""{experimentId}"" and user ""{userId}"" in the forced variation map."); return true; } @@ -638,7 +645,8 @@ public virtual Result GetVariationForFeatureExperiment( OptimizelyUserContext user, UserAttributes filteredAttributes, ProjectConfig config, - OptimizelyDecideOption[] options + OptimizelyDecideOption[] options, + UserProfileTracker userProfileTracker = null ) { var reasons = new DecisionReasons(); @@ -679,7 +687,8 @@ OptimizelyDecideOption[] options } else { - var decisionResponse = GetVariation(experiment, user, config, options); + var decisionResponse = GetVariation(experiment, user, config, options, + userProfileTracker); reasons += decisionResponse?.DecisionReasons; decisionVariation = decisionResponse.ResultObject; @@ -706,9 +715,9 @@ OptimizelyDecideOption[] options /// /// Get the variation the user is bucketed into for the FeatureFlag /// - /// The feature flag the user wants to access. - /// User Identifier - /// The user's attributes. This should be filtered to just attributes in the Datafile. + /// The feature flag the user wants to access. + /// The user context. + /// The project config. /// null if the user is not bucketed into any variation or the FeatureDecision entity if the user is /// successfully bucketed. public virtual Result GetVariationForFeature(FeatureFlag featureFlag, @@ -720,52 +729,144 @@ public virtual Result GetVariationForFeature(FeatureFlag featur } /// - /// Get the variation the user is bucketed into for the FeatureFlag + /// Get the decision for a single feature flag, following Swift SDK pattern. + /// This method processes holdouts, experiments, and rollouts in sequence. /// - /// The feature flag the user wants to access. - /// User Identifier - /// The user's attributes. This should be filtered to just attributes in the Datafile. - /// The user's attributes. This should be filtered to just attributes in the Datafile. - /// An array of decision options. - /// null if the user is not bucketed into any variation or the FeatureDecision entity if the user is - /// successfully bucketed. - public virtual Result GetVariationForFeature(FeatureFlag featureFlag, + /// The feature flag to get a decision for. + /// The user context. + /// The project config. + /// The user's filtered attributes. + /// Decision options. + /// User profile tracker for sticky bucketing. + /// Decision reasons to merge. + /// A decision result for the feature flag. + public virtual Result GetDecisionForFlag( + FeatureFlag featureFlag, OptimizelyUserContext user, - ProjectConfig config, + ProjectConfig projectConfig, UserAttributes filteredAttributes, - OptimizelyDecideOption[] options + OptimizelyDecideOption[] options, + UserProfileTracker userProfileTracker = null, + DecisionReasons decideReasons = null ) { var reasons = new DecisionReasons(); + if (decideReasons != null) + { + reasons += decideReasons; + } + var userId = user.GetUserId(); + + // Check holdouts first (highest priority) + var holdouts = projectConfig.GetHoldoutsForFlag(featureFlag.Id); + foreach (var holdout in holdouts) + { + var holdoutDecision = GetVariationForHoldout(holdout, user, projectConfig); + reasons += holdoutDecision.DecisionReasons; + + if (holdoutDecision.ResultObject != null) + { + Logger.Log(LogLevel.INFO, + reasons.AddInfo( + $"The user \"{userId}\" is bucketed into holdout \"{holdout.Key}\" for feature flag \"{featureFlag.Key}\".")); + return Result.NewResult(holdoutDecision.ResultObject, reasons); + } + } + // Check if the feature flag has an experiment and the user is bucketed into that experiment. - var decisionResult = GetVariationForFeatureExperiment(featureFlag, user, - filteredAttributes, config, options); - reasons += decisionResult.DecisionReasons; + var experimentDecision = GetVariationForFeatureExperiment(featureFlag, user, + filteredAttributes, projectConfig, options, userProfileTracker); + reasons += experimentDecision.DecisionReasons; - if (decisionResult.ResultObject != null) + if (experimentDecision.ResultObject != null) { - return Result.NewResult(decisionResult.ResultObject, reasons); + return Result.NewResult(experimentDecision.ResultObject, reasons); } - // Check if the feature flag has rollout and the the user is bucketed into one of its rules. - decisionResult = GetVariationForFeatureRollout(featureFlag, user, config); - reasons += decisionResult.DecisionReasons; + // Check if the feature flag has rollout and the user is bucketed into one of its rules. + var rolloutDecision = GetVariationForFeatureRollout(featureFlag, user, projectConfig); + reasons += rolloutDecision.DecisionReasons; - if (decisionResult.ResultObject != null) + if (rolloutDecision.ResultObject != null) { Logger.Log(LogLevel.INFO, reasons.AddInfo( $"The user \"{userId}\" is bucketed into a rollout for feature flag \"{featureFlag.Key}\".")); - return Result.NewResult(decisionResult.ResultObject, reasons); + return Result.NewResult(rolloutDecision.ResultObject, reasons); } + else + { + Logger.Log(LogLevel.INFO, + reasons.AddInfo( + $"The user \"{userId}\" is not bucketed into a rollout for feature flag \"{featureFlag.Key}\".")); + return Result.NewResult( + new FeatureDecision(null, null, FeatureDecision.DECISION_SOURCE_ROLLOUT), + reasons); + } + } - Logger.Log(LogLevel.INFO, - reasons.AddInfo( - $"The user \"{userId}\" is not bucketed into a rollout for feature flag \"{featureFlag.Key}\".")); - return Result.NewResult( - new FeatureDecision(null, null, FeatureDecision.DECISION_SOURCE_ROLLOUT), reasons); - ; + public virtual List> GetVariationsForFeatureList( + List featureFlags, + OptimizelyUserContext user, + ProjectConfig projectConfig, + UserAttributes filteredAttributes, + OptimizelyDecideOption[] options + ) + { + var upsReasons = new DecisionReasons(); + + var ignoreUps = options.Contains(OptimizelyDecideOption.IGNORE_USER_PROFILE_SERVICE); + UserProfileTracker userProfileTracker = null; + + if (UserProfileService != null && !ignoreUps) + { + userProfileTracker = new UserProfileTracker(UserProfileService, user.GetUserId(), + Logger, ErrorHandler); + userProfileTracker.LoadUserProfile(upsReasons); + } + + var decisions = new List>(); + + foreach (var featureFlag in featureFlags) + { + var decision = GetDecisionForFlag(featureFlag, user, projectConfig, filteredAttributes, + options, userProfileTracker, upsReasons); + decisions.Add(decision); + } + + if (UserProfileService != null && !ignoreUps && + userProfileTracker?.ProfileUpdated == true) + { + userProfileTracker.SaveUserProfile(); + } + + return decisions; + } + + /// + /// Get the variation the user is bucketed into for the FeatureFlag + /// + /// The feature flag the user wants to access. + /// The user context. + /// The project config. + /// The user's attributes. This should be filtered to just attributes in the Datafile. + /// An array of decision options. + /// null if the user is not bucketed into any variation or the FeatureDecision entity if the user is + /// successfully bucketed. + public virtual Result GetVariationForFeature(FeatureFlag featureFlag, + OptimizelyUserContext user, + ProjectConfig config, + UserAttributes filteredAttributes, + OptimizelyDecideOption[] options + ) + { + return GetVariationsForFeatureList(new List { featureFlag }, + user, + config, + filteredAttributes, + options). + First(); } /// @@ -800,6 +901,56 @@ private Result GetBucketingId(string userId, UserAttributes filteredAttr return Result.NewResult(bucketingId, reasons); } + private Result GetVariationForHoldout( + Holdout holdout, + OptimizelyUserContext user, + ProjectConfig config + ) + { + var userId = user.GetUserId(); + var reasons = new DecisionReasons(); + + if (!holdout.isRunning) + { + var infoMessage = $"Holdout \"{holdout.Key}\" is not running."; + Logger.Log(LogLevel.INFO, infoMessage); + reasons.AddInfo(infoMessage); + return Result.NullResult(reasons); + } + + var audienceResult = ExperimentUtils.DoesUserMeetAudienceConditions( + config, + holdout, + user, + LOGGING_KEY_TYPE_EXPERIMENT, + holdout.Key, + Logger + ); + reasons += audienceResult.DecisionReasons; + + if (!audienceResult.ResultObject) + { + reasons.AddInfo($"User \"{userId}\" does not meet conditions for holdout ({holdout.Key})."); + return Result.NullResult(reasons); + } + + var attributes = user.GetAttributes(); + var bucketingIdResult = GetBucketingId(userId, attributes); + var bucketedVariation = Bucketer.Bucket(config, holdout, bucketingIdResult.ResultObject, userId); + reasons += bucketedVariation.DecisionReasons; + + if (bucketedVariation.ResultObject != null && !string.IsNullOrEmpty(bucketedVariation.ResultObject.Key)) + { + reasons.AddInfo($"User \"{userId}\" is bucketed into holdout variation \"{bucketedVariation.ResultObject.Key}\"."); + return Result.NewResult( + new FeatureDecision(holdout, bucketedVariation.ResultObject, FeatureDecision.DECISION_SOURCE_HOLDOUT), + reasons + ); + } + + reasons.AddInfo($"User \"{userId}\" is not bucketed into holdout variation \"{holdout.Key}\"."); + return Result.NullResult(reasons); + } /// /// Finds a validated forced decision. /// diff --git a/OptimizelySDK/Bucketing/UserProfileTracker.cs b/OptimizelySDK/Bucketing/UserProfileTracker.cs new file mode 100644 index 000000000..226cca482 --- /dev/null +++ b/OptimizelySDK/Bucketing/UserProfileTracker.cs @@ -0,0 +1,108 @@ +using System; +using System.Collections.Generic; +using OptimizelySDK.Entity; +using OptimizelySDK.ErrorHandler; +using OptimizelySDK.Logger; +using OptimizelySDK.OptimizelyDecisions; + +namespace OptimizelySDK.Bucketing +{ + public class UserProfileTracker + { + public UserProfile UserProfile { get; private set; } + public bool ProfileUpdated { get; private set; } + + private readonly UserProfileService _userProfileService; + private readonly string _userId; + private readonly ILogger _logger; + private readonly IErrorHandler _errorHandler; + + public UserProfileTracker(UserProfileService userProfileService, string userId, ILogger logger, IErrorHandler errorHandler) + { + _userProfileService = userProfileService; + _userId = userId; + _logger = logger; + _errorHandler = errorHandler; + ProfileUpdated = false; + UserProfile = null; + } + + public void LoadUserProfile(DecisionReasons reasons) + { + try + { + var userProfileMap = _userProfileService.Lookup(_userId); + if (userProfileMap == null) + { + _logger.Log(LogLevel.INFO, + reasons.AddInfo( + "We were unable to get a user profile map from the UserProfileService.")); + } + else if (UserProfileUtil.IsValidUserProfileMap(userProfileMap)) + { + UserProfile = UserProfileUtil.ConvertMapToUserProfile(userProfileMap); + } + else + { + _logger.Log(LogLevel.WARN, + reasons.AddInfo("The UserProfileService returned an invalid map.")); + } + } + catch (Exception exception) + { + _logger.Log(LogLevel.ERROR, reasons.AddInfo(exception.Message)); + _errorHandler.HandleError( + new Exceptions.OptimizelyRuntimeException(exception.Message)); + } + + if (UserProfile == null) + { + UserProfile = new UserProfile(_userId, new Dictionary()); + } + } + + public void UpdateUserProfile(Experiment experiment, Variation variation) + { + var experimentId = experiment.Id; + var variationId = variation.Id; + Decision decision; + if (UserProfile.ExperimentBucketMap.ContainsKey(experimentId)) + { + decision = UserProfile.ExperimentBucketMap[experimentId]; + decision.VariationId = variationId; + } + else + { + decision = new Decision(variationId); + } + + UserProfile.ExperimentBucketMap[experimentId] = decision; + ProfileUpdated = true; + + _logger.Log(LogLevel.INFO, + $"Saved variation \"{variationId}\" of experiment \"{experimentId}\" for user \"{UserProfile.UserId}\"."); + } + + public void SaveUserProfile() + { + if (!ProfileUpdated) + { + return; + } + + try + { + _userProfileService.Save(UserProfile.ToMap()); + _logger.Log(LogLevel.INFO, + $"Saved user profile of user \"{UserProfile.UserId}\"."); + } + catch (Exception exception) + { + _logger.Log(LogLevel.WARN, + $"Failed to save user profile of user \"{UserProfile.UserId}\"."); + _errorHandler.HandleError( + new Exceptions.OptimizelyRuntimeException(exception.Message)); + } + } + } +} diff --git a/OptimizelySDK/Cmab/CmabConstants.cs b/OptimizelySDK/Cmab/CmabConstants.cs new file mode 100644 index 000000000..8c3659a1d --- /dev/null +++ b/OptimizelySDK/Cmab/CmabConstants.cs @@ -0,0 +1,32 @@ +/* +* Copyright 2025, Optimizely +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +using System; + +namespace OptimizelySDK.Cmab +{ + internal static class CmabConstants + { + public const string PredictionUrl = "https://prediction.cmab.optimizely.com/predict"; + public static readonly TimeSpan MaxTimeout = TimeSpan.FromSeconds(10); + + public const string ContentTypeJson = "application/json"; + + public const string ErrorFetchFailedFmt = "CMAB decision fetch failed with status: {0}"; + public const string ErrorInvalidResponse = "Invalid CMAB fetch response"; + public const string ExhaustRetryMessage = "Exhausted all retries for CMAB request"; + } +} diff --git a/OptimizelySDK/Cmab/CmabModels.cs b/OptimizelySDK/Cmab/CmabModels.cs new file mode 100644 index 000000000..3a992458c --- /dev/null +++ b/OptimizelySDK/Cmab/CmabModels.cs @@ -0,0 +1,41 @@ +/* +* Copyright 2025, Optimizely +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +using System.Collections.Generic; +using Newtonsoft.Json; + +namespace OptimizelySDK.Cmab +{ + internal class CmabAttribute + { + [JsonProperty("id")] public string Id { get; set; } + [JsonProperty("value")] public object Value { get; set; } + [JsonProperty("type")] public string Type { get; set; } = "custom_attribute"; + } + + internal class CmabInstance + { + [JsonProperty("visitorId")] public string VisitorId { get; set; } + [JsonProperty("experimentId")] public string ExperimentId { get; set; } + [JsonProperty("attributes")] public List Attributes { get; set; } + [JsonProperty("cmabUUID")] public string CmabUUID { get; set; } + } + + internal class CmabRequest + { + [JsonProperty("instances")] public List Instances { get; set; } + } +} diff --git a/OptimizelySDK/Cmab/CmabRetryConfig.cs b/OptimizelySDK/Cmab/CmabRetryConfig.cs new file mode 100644 index 000000000..d89d78c6f --- /dev/null +++ b/OptimizelySDK/Cmab/CmabRetryConfig.cs @@ -0,0 +1,43 @@ +/* +* Copyright 2025, Optimizely +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +using System; + +namespace OptimizelySDK.Cmab +{ + /// + /// Configuration for retrying CMAB requests (exponential backoff). + /// + public class CmabRetryConfig + { + public int MaxRetries { get; } + public TimeSpan InitialBackoff { get; } + public TimeSpan MaxBackoff { get; } + public double BackoffMultiplier { get; } + + public CmabRetryConfig( + int maxRetries = 3, + TimeSpan? initialBackoff = null, + TimeSpan? maxBackoff = null, + double backoffMultiplier = 2.0) + { + MaxRetries = maxRetries; + InitialBackoff = initialBackoff ?? TimeSpan.FromMilliseconds(100); + MaxBackoff = maxBackoff ?? TimeSpan.FromSeconds(10); + BackoffMultiplier = backoffMultiplier; + } + } +} diff --git a/OptimizelySDK/Cmab/DefaultCmabClient.cs b/OptimizelySDK/Cmab/DefaultCmabClient.cs new file mode 100644 index 000000000..3faaec758 --- /dev/null +++ b/OptimizelySDK/Cmab/DefaultCmabClient.cs @@ -0,0 +1,216 @@ +/* +* Copyright 2025, Optimizely +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Net.Http; +using System.Text; +using System.Threading; +using System.Threading.Tasks; +using Newtonsoft.Json; +using Newtonsoft.Json.Linq; +using OptimizelySDK.ErrorHandler; +using OptimizelySDK.Exceptions; +using OptimizelySDK.Logger; + +namespace OptimizelySDK.Cmab +{ + /// + /// Default client for interacting with the CMAB service via HttpClient. + /// + public class DefaultCmabClient : ICmabClient + { + private readonly HttpClient _httpClient; + private readonly CmabRetryConfig _retryConfig; + private readonly ILogger _logger; + private readonly IErrorHandler _errorHandler; + + public DefaultCmabClient( + HttpClient httpClient = null, + CmabRetryConfig retryConfig = null, + ILogger logger = null, + IErrorHandler errorHandler = null) + { + _httpClient = httpClient ?? new HttpClient(); + _retryConfig = retryConfig; + _logger = logger ?? new NoOpLogger(); + _errorHandler = errorHandler ?? new NoOpErrorHandler(); + } + + private async Task FetchDecisionAsync( + string ruleId, + string userId, + IDictionary attributes, + string cmabUuid, + TimeSpan? timeout = null) + { + var url = $"{CmabConstants.PredictionUrl}/{ruleId}"; + var body = BuildRequestBody(ruleId, userId, attributes, cmabUuid); + var perAttemptTimeout = timeout ?? CmabConstants.MaxTimeout; + + if (_retryConfig == null) + { + return await DoFetchOnceAsync(url, body, perAttemptTimeout).ConfigureAwait(false); + } + return await DoFetchWithRetryAsync(url, body, perAttemptTimeout).ConfigureAwait(false); + } + + public string FetchDecision( + string ruleId, + string userId, + IDictionary attributes, + string cmabUuid, + TimeSpan? timeout = null) + { + try + { + return FetchDecisionAsync(ruleId, userId, attributes, cmabUuid, timeout).ConfigureAwait(false).GetAwaiter().GetResult(); + } + catch (Exception ex) + { + _errorHandler.HandleError(ex); + throw; + } + } + + private static StringContent BuildContent(object payload) + { + var json = JsonConvert.SerializeObject(payload); + return new StringContent(json, Encoding.UTF8, CmabConstants.ContentTypeJson); + } + + private static CmabRequest BuildRequestBody(string ruleId, string userId, IDictionary attributes, string cmabUuid) + { + var attrList = new List(); + + if (attributes != null) + { + attrList = attributes.Select(kv => new CmabAttribute { Id = kv.Key, Value = kv.Value }).ToList(); + } + + return new CmabRequest + { + Instances = new List + { + new CmabInstance + { + VisitorId = userId, + ExperimentId = ruleId, + Attributes = attrList, + CmabUUID = cmabUuid, + } + } + }; + } + + private async Task DoFetchOnceAsync(string url, CmabRequest request, TimeSpan timeout) + { + using (var cts = new CancellationTokenSource(timeout)) + { + try + { + var httpRequest = new HttpRequestMessage + { + RequestUri = new Uri(url), + Method = HttpMethod.Post, + Content = BuildContent(request), + }; + + var response = await _httpClient.SendAsync(httpRequest, cts.Token).ConfigureAwait(false); + + if (!response.IsSuccessStatusCode) + { + var status = (int)response.StatusCode; + _logger.Log(LogLevel.ERROR, string.Format(CmabConstants.ErrorFetchFailedFmt, status)); + throw new CmabFetchException(string.Format(CmabConstants.ErrorFetchFailedFmt, status)); + } + + var responseText = await response.Content.ReadAsStringAsync().ConfigureAwait(false); + + var j = JObject.Parse(responseText); + if (!ValidateResponse(j)) + { + _logger.Log(LogLevel.ERROR, CmabConstants.ErrorInvalidResponse); + throw new CmabInvalidResponseException(CmabConstants.ErrorInvalidResponse); + } + + var variationIdToken = j["predictions"][0]["variation_id"]; + return variationIdToken?.ToString(); + } + catch (JsonException ex) + { + _logger.Log(LogLevel.ERROR, CmabConstants.ErrorInvalidResponse); + throw new CmabInvalidResponseException(ex.Message); + } + catch (CmabInvalidResponseException) + { + throw; + } + catch (HttpRequestException ex) + { + _logger.Log(LogLevel.ERROR, string.Format(CmabConstants.ErrorFetchFailedFmt, ex.Message)); + throw new CmabFetchException(string.Format(CmabConstants.ErrorFetchFailedFmt, ex.Message)); + } + catch (Exception ex) + { + _logger.Log(LogLevel.ERROR, string.Format(CmabConstants.ErrorFetchFailedFmt, ex.Message)); + throw new CmabFetchException(string.Format(CmabConstants.ErrorFetchFailedFmt, ex.Message)); + } + } + } + + private async Task DoFetchWithRetryAsync(string url, CmabRequest request, TimeSpan timeout) + { + var backoff = _retryConfig.InitialBackoff; + var attempt = 0; + while (true) + { + try + { + return await DoFetchOnceAsync(url, request, timeout).ConfigureAwait(false); + } + catch (Exception) + { + if (attempt >= _retryConfig.MaxRetries) + { + _logger.Log(LogLevel.ERROR, string.Format(CmabConstants.ErrorFetchFailedFmt, CmabConstants.ExhaustRetryMessage)); + throw new CmabFetchException(string.Format(CmabConstants.ErrorFetchFailedFmt, CmabConstants.ExhaustRetryMessage)); + } + + _logger.Log(LogLevel.INFO, $"Retrying CMAB request (attempt: {attempt + 1}) after {backoff.TotalSeconds} seconds..."); + await Task.Delay(backoff).ConfigureAwait(false); + var nextMs = Math.Min(_retryConfig.MaxBackoff.TotalMilliseconds, backoff.TotalMilliseconds * _retryConfig.BackoffMultiplier); + backoff = TimeSpan.FromMilliseconds(nextMs); + attempt++; + } + } + } + + private static bool ValidateResponse(JObject body) + { + if (body == null) return false; + + var preds = body["predictions"] as JArray; + if (preds == null || preds.Count == 0) return false; + + var first = preds[0] as JObject; + if (first == null) return false; + + return first["variation_id"] != null; + } + } +} diff --git a/OptimizelySDK/Cmab/ICmabClient.cs b/OptimizelySDK/Cmab/ICmabClient.cs new file mode 100644 index 000000000..d80aec618 --- /dev/null +++ b/OptimizelySDK/Cmab/ICmabClient.cs @@ -0,0 +1,41 @@ +/* +* Copyright 2025, Optimizely +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +using System; +using System.Collections.Generic; +using System.Threading; +using System.Threading.Tasks; + +namespace OptimizelySDK.Cmab +{ + /// + /// Interface for CMAB client that fetches decisions from the prediction service. + /// + public interface ICmabClient + { + /// + /// Fetch a decision (variation id) from CMAB prediction service. + /// Throws on failure (network/non-2xx/invalid response/exhausted retries). + /// + /// Variation ID as string. + string FetchDecision( + string ruleId, + string userId, + IDictionary attributes, + string cmabUuid, + TimeSpan? timeout = null); + } +} diff --git a/OptimizelySDK/Config/DatafileProjectConfig.cs b/OptimizelySDK/Config/DatafileProjectConfig.cs index cb248f8c0..52593e785 100644 --- a/OptimizelySDK/Config/DatafileProjectConfig.cs +++ b/OptimizelySDK/Config/DatafileProjectConfig.cs @@ -103,7 +103,7 @@ public enum OPTLYSDKVersion public string Datafile { get; set; } /// - /// Configured host name for the Optimizely Data Platform. + /// Configured host name for the Optimizely Data Platform. /// public string HostForOdp { get; private set; } @@ -195,6 +195,13 @@ private Dictionary> _VariationIdMap public Dictionary AttributeKeyMap => _AttributeKeyMap; + /// + /// Associative array of attribute ID to Attribute(s) in the datafile + /// + private Dictionary _AttributeIdMap; + + public Dictionary AttributeIdMap => _AttributeIdMap; + /// /// Associative array of audience ID to Audience(s) in the datafile /// @@ -232,6 +239,11 @@ private Dictionary> _VariationIdMap public Dictionary> FlagVariationMap => _FlagVariationMap; + /// + /// Holdout configuration manager for flag-to-holdout relationships. + /// + private HoldoutConfig _holdoutConfig; + //========================= Interfaces =========================== /// @@ -286,6 +298,11 @@ private Dictionary> _VariationIdMap /// public Rollout[] Rollouts { get; set; } + /// + /// Associative list of Holdouts. + /// + public Holdout[] Holdouts { get; set; } + /// /// Associative list of Integrations. /// @@ -309,6 +326,7 @@ private void Initialize() TypedAudiences = TypedAudiences ?? new Audience[0]; FeatureFlags = FeatureFlags ?? new FeatureFlag[0]; Rollouts = Rollouts ?? new Rollout[0]; + Holdouts = Holdouts ?? new Holdout[0]; Integrations = Integrations ?? new Integration[0]; _ExperimentKeyMap = new Dictionary(); @@ -321,6 +339,8 @@ private void Initialize() true); _AttributeKeyMap = ConfigParser.GenerateMap(Attributes, a => a.Key, true); + _AttributeIdMap = ConfigParser.GenerateMap(Attributes, + a => a.Id, true); _AudienceIdMap = ConfigParser.GenerateMap(Audiences, a => a.Id.ToString(), true); _FeatureKeyMap = ConfigParser.GenerateMap(FeatureFlags, @@ -402,6 +422,29 @@ private void Initialize() } } + // Adding Holdout variations in variation id and key maps. + if (Holdouts != null) + { + foreach (var holdout in Holdouts) + { + _VariationKeyMap[holdout.Key] = new Dictionary(); + _VariationIdMap[holdout.Key] = new Dictionary(); + _VariationIdMapByExperimentId[holdout.Id] = new Dictionary(); + _VariationKeyMapByExperimentId[holdout.Id] = new Dictionary(); + + if (holdout.Variations != null) + { + foreach (var variation in holdout.Variations) + { + _VariationKeyMap[holdout.Key][variation.Key] = variation; + _VariationIdMap[holdout.Key][variation.Id] = variation; + _VariationKeyMapByExperimentId[holdout.Id][variation.Key] = variation; + _VariationIdMapByExperimentId[holdout.Id][variation.Id] = variation; + } + } + } + } + var integration = Integrations.FirstOrDefault(i => i.Key.ToLower() == "odp"); HostForOdp = integration?.Host; PublicKeyForOdp = integration?.PublicKey; @@ -450,6 +493,9 @@ private void Initialize() } _FlagVariationMap = flagToVariationsMap; + + // Initialize HoldoutConfig for managing flag-to-holdout relationships + _holdoutConfig = new HoldoutConfig(Holdouts ?? new Holdout[0]); } /// @@ -492,8 +538,7 @@ private static DatafileProjectConfig GetConfig(string configData) !(((int)supportedVersion).ToString() == config.Version))) { throw new ConfigParseException( - $@"This version of the C# SDK does not support the given datafile version: { - config.Version}"); + $@"This version of the C# SDK does not support the given datafile version: {config.Version}"); } return config; @@ -617,6 +662,25 @@ public Attribute GetAttribute(string attributeKey) return new Attribute(); } + /// + /// Get the Attribute from the ID + /// + /// ID of the Attribute + /// Attribute Entity corresponding to the ID or a dummy entity if ID is invalid + public Attribute GetAttributeById(string attributeId) + { + if (_AttributeIdMap.ContainsKey(attributeId)) + { + return _AttributeIdMap[attributeId]; + } + + var message = $@"Attribute ID ""{attributeId}"" is not in datafile."; + Logger.Log(LogLevel.ERROR, message); + ErrorHandler.HandleError( + new InvalidAttributeException("Provided attribute is not in datafile.")); + return new Attribute(); + } + /// /// Get the Variation from the keys /// @@ -632,8 +696,7 @@ public Variation GetVariationFromKey(string experimentKey, string variationKey) return _VariationKeyMap[experimentKey][variationKey]; } - var message = $@"No variation key ""{variationKey - }"" defined in datafile for experiment ""{experimentKey}""."; + var message = $@"No variation key ""{variationKey}"" defined in datafile for experiment ""{experimentKey}""."; Logger.Log(LogLevel.ERROR, message); ErrorHandler.HandleError( new InvalidVariationException("Provided variation is not in datafile.")); @@ -655,8 +718,7 @@ public Variation GetVariationFromKeyByExperimentId(string experimentId, string v return _VariationKeyMapByExperimentId[experimentId][variationKey]; } - var message = $@"No variation key ""{variationKey - }"" defined in datafile for experiment ""{experimentId}""."; + var message = $@"No variation key ""{variationKey}"" defined in datafile for experiment ""{experimentId}""."; Logger.Log(LogLevel.ERROR, message); ErrorHandler.HandleError( new InvalidVariationException("Provided variation is not in datafile.")); @@ -678,8 +740,7 @@ public Variation GetVariationFromId(string experimentKey, string variationId) return _VariationIdMap[experimentKey][variationId]; } - var message = $@"No variation ID ""{variationId - }"" defined in datafile for experiment ""{experimentKey}""."; + var message = $@"No variation ID ""{variationId}"" defined in datafile for experiment ""{experimentKey}""."; Logger.Log(LogLevel.ERROR, message); ErrorHandler.HandleError( new InvalidVariationException("Provided variation is not in datafile.")); @@ -701,11 +762,9 @@ public Variation GetVariationFromIdByExperimentId(string experimentId, string va return _VariationIdMapByExperimentId[experimentId][variationId]; } - var message = $@"No variation ID ""{variationId - }"" defined in datafile for experiment ""{experimentId}""."; + var message = $@"No variation ID ""{variationId}"" defined in datafile for experiment ""{experimentId}""."; Logger.Log(LogLevel.ERROR, message); - ErrorHandler.HandleError( - new InvalidVariationException("Provided variation is not in datafile.")); + ErrorHandler.HandleError(new InvalidVariationException("Provided variation is not in datafile.")); return new Variation(); } @@ -773,6 +832,16 @@ public Rollout GetRolloutFromId(string rolloutId) return new Rollout(); } + /// + /// Get the holdout from the ID + /// + /// ID for holdout + /// Holdout Entity corresponding to the holdout ID or null if ID is invalid + public Holdout GetHoldout(string holdoutId) + { + return _holdoutConfig.GetHoldout(holdoutId); + } + /// /// Get attribute ID for the provided attribute key /// @@ -788,9 +857,7 @@ public string GetAttributeId(string attributeKey) if (hasReservedPrefix) { Logger.Log(LogLevel.WARN, - $@"Attribute {attributeKey} unexpectedly has reserved prefix { - RESERVED_ATTRIBUTE_PREFIX - }; using attribute ID instead of reserved attribute name."); + $@"Attribute {attributeKey} unexpectedly has reserved prefix {RESERVED_ATTRIBUTE_PREFIX}; using attribute ID instead of reserved attribute name."); } return attribute.Id; @@ -825,12 +892,29 @@ public bool IsFeatureExperiment(string experimentId) } /// - ///Returns the datafile corresponding to ProjectConfig + /// Gets or sets the region associated with the project configuration. + /// This typically indicates the data residency or deployment region (e.g., "us", "eu"). + /// Valid values depend on the Optimizely environment and configuration. /// /// the datafile string corresponding to ProjectConfig public string ToDatafile() { return _datafile; } + + /// + /// Get holdout instances associated with the given feature flag Id. + /// + /// Feature flag Id + /// Array of holdouts associated with the flag, empty array if none + public Holdout[] GetHoldoutsForFlag(string flagId) + { + var holdouts = _holdoutConfig?.GetHoldoutsForFlag(flagId); + return holdouts?.ToArray() ?? new Holdout[0]; + } + /// Returns the datafile corresponding to ProjectConfig + /// + /// the datafile string corresponding to ProjectConfig + public string Region { get; set; } } } diff --git a/OptimizelySDK/Entity/Cmab.cs b/OptimizelySDK/Entity/Cmab.cs new file mode 100644 index 000000000..f8caec87d --- /dev/null +++ b/OptimizelySDK/Entity/Cmab.cs @@ -0,0 +1,63 @@ +/* + * Copyright 2025, Optimizely + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +using System.Collections.Generic; +using Newtonsoft.Json; + +namespace OptimizelySDK.Entity +{ + /// + /// Class representing CMAB (Contextual Multi-Armed Bandit) configuration for experiments. + /// + public class Cmab + { + /// + /// List of attribute IDs that are relevant for CMAB decision making. + /// These attributes will be used to filter user attributes when making CMAB requests. + /// + [JsonProperty("attributeIds")] + public List AttributeIds { get; set; } + + /// + /// Traffic allocation value for CMAB experiments. + /// Determines what portion of traffic should be allocated to CMAB decision making. + /// + [JsonProperty("trafficAllocation")] + public int? TrafficAllocation { get; set; } + + /// + /// Initializes a new instance of the Cmab class with specified values. + /// + /// List of attribute IDs for CMAB + /// Traffic allocation value + public Cmab(List attributeIds, int? trafficAllocation = null) + { + AttributeIds = attributeIds ?? new List(); + TrafficAllocation = trafficAllocation; + } + + /// + /// Returns a string representation of the CMAB configuration. + /// + /// String representation + public override string ToString() + { + var attributeList = AttributeIds ?? new List(); + return string.Format("Cmab{{AttributeIds=[{0}], TrafficAllocation={1}}}", + string.Join(", ", attributeList.ToArray()), TrafficAllocation); + } + } +} diff --git a/OptimizelySDK/Entity/Experiment.cs b/OptimizelySDK/Entity/Experiment.cs index e1eee5f2b..52e990152 100644 --- a/OptimizelySDK/Entity/Experiment.cs +++ b/OptimizelySDK/Entity/Experiment.cs @@ -16,38 +16,18 @@ using System.Collections.Generic; using Newtonsoft.Json; -using Newtonsoft.Json.Linq; -using OptimizelySDK.AudienceConditions; -using OptimizelySDK.Utils; namespace OptimizelySDK.Entity { - public class Experiment : IdKeyEntity + public class Experiment : ExperimentCore { - private const string STATUS_RUNNING = "Running"; - private const string MUTEX_GROUP_POLICY = "random"; - /// - /// Experiment Status - /// - public string Status { get; set; } - - /// - /// Layer ID for the experiment - /// - public string LayerId { get; set; } - /// /// Group ID for the experiment /// public string GroupId { get; set; } - /// - /// Variations for the experiment - /// - public Variation[] Variations { get; set; } - /// /// ForcedVariations for the experiment /// @@ -63,203 +43,6 @@ public class Experiment : IdKeyEntity /// public string GroupPolicy { get; set; } - /// - /// ID(s) of audience(s) the experiment is targeted to - /// - public string[] AudienceIds { get; set; } - - private ICondition _audienceIdsList = null; - - /// - /// De-serialized audience conditions - /// - public ICondition AudienceIdsList - { - get - { - if (AudienceIds == null || AudienceIds.Length == 0) - { - return null; - } - - if (_audienceIdsList == null) - { - var conditions = new List(); - foreach (var audienceId in AudienceIds) - { - conditions.Add( - new AudienceIdCondition() { AudienceId = (string)audienceId }); - } - - _audienceIdsList = new OrCondition() { Conditions = conditions.ToArray() }; - } - - return _audienceIdsList; - } - } - - private string _audienceIdsString = null; - - /// - /// Stringified audience conditions - /// - public string AudienceIdsString - { - get - { - if (AudienceIds == null) - { - return null; - } - - if (_audienceIdsString == null) - { - _audienceIdsString = JsonConvert.SerializeObject(AudienceIds, Formatting.None); - } - - return _audienceIdsString; - } - } - - /// - /// Traffic allocation of variations in the experiment - /// - public TrafficAllocation[] TrafficAllocation { get; set; } - - /// - /// Audience Conditions - /// - public object AudienceConditions { get; set; } - - private ICondition _audienceConditionsList = null; - - /// - /// De-serialized audience conditions - /// - public ICondition AudienceConditionsList - { - get - { - if (AudienceConditions == null) - { - return null; - } - - if (_audienceConditionsList == null) - { - if (AudienceConditions is string) - { - _audienceConditionsList = - ConditionParser.ParseAudienceConditions( - JToken.Parse((string)AudienceConditions)); - } - else - { - _audienceConditionsList = - ConditionParser.ParseAudienceConditions((JToken)AudienceConditions); - } - } - - return _audienceConditionsList; - } - } - - private string _audienceConditionsString = null; - - /// - /// Stringified audience conditions - /// - public string AudienceConditionsString - { - get - { - if (AudienceConditions == null) - { - return null; - } - - if (_audienceConditionsString == null) - { - if (AudienceConditions is JToken token) - { - _audienceConditionsString = token.ToString(Formatting.None); - } - else - { - _audienceConditionsString = AudienceConditions.ToString(); - } - } - - return _audienceConditionsString; - } - } - - private bool isGenerateKeyMapCalled = false; - - private Dictionary _VariationKeyToVariationMap; - - public Dictionary VariationKeyToVariationMap - { - get - { - if (!isGenerateKeyMapCalled) - { - GenerateVariationKeyMap(); - } - - return _VariationKeyToVariationMap; - } - } - - private Dictionary _VariationIdToVariationMap; - - public Dictionary VariationIdToVariationMap - { - get - { - if (!isGenerateKeyMapCalled) - { - GenerateVariationKeyMap(); - } - - return _VariationIdToVariationMap; - } - } - - public void GenerateVariationKeyMap() - { - if (Variations == null) - { - return; - } - - _VariationIdToVariationMap = - ConfigParser.GenerateMap(Variations, a => a.Id, true); - _VariationKeyToVariationMap = - ConfigParser.GenerateMap(Variations, a => a.Key, true); - isGenerateKeyMapCalled = true; - } - - // Code from PHP, need to build traffic and variations from config -#if false - /** - * @param $variations array Variations in experiment. - */ - public function setVariations($variations) - { - $this->_variations = ConfigParser::generateMap($variations, null, Variation::class); - } - - /** - * @param $trafficAllocation array Traffic allocation of variations in experiment. - */ - public function setTrafficAllocation($trafficAllocation) - { - $this->_trafficAllocation = - ConfigParser::generateMap($trafficAllocation, null, TrafficAllocation::class); - } -#endif - /// /// Determine if experiment is in a mutually exclusive group /// @@ -267,10 +50,10 @@ public function setTrafficAllocation($trafficAllocation) !string.IsNullOrEmpty(GroupPolicy) && GroupPolicy == MUTEX_GROUP_POLICY; /// - /// Determine if experiment is running or not + /// CMAB (Contextual Multi-Armed Bandit) configuration for the experiment. /// - public bool IsExperimentRunning => - !string.IsNullOrEmpty(Status) && Status == STATUS_RUNNING; + [JsonProperty("cmab")] + public Cmab Cmab { get; set; } /// /// Determin if user is forced variation of experiment diff --git a/OptimizelySDK/Entity/ExperimentCore.cs b/OptimizelySDK/Entity/ExperimentCore.cs new file mode 100644 index 000000000..0f81e2d08 --- /dev/null +++ b/OptimizelySDK/Entity/ExperimentCore.cs @@ -0,0 +1,281 @@ +/* + * Copyright 2025, Optimizely + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +using System.Collections.Generic; +using System.Linq; +using Newtonsoft.Json; +using Newtonsoft.Json.Linq; +using OptimizelySDK.AudienceConditions; +using OptimizelySDK.Utils; + +namespace OptimizelySDK.Entity +{ + /// + /// Abstract base class containing common properties and behaviors shared between Experiment and Holdout + /// + public abstract class ExperimentCore : IdKeyEntity + { + protected const string STATUS_RUNNING = "Running"; + + /// + /// Status of the experiment/holdout + /// + public string Status { get; set; } + + /// + /// Layer ID for the experiment + /// + public virtual string LayerId { get; set; } + + /// + /// Variations for the experiment/holdout + /// + public Variation[] Variations { get; set; } + + /// + /// Traffic allocation of variations in the experiment/holdout + /// + public TrafficAllocation[] TrafficAllocation { get; set; } + + /// + /// ID(s) of audience(s) the experiment/holdout is targeted to + /// + public string[] AudienceIds { get; set; } + + /// + /// Audience Conditions + /// + public object AudienceConditions { get; set; } + + #region Audience Processing Properties + + private ICondition _audienceIdsList = null; + + /// + /// De-serialized audience conditions from audience IDs + /// + public ICondition AudienceIdsList + { + get + { + if (AudienceIds == null || AudienceIds.Length == 0) + { + return null; + } + + if (_audienceIdsList == null) + { + var conditions = new List(); + foreach (var audienceId in AudienceIds) + { + conditions.Add(new AudienceIdCondition() { AudienceId = audienceId }); + } + + _audienceIdsList = new OrCondition() { Conditions = conditions.ToArray() }; + } + + return _audienceIdsList; + } + } + + private string _audienceIdsString = null; + + /// + /// Stringified audience IDs + /// + public string AudienceIdsString + { + get + { + if (AudienceIds == null) + { + return null; + } + + if (_audienceIdsString == null) + { + _audienceIdsString = JsonConvert.SerializeObject(AudienceIds, Formatting.None); + } + + return _audienceIdsString; + } + } + + private ICondition _audienceConditionsList = null; + + /// + /// De-serialized audience conditions + /// + public ICondition AudienceConditionsList + { + get + { + if (AudienceConditions == null) + { + return null; + } + + if (_audienceConditionsList == null) + { + if (AudienceConditions is string) + { + _audienceConditionsList = + ConditionParser.ParseAudienceConditions( + JToken.Parse((string)AudienceConditions)); + } + else + { + _audienceConditionsList = + ConditionParser.ParseAudienceConditions((JToken)AudienceConditions); + } + } + + return _audienceConditionsList; + } + } + + private string _audienceConditionsString = null; + + /// + /// Stringified audience conditions + /// + public string AudienceConditionsString + { + get + { + if (AudienceConditions == null) + { + _audienceConditionsString = null; + return null; + } + + if (_audienceConditionsString == null) + { + if (AudienceConditions is JToken token) + { + _audienceConditionsString = token.ToString(Formatting.None); + } + else + { + _audienceConditionsString = AudienceConditions.ToString(); + } + } + + return _audienceConditionsString; + } + } + + #endregion + + #region Variation Mapping Properties + + private bool isGenerateKeyMapCalled = false; + + private Dictionary _VariationKeyToVariationMap; + + /// + /// Variation key to variation mapping + /// + public Dictionary VariationKeyToVariationMap + { + get + { + if (!isGenerateKeyMapCalled) + { + GenerateVariationKeyMap(); + } + + return _VariationKeyToVariationMap; + } + } + + private Dictionary _VariationIdToVariationMap; + + /// + /// Variation ID to variation mapping + /// + public Dictionary VariationIdToVariationMap + { + get + { + if (!isGenerateKeyMapCalled) + { + GenerateVariationKeyMap(); + } + + return _VariationIdToVariationMap; + } + } + + /// + /// Generate variation key maps for performance optimization + /// + public void GenerateVariationKeyMap() + { + if (Variations == null) + { + return; + } + + _VariationIdToVariationMap = + ConfigParser.GenerateMap(Variations, a => a.Id, true); + _VariationKeyToVariationMap = + ConfigParser.GenerateMap(Variations, a => a.Key, true); + isGenerateKeyMapCalled = true; + } + + #endregion + + #region Variation Helper Methods + + /// + /// Get variation by ID + /// + /// Variation ID to search for + /// Variation with the specified ID, or null if not found + public virtual Variation GetVariation(string id) + { + if (Variations == null || string.IsNullOrEmpty(id)) + { + return null; + } + + return Variations.FirstOrDefault(v => v.Id == id); + } + + /// + /// Get variation by key + /// + /// Variation key to search for + /// Variation with the specified key, or null if not found + public virtual Variation GetVariationByKey(string key) + { + if (Variations == null || string.IsNullOrEmpty(key)) + { + return null; + } + + return Variations.FirstOrDefault(v => v.Key == key); + } + + #endregion + + /// + /// Determine if experiment is currently activated/running + /// + public bool isRunning => !string.IsNullOrEmpty(Status) && Status == STATUS_RUNNING; + } +} diff --git a/OptimizelySDK/Entity/FeatureDecision.cs b/OptimizelySDK/Entity/FeatureDecision.cs index e768cc5a9..6bdd8f4cf 100644 --- a/OptimizelySDK/Entity/FeatureDecision.cs +++ b/OptimizelySDK/Entity/FeatureDecision.cs @@ -20,12 +20,12 @@ public class FeatureDecision { public const string DECISION_SOURCE_FEATURE_TEST = "feature-test"; public const string DECISION_SOURCE_ROLLOUT = "rollout"; - - public Experiment Experiment { get; } + public const string DECISION_SOURCE_HOLDOUT = "holdout"; + public ExperimentCore Experiment { get; } public Variation Variation { get; } public string Source { get; } - public FeatureDecision(Experiment experiment, Variation variation, string source) + public FeatureDecision(ExperimentCore experiment, Variation variation, string source) { Experiment = experiment; Variation = variation; diff --git a/OptimizelySDK/Entity/Holdout.cs b/OptimizelySDK/Entity/Holdout.cs new file mode 100644 index 000000000..834b52293 --- /dev/null +++ b/OptimizelySDK/Entity/Holdout.cs @@ -0,0 +1,59 @@ +/* + * Copyright 2025, Optimizely + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +using System.Collections.Generic; + +namespace OptimizelySDK.Entity +{ + /// + /// Represents a holdout in an Optimizely project + /// + public class Holdout : ExperimentCore + { + /// + /// Holdout status enumeration + /// + public enum HoldoutStatus + { + Draft, + Running, + Concluded, + Archived + } + + /// + /// Flags included in this holdout + /// + public string[] IncludedFlags { get; set; } = new string[0]; + + /// + /// Flags excluded from this holdout + /// + public string[] ExcludedFlags { get; set; } = new string[0]; + + /// + /// Layer ID is always empty for holdouts as they don't belong to any layer + /// + public override string LayerId + { + get => string.Empty; + set + { + /* Holdouts don't have layer IDs, ignore any assignment */ + } + } + } +} diff --git a/OptimizelySDK/Event/Builder/EventBuilder.cs b/OptimizelySDK/Event/Builder/EventBuilder.cs index 1d73ff946..0dd4562ac 100644 --- a/OptimizelySDK/Event/Builder/EventBuilder.cs +++ b/OptimizelySDK/Event/Builder/EventBuilder.cs @@ -27,9 +27,6 @@ namespace OptimizelySDK.Event.Builder [Obsolete("This class is deprecated. Use 'OptimizelySDK.Event.EventFactory'.")] public class EventBuilder { - private const string IMPRESSION_ENDPOINT = "https://logx.optimizely.com/v1/events"; - - private const string CONVERSION_ENDPOINT = "https://logx.optimizely.com/v1/events"; private const string HTTP_VERB = "POST"; @@ -245,7 +242,11 @@ public virtual LogEvent CreateImpressionEvent(ProjectConfig config, Experiment e GetImpressionOrConversionParamsWithCommonParams(commonParams, new object[] { impressionOnlyParams }); - return new LogEvent(IMPRESSION_ENDPOINT, impressionParams, HTTP_VERB, HTTP_HEADERS); + var region = !string.IsNullOrEmpty(config.Region) && EventFactory.EventEndpoints.ContainsKey(config.Region) ? config.Region : "US"; + + var endpoint = EventFactory.EventEndpoints[region]; + + return new LogEvent(endpoint, impressionParams, HTTP_VERB, HTTP_HEADERS); } @@ -271,7 +272,11 @@ public virtual LogEvent CreateConversionEvent(ProjectConfig config, string event var conversionParams = GetImpressionOrConversionParamsWithCommonParams(commonParams, conversionOnlyParams); - return new LogEvent(CONVERSION_ENDPOINT, conversionParams, HTTP_VERB, HTTP_HEADERS); + var region = !string.IsNullOrEmpty(config.Region) && EventFactory.EventEndpoints.ContainsKey(config.Region) ? config.Region : "US"; + + var endpoint = EventFactory.EventEndpoints[region]; + + return new LogEvent(endpoint, conversionParams, HTTP_VERB, HTTP_HEADERS); } } } diff --git a/OptimizelySDK/Event/Entity/EventContext.cs b/OptimizelySDK/Event/Entity/EventContext.cs index 44b776442..718deba61 100644 --- a/OptimizelySDK/Event/Entity/EventContext.cs +++ b/OptimizelySDK/Event/Entity/EventContext.cs @@ -41,6 +41,9 @@ public class EventContext [JsonProperty("anonymize_ip")] public bool AnonymizeIP { get; protected set; } + [JsonProperty("region")] + public string Region { get; protected set; } + /// /// EventContext builder /// @@ -50,6 +53,7 @@ public class Builder private string ProjectId; private string Revision; private bool AnonymizeIP; + private string Region; public Builder WithAccountId(string accountId) { @@ -75,6 +79,12 @@ public Builder WithAnonymizeIP(bool anonymizeIP) return this; } + public Builder WithRegion(string region) + { + Region = region; + return this; + } + /// /// Build EventContext instance /// @@ -89,6 +99,7 @@ public EventContext Build() eventContext.ClientName = Optimizely.SDK_TYPE; eventContext.ClientVersion = Optimizely.SDK_VERSION; eventContext.AnonymizeIP = AnonymizeIP; + eventContext.Region = Region; return eventContext; } diff --git a/OptimizelySDK/Event/Entity/ImpressionEvent.cs b/OptimizelySDK/Event/Entity/ImpressionEvent.cs index 12949ea6c..0e5d01526 100644 --- a/OptimizelySDK/Event/Entity/ImpressionEvent.cs +++ b/OptimizelySDK/Event/Entity/ImpressionEvent.cs @@ -28,7 +28,7 @@ public class ImpressionEvent : UserEvent public string UserId { get; private set; } public VisitorAttribute[] VisitorAttributes { get; private set; } - public Experiment Experiment { get; set; } + public ExperimentCore Experiment { get; set; } public DecisionMetadata Metadata { get; set; } public Variation Variation { get; set; } public bool? BotFiltering { get; set; } @@ -42,7 +42,7 @@ public class Builder private EventContext EventContext; public VisitorAttribute[] VisitorAttributes; - private Experiment Experiment; + private ExperimentCore Experiment; private Variation Variation; private DecisionMetadata Metadata; private bool? BotFiltering; @@ -61,7 +61,7 @@ public Builder WithEventContext(EventContext eventContext) return this; } - public Builder WithExperiment(Experiment experiment) + public Builder WithExperiment(ExperimentCore experiment) { Experiment = experiment; diff --git a/OptimizelySDK/Event/EventFactory.cs b/OptimizelySDK/Event/EventFactory.cs index 841b650ff..771e0f392 100644 --- a/OptimizelySDK/Event/EventFactory.cs +++ b/OptimizelySDK/Event/EventFactory.cs @@ -34,9 +34,15 @@ public class EventFactory { private const string CUSTOM_ATTRIBUTE_FEATURE_TYPE = "custom"; - public const string - EVENT_ENDPOINT = - "https://logx.optimizely.com/v1/events"; // Should be part of the datafile + // Supported regions for event endpoints + public static string[] SupportedRegions => EventEndpoints.Keys.ToArray(); + + // Dictionary of event endpoints for different regions + public static readonly Dictionary EventEndpoints = new Dictionary + { + {"US", "https://logx.optimizely.com/v1/events"}, + {"EU", "https://eu.logx.optimizely.com/v1/events"} + }; private const string ACTIVATE_EVENT_KEY = "campaign_activated"; @@ -63,6 +69,9 @@ public static LogEvent CreateLogEvent(UserEvent[] userEvents, ILogger logger) var visitors = new List(userEvents.Count()); + // Default to US region + string region = "US"; + foreach (var userEvent in userEvents) { if (userEvent is ImpressionEvent) @@ -81,6 +90,12 @@ public static LogEvent CreateLogEvent(UserEvent[] userEvents, ILogger logger) var userContext = userEvent.Context; + // Get region from the event's context, default to US if not specified + if (!string.IsNullOrEmpty(userContext.Region)) + { + region = userContext.Region; + } + builder.WithClientName(userContext.ClientName). WithClientVersion(userContext.ClientVersion). WithAccountId(userContext.AccountId). @@ -102,7 +117,16 @@ public static LogEvent CreateLogEvent(UserEvent[] userEvents, ILogger logger) var eventBatchDictionary = JObject.FromObject(eventBatch).ToObject>(); - return new LogEvent(EVENT_ENDPOINT, eventBatchDictionary, "POST", + // Use the region to determine the endpoint URL, falling back to US if the region is not found or not supported + string endpointUrl = EventEndpoints["US"]; // Default to US endpoint + + // Only try to use the region-specific endpoint if it's a supported region + if (SupportedRegions.Contains(region) && EventEndpoints.ContainsKey(region)) + { + endpointUrl = EventEndpoints[region]; + } + + return new LogEvent(endpointUrl, eventBatchDictionary, "POST", new Dictionary { { "Content-Type", "application/json" }, diff --git a/OptimizelySDK/Event/UserEventFactory.cs b/OptimizelySDK/Event/UserEventFactory.cs index f073237a8..adb9c87b8 100644 --- a/OptimizelySDK/Event/UserEventFactory.cs +++ b/OptimizelySDK/Event/UserEventFactory.cs @@ -61,7 +61,7 @@ public static ImpressionEvent CreateImpressionEvent(ProjectConfig projectConfig, /// experiment or featureDecision source /// ImpressionEvent instance public static ImpressionEvent CreateImpressionEvent(ProjectConfig projectConfig, - Experiment activatedExperiment, + ExperimentCore activatedExperiment, Variation variation, string userId, UserAttributes userAttributes, @@ -80,6 +80,7 @@ public static ImpressionEvent CreateImpressionEvent(ProjectConfig projectConfig, WithAccountId(projectConfig.AccountId). WithAnonymizeIP(projectConfig.AnonymizeIP). WithRevision(projectConfig.Revision). + WithRegion(projectConfig.Region). Build(); var variationKey = ""; @@ -123,6 +124,7 @@ EventTags eventTags WithAccountId(projectConfig.AccountId). WithAnonymizeIP(projectConfig.AnonymizeIP). WithRevision(projectConfig.Revision). + WithRegion(projectConfig.Region). Build(); return new ConversionEvent.Builder(). diff --git a/OptimizelySDK/Exceptions/OptimizelyException.cs b/OptimizelySDK/Exceptions/OptimizelyException.cs index ad9cf4d59..2d6ec0d80 100644 --- a/OptimizelySDK/Exceptions/OptimizelyException.cs +++ b/OptimizelySDK/Exceptions/OptimizelyException.cs @@ -85,6 +85,33 @@ public InvalidFeatureException(string message) : base(message) { } } + /// + /// Base exception for CMAB client errors. + /// + public class CmabException : OptimizelyException + { + public CmabException(string message) + : base(message) { } + } + + /// + /// Exception thrown when CMAB decision fetch fails (network/non-2xx/exhausted retries). + /// + public class CmabFetchException : CmabException + { + public CmabFetchException(string message) + : base(message) { } + } + + /// + /// Exception thrown when CMAB response is invalid or cannot be parsed. + /// + public class CmabInvalidResponseException : CmabException + { + public CmabInvalidResponseException(string message) + : base(message) { } + } + public class InvalidRolloutException : OptimizelyException { public InvalidRolloutException(string message) @@ -102,4 +129,10 @@ public class ParseException : OptimizelyException public ParseException(string message) : base(message) { } } + public class InvalidHoldoutException : OptimizelyException + { + public InvalidHoldoutException(string message) + : base(message) { } + } } + diff --git a/OptimizelySDK/Odp/LruCache.cs b/OptimizelySDK/Odp/LruCache.cs index bf1af65a6..45b9be5d4 100644 --- a/OptimizelySDK/Odp/LruCache.cs +++ b/OptimizelySDK/Odp/LruCache.cs @@ -165,6 +165,18 @@ public void Reset() } } + /// + /// Remove the element associated with the provided key from the cache + /// + /// Key of element to remove from the cache + public void Remove(string key) + { + lock (_mutex) + { + _cache.Remove(key); + } + } + /// /// Wrapping class around a generic value stored in the cache /// diff --git a/OptimizelySDK/Optimizely.cs b/OptimizelySDK/Optimizely.cs index 9da300f85..4e0a0bce2 100644 --- a/OptimizelySDK/Optimizely.cs +++ b/OptimizelySDK/Optimizely.cs @@ -1,5 +1,5 @@ /* - * Copyright 2017-2023, Optimizely + * Copyright 2017-2024, Optimizely * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use file except in compliance with the License. @@ -564,7 +564,8 @@ public virtual bool IsFeatureEnabled(string featureKey, string userId, // This information is only necessary for feature tests. // For rollouts experiments and variations are an implementation detail only. - if (decision?.Source == FeatureDecision.DECISION_SOURCE_FEATURE_TEST) + if (decision?.Source == FeatureDecision.DECISION_SOURCE_FEATURE_TEST || + decision?.Source == FeatureDecision.DECISION_SOURCE_HOLDOUT) { decisionSource = decision.Source; sourceInfo["experimentKey"] = decision.Experiment.Key; @@ -573,8 +574,7 @@ public virtual bool IsFeatureEnabled(string featureKey, string userId, else { Logger.Log(LogLevel.INFO, - $@"The user ""{userId}"" is not being experimented on feature ""{featureKey - }""."); + $@"The user ""{userId}"" is not being experimented on feature ""{featureKey}""."); } } @@ -624,8 +624,7 @@ public virtual T GetFeatureVariableValueForType(string featureKey, string var if (config == null) { Logger.Log(LogLevel.ERROR, - $@"Datafile has invalid format. Failing '{ - FeatureVariable.GetFeatureVariableTypeName(variableType)}'."); + $@"Datafile has invalid format. Failing '{FeatureVariable.GetFeatureVariableTypeName(variableType)}'."); return default; } @@ -649,15 +648,13 @@ public virtual T GetFeatureVariableValueForType(string featureKey, string var if (featureVariable == null) { Logger.Log(LogLevel.ERROR, - $@"No feature variable was found for key ""{variableKey}"" in feature flag ""{ - featureKey}""."); + $@"No feature variable was found for key ""{variableKey}"" in feature flag ""{featureKey}""."); return default; } else if (featureVariable.Type != variableType) { Logger.Log(LogLevel.ERROR, - $@"Variable is of type ""{featureVariable.Type - }"", but you requested it as type ""{variableType}""."); + $@"Variable is of type ""{featureVariable.Type}"", but you requested it as type ""{variableType}""."); return default; } @@ -681,28 +678,24 @@ public virtual T GetFeatureVariableValueForType(string featureKey, string var { variableValue = featureVariableUsageInstance.Value; Logger.Log(LogLevel.INFO, - $@"Got variable value ""{variableValue}"" for variable ""{variableKey - }"" of feature flag ""{featureKey}""."); + $@"Got variable value ""{variableValue}"" for variable ""{variableKey}"" of feature flag ""{featureKey}""."); } else { Logger.Log(LogLevel.INFO, - $@"Feature ""{featureKey}"" is not enabled for user {userId - }. Returning the default variable value ""{variableValue}""."); + $@"Feature ""{featureKey}"" is not enabled for user {userId}. Returning the default variable value ""{variableValue}""."); } } else { Logger.Log(LogLevel.INFO, - $@"Variable ""{variableKey}"" is not used in variation ""{variation.Key - }"", returning default value ""{variableValue}""."); + $@"Variable ""{variableKey}"" is not used in variation ""{variation.Key}"", returning default value ""{variableValue}""."); } } else { Logger.Log(LogLevel.INFO, - $@"User ""{userId}"" is not in any variation for feature flag ""{featureKey - }"", returning default value ""{variableValue}""."); + $@"User ""{userId}"" is not in any variation for feature flag ""{featureKey}"", returning default value ""{variableValue}""."); } var sourceInfo = new Dictionary(); @@ -861,6 +854,7 @@ private OptimizelyUserContext CreateUserContextCopy(string userId, ///
  • If the SDK finds an error, it’ll return a decision with null for variationKey. The decision will include an error message in reasons. /// ///
    • + /// User context to be used to make decision. /// A flag key for which a decision will be made. /// A list of options for decision-making. /// A decision result. @@ -879,194 +873,256 @@ OptimizelyDecideOption[] options if (key == null) { - return OptimizelyDecision.NewErrorDecision(key, - user, - DecisionMessage.Reason(DecisionMessage.FLAG_KEY_INVALID, key), + return OptimizelyDecision.NewErrorDecision(key, user, + DecisionMessage.Reason(DecisionMessage.FLAG_KEY_INVALID, "null"), ErrorHandler, Logger); } - var flag = config.GetFeatureFlagFromKey(key); - if (flag.Key == null) + var allOptions = GetAllOptions(options). + Where(opt => opt != OptimizelyDecideOption.ENABLED_FLAGS_ONLY). + ToArray(); + + return DecideForKeys(user, new[] { key }, allOptions, true)[key]; + } + + internal Dictionary DecideAll(OptimizelyUserContext user, + OptimizelyDecideOption[] options + ) + { + var decisionMap = new Dictionary(); + + var projectConfig = ProjectConfigManager?.GetConfig(); + if (projectConfig == null) { - return OptimizelyDecision.NewErrorDecision(key, - user, - DecisionMessage.Reason(DecisionMessage.FLAG_KEY_INVALID, key), - ErrorHandler, Logger); + Logger.Log(LogLevel.ERROR, + "Optimizely instance is not valid, failing DecideAll call."); + return decisionMap; } - var userId = user?.GetUserId(); - var userAttributes = user?.GetAttributes(); - var decisionEventDispatched = false; - var allOptions = GetAllOptions(options); - var decisionReasons = new DecisionReasons(); - FeatureDecision decision = null; + var allFlags = projectConfig.FeatureFlags; + var allFlagKeys = allFlags.Select(v => v.Key).ToArray(); + + return DecideForKeys(user, allFlagKeys, options); + } - var decisionContext = new OptimizelyDecisionContext(flag.Key); - var forcedDecisionVariation = - DecisionService.ValidatedForcedDecision(decisionContext, config, user); - decisionReasons += forcedDecisionVariation.DecisionReasons; + internal Dictionary DecideForKeys(OptimizelyUserContext user, + string[] keys, + OptimizelyDecideOption[] options, + bool ignoreDefaultOptions = false + ) + { + var decisionDictionary = new Dictionary(); - if (forcedDecisionVariation.ResultObject != null) + var projectConfig = ProjectConfigManager?.GetConfig(); + if (projectConfig == null) { - decision = new FeatureDecision(null, forcedDecisionVariation.ResultObject, - FeatureDecision.DECISION_SOURCE_FEATURE_TEST); + Logger.Log(LogLevel.ERROR, + "Optimizely instance is not valid, failing DecideForKeys call."); + return decisionDictionary; } - else + + if (keys.Length == 0) { - var flagDecisionResult = DecisionService.GetVariationForFeature( - flag, - user, - config, - userAttributes, - allOptions - ); - decisionReasons += flagDecisionResult.DecisionReasons; - decision = flagDecisionResult.ResultObject; + return decisionDictionary; } - var featureEnabled = false; + var allOptions = ignoreDefaultOptions ? options : GetAllOptions(options); - if (decision?.Variation != null) + var flagDecisions = new Dictionary(); + var decisionReasonsMap = new Dictionary(); + + var flagsWithoutForcedDecisions = new List(); + + var validKeys = new List(); + + foreach (var key in keys) { - featureEnabled = decision.Variation.FeatureEnabled.GetValueOrDefault(); + var flag = projectConfig.GetFeatureFlagFromKey(key); + if (flag.Key == null) + { + decisionDictionary.Add(key, + OptimizelyDecision.NewErrorDecision(key, user, + DecisionMessage.Reason(DecisionMessage.FLAG_KEY_INVALID, key), + ErrorHandler, Logger)); + continue; + } + + validKeys.Add(key); + + var decisionReasons = new DecisionReasons(); + decisionReasonsMap.Add(key, decisionReasons); + + var optimizelyDecisionContext = new OptimizelyDecisionContext(key); + var forcedDecisionVariation = + DecisionService.ValidatedForcedDecision(optimizelyDecisionContext, projectConfig, user); + decisionReasons += forcedDecisionVariation.DecisionReasons; + + if (forcedDecisionVariation.ResultObject != null) + { + flagDecisions.Add(key, new FeatureDecision(null, + forcedDecisionVariation.ResultObject, + FeatureDecision.DECISION_SOURCE_FEATURE_TEST)); + } + else + { + flagsWithoutForcedDecisions.Add(flag); + } } - if (featureEnabled) + var decisionsList = DecisionService.GetVariationsForFeatureList( + flagsWithoutForcedDecisions, user, projectConfig, user.GetAttributes(), + allOptions); + + for (var i = 0; i < decisionsList.Count; i += 1) { - Logger.Log(LogLevel.INFO, - "Feature \"" + key + "\" is enabled for user \"" + userId + "\""); + var decision = decisionsList[i]; + var flagKey = flagsWithoutForcedDecisions[i].Key; + flagDecisions.Add(flagKey, decision.ResultObject); + decisionReasonsMap[flagKey] += decision.DecisionReasons; } - else + + foreach (var key in validKeys) { - Logger.Log(LogLevel.INFO, - "Feature \"" + key + "\" is not enabled for user \"" + userId + "\""); + var flagDecision = flagDecisions[key]; + var decisionReasons = decisionReasonsMap[key]; + + var optimizelyDecision = CreateOptimizelyDecision(user, key, flagDecision, + decisionReasons, allOptions.ToList(), projectConfig); + if (!allOptions.Contains(OptimizelyDecideOption.ENABLED_FLAGS_ONLY) || + optimizelyDecision.Enabled) + { + decisionDictionary.Add(key, optimizelyDecision); + } } - var variableMap = new Dictionary(); - if (flag?.Variables != null && - !allOptions.Contains(OptimizelyDecideOption.EXCLUDE_VARIABLES)) + return decisionDictionary; + } + + private OptimizelyDecision CreateOptimizelyDecision( + OptimizelyUserContext user, + string flagKey, + FeatureDecision flagDecision, + DecisionReasons decisionReasons, + List allOptions, + ProjectConfig projectConfig + ) + { + var userId = user.GetUserId(); + string experimentId = null; + string variationId = null; + var flagEnabled = false; + if (flagDecision.Variation != null) { - foreach (var featureVariable in flag?.Variables) + if (flagDecision.Variation.IsFeatureEnabled) { - var variableValue = featureVariable.DefaultValue; - if (featureEnabled) - { - var featureVariableUsageInstance = - decision?.Variation.GetFeatureVariableUsageFromId(featureVariable.Id); - if (featureVariableUsageInstance != null) - { - variableValue = featureVariableUsageInstance.Value; - } - } + flagEnabled = true; + } + variationId = flagDecision.Variation.Id; + } + if (flagDecision.Experiment != null) + { + experimentId = flagDecision.Experiment.Id; + } + Logger.Log(LogLevel.INFO, + $"Feature \"{flagKey}\" is enabled for user \"{userId}\"? {flagEnabled}"); - var typeCastedValue = - GetTypeCastedVariableValue(variableValue, featureVariable.Type); + var variableMap = new Dictionary(); + if (!allOptions.Contains(OptimizelyDecideOption.EXCLUDE_VARIABLES)) + { + var decisionVariables = GetDecisionVariableMap( + projectConfig.GetFeatureFlagFromKey(flagKey), + flagDecision.Variation, + flagEnabled); + variableMap = decisionVariables.ResultObject; + decisionReasons += decisionVariables.DecisionReasons; + } - if (typeCastedValue is OptimizelyJSON) - { - typeCastedValue = ((OptimizelyJSON)typeCastedValue).ToDictionary(); - } + var optimizelyJson = new OptimizelyJSON(variableMap, ErrorHandler, Logger); - variableMap.Add(featureVariable.Key, typeCastedValue); - } + var decisionSource = FeatureDecision.DECISION_SOURCE_ROLLOUT; + if (flagDecision.Source != null) + { + decisionSource = flagDecision.Source; } - var optimizelyJSON = new OptimizelyJSON(variableMap, ErrorHandler, Logger); + var includeReasons = allOptions.Contains(OptimizelyDecideOption.INCLUDE_REASONS); + var reasonsToReport = decisionReasons.ToReport(includeReasons).ToArray(); + var variationKey = flagDecision.Variation?.Key; + // TODO: add ruleKey values when available later. use a copy of experimentKey until then. + // add to event metadata as well (currently set to experimentKey) + var ruleKey = flagDecision.Experiment?.Key; - var decisionSource = decision?.Source ?? FeatureDecision.DECISION_SOURCE_ROLLOUT; + var decisionEventDispatched = false; if (!allOptions.Contains(OptimizelyDecideOption.DISABLE_DECISION_EVENT)) { - decisionEventDispatched = SendImpressionEvent(decision?.Experiment, - decision?.Variation, userId, userAttributes, config, key, decisionSource, - featureEnabled); + decisionEventDispatched = SendImpressionEvent( + flagDecision.Experiment, + flagDecision.Variation, + userId, + user.GetAttributes(), + projectConfig, + flagKey, + decisionSource, + flagEnabled); } - var reasonsToReport = decisionReasons - .ToReport(allOptions.Contains(OptimizelyDecideOption.INCLUDE_REASONS)) - .ToArray(); - var variationKey = decision?.Variation?.Key; - - // TODO: add ruleKey values when available later. use a copy of experimentKey until then. - var ruleKey = decision?.Experiment?.Key; - var decisionInfo = new Dictionary { - { "flagKey", key }, - { "enabled", featureEnabled }, + { "flagKey", flagKey }, + { "enabled", flagEnabled }, { "variables", variableMap }, { "variationKey", variationKey }, { "ruleKey", ruleKey }, { "reasons", reasonsToReport }, { "decisionEventDispatched", decisionEventDispatched }, + { "experimentId", experimentId }, + { "variationId", variationId }, }; NotificationCenter.SendNotifications(NotificationCenter.NotificationType.Decision, - DecisionNotificationTypes.FLAG, userId, - userAttributes ?? new UserAttributes(), decisionInfo); + DecisionNotificationTypes.FLAG, userId, user.GetAttributes(), decisionInfo); return new OptimizelyDecision( variationKey, - featureEnabled, - optimizelyJSON, + flagEnabled, + optimizelyJson, ruleKey, - key, + flagKey, user, reasonsToReport); } - internal Dictionary DecideAll(OptimizelyUserContext user, - OptimizelyDecideOption[] options - ) + private Result> GetDecisionVariableMap(FeatureFlag flag, Variation variation, bool featureEnabled) { - var decisionMap = new Dictionary(); - - var projectConfig = ProjectConfigManager?.GetConfig(); - if (projectConfig == null) - { - Logger.Log(LogLevel.ERROR, - "Optimizely instance is not valid, failing isFeatureEnabled call."); - return decisionMap; - } - - var allFlags = projectConfig.FeatureFlags; - var allFlagKeys = allFlags.Select(v => v.Key).ToArray(); - - return DecideForKeys(user, allFlagKeys, options); - } - - internal Dictionary DecideForKeys(OptimizelyUserContext user, - string[] keys, - OptimizelyDecideOption[] options - ) - { - var decisionDictionary = new Dictionary(); + var reasons = new DecisionReasons(); + var valuesMap = new Dictionary(); - var projectConfig = ProjectConfigManager?.GetConfig(); - if (projectConfig == null) + foreach (var variable in flag.Variables) { - Logger.Log(LogLevel.ERROR, - "Optimizely instance is not valid, failing isFeatureEnabled call."); - return decisionDictionary; - } - - if (keys.Length == 0) - { - return decisionDictionary; - } - - var allOptions = GetAllOptions(options); + var value = variable.DefaultValue; + if (featureEnabled) + { + var instance = variation.GetFeatureVariableUsageFromId(variable.Id); + if (instance != null) + { + value = instance.Value; + } + } - foreach (var key in keys) - { - var decision = Decide(user, key, options); - if (!allOptions.Contains(OptimizelyDecideOption.ENABLED_FLAGS_ONLY) || - decision.Enabled) + var convertedValue = GetTypeCastedVariableValue(value, variable.Type); + if (convertedValue == null) { - decisionDictionary.Add(key, decision); + reasons.AddError(DecisionMessage.Reason(DecisionMessage.VARIABLE_VALUE_INVALID, variable.Key)); } + else if (convertedValue is OptimizelyJSON optimizelyJson) + { + convertedValue = optimizelyJson.ToDictionary(); + } + + valuesMap[variable.Key] = convertedValue; } - return decisionDictionary; + return Result>.NewResult(valuesMap, reasons); } private OptimizelyDecideOption[] GetAllOptions(OptimizelyDecideOption[] options) @@ -1106,12 +1162,12 @@ private void SendImpressionEvent(Experiment experiment, Variation variation, str /// The user's attributes /// It can either be experiment key in case if ruleType is experiment or it's feature key in case ruleType is feature-test or rollout /// It can either be experiment in case impression event is sent from activate or it's feature-test or rollout - private bool SendImpressionEvent(Experiment experiment, Variation variation, string userId, + private bool SendImpressionEvent(ExperimentCore experiment, Variation variation, string userId, UserAttributes userAttributes, ProjectConfig config, string flagKey, string ruleType, bool enabled ) { - if (experiment != null && !experiment.IsExperimentRunning) + if (experiment != null && !experiment.isRunning) { Logger.Log(LogLevel.ERROR, @"Experiment has ""Launched"" status so not dispatching event during activation."); diff --git a/OptimizelySDK/OptimizelySDK.csproj b/OptimizelySDK/OptimizelySDK.csproj index 1812a2adc..ccd53f42f 100644 --- a/OptimizelySDK/OptimizelySDK.csproj +++ b/OptimizelySDK/OptimizelySDK.csproj @@ -75,6 +75,7 @@ + @@ -83,6 +84,9 @@ + + + @@ -170,6 +174,7 @@ + @@ -199,6 +204,11 @@ + + + + + diff --git a/OptimizelySDK/ProjectConfig.cs b/OptimizelySDK/ProjectConfig.cs index 58272aa72..28f63d24d 100644 --- a/OptimizelySDK/ProjectConfig.cs +++ b/OptimizelySDK/ProjectConfig.cs @@ -113,6 +113,11 @@ public interface ProjectConfig /// Dictionary AttributeKeyMap { get; } + /// + /// Associative array of attribute ID to Attribute(s) in the datafile + /// + Dictionary AttributeIdMap { get; } + /// /// Associative array of audience ID to Audience(s) in the datafile /// @@ -175,6 +180,11 @@ public interface ProjectConfig /// Rollout[] Rollouts { get; set; } + /// + /// Associative list of Holdouts. + /// + Holdout[] Holdouts { get; set; } + /// /// Associative list of Integrations. /// @@ -229,6 +239,13 @@ public interface ProjectConfig /// Attribute Entity corresponding to the key or a dummy entity if key is invalid Attribute GetAttribute(string attributeKey); + /// + /// Get the Attribute from the ID + /// + /// ID of the Attribute + /// Attribute Entity corresponding to the ID or a dummy entity if ID is invalid + Attribute GetAttributeById(string attributeId); + /// /// Get the Variation from the keys /// @@ -308,9 +325,28 @@ public interface ProjectConfig /// List| Feature flag ids list, null otherwise List GetExperimentFeatureList(string experimentId); + /// + /// Get the holdout from the ID + /// + /// ID for holdout + /// Holdout Entity corresponding to the holdout ID or null if ID is invalid + Holdout GetHoldout(string holdoutId); + + /// + /// Get holdout instances associated with the given feature flag Id. + /// + /// Feature flag Id + /// Array of holdouts associated with the flag, empty array if none + Holdout[] GetHoldoutsForFlag(string flagId); + /// /// Returns the datafile corresponding to ProjectConfig /// string ToDatafile(); + + /// + /// Returns the datafile region to ProjectConfig + /// + string Region { get; set; } } } diff --git a/OptimizelySDK/Properties/AssemblyInfo.cs b/OptimizelySDK/Properties/AssemblyInfo.cs index 07e29d0ab..96d048676 100644 --- a/OptimizelySDK/Properties/AssemblyInfo.cs +++ b/OptimizelySDK/Properties/AssemblyInfo.cs @@ -41,6 +41,6 @@ // // You can specify all the values or you can default the Build and Revision Numbers // by using the '*' as shown below: -[assembly: AssemblyVersion("4.0.0.0")] -[assembly: AssemblyFileVersion("4.0.0.0")] -[assembly: AssemblyInformationalVersion("4.0.0-beta")] // Used by Nuget. +[assembly: AssemblyVersion("4.1.0.0")] +[assembly: AssemblyFileVersion("4.1.0.0")] +[assembly: AssemblyInformationalVersion("4.1.0")] // Used by NuGet. diff --git a/OptimizelySDK/Utils/ConfigParser.cs b/OptimizelySDK/Utils/ConfigParser.cs index 318ff1b6e..c6b869167 100644 --- a/OptimizelySDK/Utils/ConfigParser.cs +++ b/OptimizelySDK/Utils/ConfigParser.cs @@ -33,7 +33,13 @@ public static Dictionary GenerateMap(IEnumerable entities, Func getKey, bool clone ) { - return entities.ToDictionary(e => getKey(e), e => clone ? (T)e.Clone() : e); + var dictionary = new Dictionary(); + foreach (var entity in entities) + { + var key = getKey(entity); + dictionary[key] = clone ? (T)entity.Clone() : entity; + } + return dictionary; } } } diff --git a/OptimizelySDK/Utils/ExperimentUtils.cs b/OptimizelySDK/Utils/ExperimentUtils.cs index c87cebbf6..8ee5fab53 100644 --- a/OptimizelySDK/Utils/ExperimentUtils.cs +++ b/OptimizelySDK/Utils/ExperimentUtils.cs @@ -25,7 +25,7 @@ public class ExperimentUtils { public static bool IsExperimentActive(Experiment experiment, ILogger logger) { - if (!experiment.IsExperimentRunning) + if (!experiment.isRunning) { logger.Log(LogLevel.INFO, $"Experiment \"{experiment.Key}\" is not running."); @@ -46,7 +46,7 @@ public static bool IsExperimentActive(Experiment experiment, ILogger logger) /// Custom logger implementation to record log outputs /// true if the user meets audience conditions to be in experiment, false otherwise. public static Result DoesUserMeetAudienceConditions(ProjectConfig config, - Experiment experiment, + ExperimentCore experiment, OptimizelyUserContext user, string loggingKeyType, string loggingKey, @@ -64,15 +64,13 @@ ILogger logger { expConditions = experiment.AudienceConditionsList; logger.Log(LogLevel.DEBUG, - $@"Evaluating audiences for {loggingKeyType} ""{loggingKey}"": { - experiment.AudienceConditionsString}."); + $@"Evaluating audiences for {loggingKeyType} ""{loggingKey}"": {experiment.AudienceConditionsString}."); } else { expConditions = experiment.AudienceIdsList; logger.Log(LogLevel.DEBUG, - $@"Evaluating audiences for {loggingKeyType} ""{loggingKey}"": { - experiment.AudienceIdsString}."); + $@"Evaluating audiences for {loggingKeyType} ""{loggingKey}"": {experiment.AudienceIdsString}."); } // If there are no audiences, return true because that means ALL users are included in the experiment. @@ -84,8 +82,7 @@ ILogger logger var result = expConditions.Evaluate(config, user, logger).GetValueOrDefault(); var resultText = result.ToString().ToUpper(); logger.Log(LogLevel.INFO, - reasons.AddInfo($@"Audiences for {loggingKeyType} ""{loggingKey - }"" collectively evaluated to {resultText}")); + reasons.AddInfo($@"Audiences for {loggingKeyType} ""{loggingKey}"" collectively evaluated to {resultText}")); return Result.NewResult(result, reasons); } } diff --git a/OptimizelySDK/Utils/HoldoutConfig.cs b/OptimizelySDK/Utils/HoldoutConfig.cs new file mode 100644 index 000000000..6b717af2a --- /dev/null +++ b/OptimizelySDK/Utils/HoldoutConfig.cs @@ -0,0 +1,193 @@ +/* + * Copyright 2025, Optimizely + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +using System.Collections.Generic; +using System.Linq; +using OptimizelySDK.Entity; + +namespace OptimizelySDK.Utils +{ + /// + /// Configuration manager for holdouts, providing flag-to-holdout relationship mapping and optimization logic. + /// + public class HoldoutConfig + { + private List _allHoldouts; + private readonly List _globalHoldouts; + private readonly Dictionary _holdoutIdMap; + private readonly Dictionary> _includedHoldouts; + private readonly Dictionary> _excludedHoldouts; + private readonly Dictionary> _flagHoldoutCache; + + /// + /// Initializes a new instance of the HoldoutConfig class. + /// + /// Array of all holdouts from the datafile + public HoldoutConfig(Holdout[] allHoldouts = null) + { + _allHoldouts = allHoldouts?.ToList() ?? new List(); + _globalHoldouts = new List(); + _holdoutIdMap = new Dictionary(); + _includedHoldouts = new Dictionary>(); + _excludedHoldouts = new Dictionary>(); + _flagHoldoutCache = new Dictionary>(); + + UpdateHoldoutMapping(); + } + + /// + /// Gets a read-only dictionary mapping holdout IDs to holdout instances. + /// + public IDictionary HoldoutIdMap => _holdoutIdMap; + + /// + /// Updates internal mappings of holdouts including the id map, global list, and per-flag inclusion/exclusion maps. + /// + private void UpdateHoldoutMapping() + { + // Clear existing mappings + _holdoutIdMap.Clear(); + _globalHoldouts.Clear(); + _includedHoldouts.Clear(); + _excludedHoldouts.Clear(); + _flagHoldoutCache.Clear(); + + foreach (var holdout in _allHoldouts) + { + // Build ID mapping + _holdoutIdMap[holdout.Id] = holdout; + + var hasIncludedFlags = holdout.IncludedFlags != null && holdout.IncludedFlags.Length > 0; + var hasExcludedFlags = holdout.ExcludedFlags != null && holdout.ExcludedFlags.Length > 0; + + if (hasIncludedFlags) + { + // Local/targeted holdout - only applies to specific included flags + foreach (var flagId in holdout.IncludedFlags) + { + if (!_includedHoldouts.ContainsKey(flagId)) + _includedHoldouts[flagId] = new List(); + + _includedHoldouts[flagId].Add(holdout); + } + } + else + { + // Global holdout (applies to all flags) + _globalHoldouts.Add(holdout); + + // If it has excluded flags, track which flags to exclude it from + if (hasExcludedFlags) + { + foreach (var flagId in holdout.ExcludedFlags) + { + if (!_excludedHoldouts.ContainsKey(flagId)) + _excludedHoldouts[flagId] = new List(); + + _excludedHoldouts[flagId].Add(holdout); + } + } + } + } + } + + /// + /// Returns the applicable holdouts for the given flag ID by combining global holdouts (excluding any specified) and included holdouts, in that order. + /// Caches the result for future calls. + /// + /// The flag identifier + /// A list of Holdout objects relevant to the given flag + public List GetHoldoutsForFlag(string flagId) + { + if (string.IsNullOrEmpty(flagId) || _allHoldouts.Count == 0) + return new List(); + + // Check cache first + if (_flagHoldoutCache.ContainsKey(flagId)) + return _flagHoldoutCache[flagId]; + + var activeHoldouts = new List(); + // Start with global holdouts, excluding any that are specifically excluded for this flag + var excludedForFlag = _excludedHoldouts.ContainsKey(flagId) ? _excludedHoldouts[flagId] : new List(); + + if (excludedForFlag.Count > 0) + { + // Only iterate if we have exclusions to check + foreach (var globalHoldout in _globalHoldouts) + { + if (!excludedForFlag.Contains(globalHoldout)) + { + activeHoldouts.Add(globalHoldout); + } + } + } + else + { + // No exclusions, add all global holdouts directly + activeHoldouts.AddRange(_globalHoldouts); + } + + // Add included holdouts for this flag + if (_includedHoldouts.ContainsKey(flagId)) + { + activeHoldouts.AddRange(_includedHoldouts[flagId]); + } + + // Cache the result + _flagHoldoutCache[flagId] = activeHoldouts; + + return activeHoldouts; + } + + /// + /// Get a Holdout object for an ID. + /// + /// The holdout identifier + /// The Holdout object if found, null otherwise + public Holdout GetHoldout(string holdoutId) + { + if (string.IsNullOrEmpty(holdoutId)) + { + return null; + } + + _holdoutIdMap.TryGetValue(holdoutId, out var holdout); + + return holdout; + } + + /// + /// Gets the total number of holdouts. + /// + public int HoldoutCount => _allHoldouts.Count; + + /// + /// Gets the number of global holdouts. + /// + public int GlobalHoldoutCount => _globalHoldouts.Count; + + /// + /// Updates the holdout configuration with a new set of holdouts. + /// This method is useful for testing or when the holdout configuration needs to be updated at runtime. + /// + /// The new array of holdouts to use + public void UpdateHoldoutMapping(Holdout[] newHoldouts) + { + _allHoldouts = newHoldouts?.ToList() ?? new List(); + UpdateHoldoutMapping(); + } + } +} diff --git a/OptimizelySDK/Utils/schema.json b/OptimizelySDK/Utils/schema.json index c434bbac5..dd3fedefd 100644 --- a/OptimizelySDK/Utils/schema.json +++ b/OptimizelySDK/Utils/schema.json @@ -182,6 +182,20 @@ }, "forcedVariations": { "type": "object" + }, + "cmab": { + "type": "object", + "properties": { + "attributeIds": { + "type": "array", + "items": { + "type": "string" + } + }, + "trafficAllocation": { + "type": "integer" + } + } } }, "required": [ @@ -279,4 +293,4 @@ "version", "revision" ] -} \ No newline at end of file +} diff --git a/README.md b/README.md index eb0da22ce..9de4ddc76 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # Optimizely C# SDK ![Semantic](https://img.shields.io/badge/sem-ver-lightgrey.svg?style=plastic) -[![Build Status](https://travis-ci.org/optimizely/csharp-sdk.svg?branch=master)](https://travis-ci.org/optimizely/csharp-sdk) +![CI](https://github.com/optimizely/csharp-sdk/actions/workflows/csharp.yml/badge.svg?branch=master) [![NuGet](https://img.shields.io/nuget/v/Optimizely.SDK.svg?style=plastic)](https://www.nuget.org/packages/Optimizely.SDK/) [![Apache 2.0](https://img.shields.io/github/license/nebula-plugins/gradle-extra-configurations-plugin.svg)](http://www.apache.org/licenses/LICENSE-2.0) @@ -104,7 +104,7 @@ User can provide variables using following procedure: ```
    + type="OptimizelySDK.OptimizelySDKConfigSection, OptimizelySDK, Version=4.1.0.0, Culture=neutral, PublicKeyToken=null" /> ``` 2. Now add **optlySDKConfigSection** below ****. In this section you can add and set following **HttpProjectConfigManager** and **BatchEventProcessor** variables: @@ -251,4 +251,4 @@ Optimizely SDK uses third party software: - Ruby - https://github.com/optimizely/ruby-sdk -- Swift - https://github.com/optimizely/swift-sdk \ No newline at end of file +- Swift - https://github.com/optimizely/swift-sdk