fix(resolver): bucket-match materialized assignments with duplicate variants (#345)

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: nicklasl

confidence-resolver/src/lib.rs

@@ -676,6 +676,8 @@ impl MaterializationContext {
         unit: &str,
         rule: &str,
         assignments: &'b [rule::Assignment],
+        segment_name: &str,
+        bucket_count: i32,
     ) -> Option<&'b rule::Assignment> {
         let records = match &self.records {
             MaterializationRecords::Complete(records) => records,
@@ -690,12 +692,29 @@ impl MaterializationContext {
         }
 
         let variant = &record.variant;
-        assignments.iter().find(|assignment| {
-            matches!(
-                &assignment.assignment,
-                Some(Assignment::Variant(VariantAssignment { variant: v }))
-                    if variant == v
-            )
+        let matching: Vec<_> = assignments
+            .iter()
+            .filter(|assignment| {
+                matches!(
+                    &assignment.assignment,
+                    Some(Assignment::Variant(VariantAssignment { variant: v }))
+                        if variant == v
+                )
+            })
+            .collect();
+
+        if matching.len() <= 1 {
+            return matching.into_iter().next();
+        }
+
+        let variant_salt = segment_name.split('/').nth(1)?;
+        let key = format!("{}|{}", variant_salt, unit);
+        let b = bucket(hash(&key), bucket_count as u64).ok()? as i32;
+        matching.into_iter().find(|assignment| {
+            assignment
+                .bucket_ranges
+                .iter()
+                .any(|range| range.lower <= b && b < range.upper)
         })
     }
 
@@ -1153,6 +1172,8 @@ impl<'a, H: Host> AccountResolver<'a, H> {
                                     unit_str,
                                     &rule.name,
                                     &spec.assignments,
+                                    segment_name,
+                                    spec.bucket_count,
                                 ) {
                                     return resolved_value.try_with_variant_match(
                                         rule, segment, assignment, unit_str,

confidence-resolver/src/resolver_spec_tests.rs

@@ -131,6 +131,7 @@ struct SpecResolvedFlag {
     variant: String,
     value: Option<serde_json::Value>,
     should_apply: Option<bool>,
+    assignment_id: Option<String>,
 }
 
 // ---------------------------------------------------------------------------
@@ -459,6 +460,37 @@ fn run_spec_test(state: &ResolverState, test_case: &SpecTestCase) {
                 test_case.name, expected_flag.flag, expected_should_apply, actual_should_apply,
             );
         }
+
+        // assignmentId assertion (from resolve token)
+        if let Some(expected_assignment_id) = &expected_flag.assignment_id {
+            let token = resolver
+                .decrypt_resolve_token(&resolve_response.resolve_token)
+                .unwrap_or_else(|e| {
+                    panic!(
+                        "[{}] Failed to decrypt resolve token: {}",
+                        test_case.name, e,
+                    )
+                });
+            match token.resolve_token {
+                Some(flags_resolver::resolve_token::ResolveToken::TokenV1(token_v1)) => {
+                    let assigned = token_v1
+                        .assignments
+                        .get(&expected_flag.flag)
+                        .unwrap_or_else(|| {
+                            panic!(
+                                "[{}] Flag '{}' not found in resolve token assignments",
+                                test_case.name, expected_flag.flag,
+                            )
+                        });
+                    assert_eq!(
+                        &assigned.assignment_id, expected_assignment_id,
+                        "[{}] assignmentId mismatch for flag '{}'",
+                        test_case.name, expected_flag.flag,
+                    );
+                }
+                _ => panic!("[{}] Expected TokenV1 in resolve token", test_case.name,),
+            }
+        }
     }
 }
 
@@ -685,3 +717,6 @@ spec_test!(combined_both_match);
 spec_test!(combined_only_attr);
 spec_test!(combined_only_mat);
 spec_test!(combined_neither);
+
+// Materialization: duplicate variant assignments
+spec_test!(mat_same_variant_two_assignments_returns_correct_assignment_id);

confidence-resolver/test-payloads/resolver-spec/state.json

@@ -2136,6 +2136,41 @@
           }
         }
       ]
+    },
+    "flags/mat-same-variant-flag": {
+      "name": "flags/mat-same-variant-flag",
+      "state": "ACTIVE",
+      "clients": ["clients/test-client"],
+      "variants": [
+        { "name": "on", "value": { "enabled": true } }
+      ],
+      "rules": [
+        {
+          "name": "flags/mat-same-variant-flag/rules/rule1",
+          "segment": "segments/country-se",
+          "enabled": true,
+          "targetingKeySelector": "targeting_key",
+          "materializationSpec": {
+            "readMaterialization": "materializations/mat1",
+            "writeMaterialization": "materializations/mat1"
+          },
+          "assignmentSpec": {
+            "bucketCount": 1000,
+            "assignments": [
+              {
+                "assignmentId": "a1",
+                "variant": { "variant": "on" },
+                "bucketRanges": [{ "lower": 0, "upper": 500 }]
+              },
+              {
+                "assignmentId": "a2",
+                "variant": { "variant": "on" },
+                "bucketRanges": [{ "lower": 500, "upper": 1000 }]
+              }
+            ]
+          }
+        }
+      ]
     }
   },
   "segments": {

confidence-resolver/test-payloads/resolver-spec/tests.json

@@ -4057,5 +4057,38 @@
         "expectError": null
       }
     }
+  },
+  {
+    "name": "mat_same_variant_two_assignments_returns_correct_assignment_id",
+    "resolveRequest": {
+      "flags": ["flags/mat-same-variant-flag"],
+      "evaluationContext": { "targeting_key": "user1", "country": "SE" },
+      "clientSecret": "test-secret"
+    },
+    "materializations": {
+      "user1": {
+        "materializations/mat1": {
+          "isUnitInMaterialization": true,
+          "ruleToVariant": {
+            "flags/mat-same-variant-flag/rules/rule1": "on"
+          }
+        }
+      }
+    },
+    "expectedResult": {
+      "general": {
+        "resolvedFlags": [
+          {
+            "flag": "flags/mat-same-variant-flag",
+            "reason": "RESOLVE_REASON_MATCH",
+            "variant": "on",
+            "value": { "enabled": true },
+            "shouldApply": true,
+            "assignmentId": "a2"
+          }
+        ],
+        "expectError": null
+      }
+    }
   }
 ]