FAILURE MAP
← Case archive

FA-73956 / Feature flag rollout bucketing / Open access

Segment membership precedence: List attributes are compared as a whole · case 01

Users whose groups attribute is a list never match group clauses.

Verified by executionVariant 1 · 8 checks per implementationDownload source bundle ↓JSON ↗

ROOT CAUSE

The attribute value is always wrapped as [value], so the list itself is looked up in the clause values.

VERIFIED REPAIR

Iterate the elements of a list-valued attribute and match if any element is in the clause values.

Unsuccessful approach: Requiring every element to be listed rejects mixed memberships and accepts empty lists.

Case contract

A user is in the segment if its key is in included (reason included, which beats excluded); else not if its key is in excluded; else if some rule with a non-empty clause list has every clause matching (reason rule:i). A clause [attr, values] matches only when the attribute is present and its value (or any element of a list value) is in values. Otherwise [False, none].

Why this case matters

Segments are reused across many flags, so a precedence slip changes exposure everywhere at once.

1 / The failure

Exit 1
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(segment, user):
    key = user.get('key')
    def hit(clause):
        attr, values = clause
        if attr not in user:
            return False
        value = user[attr]
        items = [value]
        return any(item in values for item in items)
    if key in segment.get('included', []):
        return [True, 'included']
    if key in segment.get('excluded', []):
        return [False, 'excluded']
    for i, rule in enumerate(segment.get('rules', [])):
        clauses = rule.get('clauses', [])
        if clauses and all(hit(c) for c in clauses):
            return [True, 'rule:%d' % i]
    return [False, 'none']
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[('explicit inclusion beats exclusion',
   [{'included': ['k1'], 'excluded': ['k1'], 'rules': []}, {'key': 'k1'}],
   [True, 'included']),
  ('exclusion blocks a matching rule',
   [{'included': ['k2'], 'excluded': ['k1'], 'rules': [{'clauses': [['region', ['eu']]]}]},
    {'key': 'k1', 'region': 'eu'}],
   [False, 'excluded']),
  ('empty clause list never matches',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': []}]}, {'key': 'k3'}],
   [False, 'none']),
  ('absent attribute does not match a null value',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['tier', [None, 'gold']]]}]}, {'key': 'k3'}],
   [False, 'none']),
  ('absent attribute does not match an empty string value',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['region', ['']]]}]}, {'key': 'k4'}],
   [False, 'none']),
  ('list attribute matches through any element',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['groups', ['beta']]]}]},
    {'key': 'k2', 'groups': ['staff', 'beta']}],
   [True, 'rule:0']),
  ('empty list attribute is not a member',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['groups', ['beta']]]}]},
    {'key': 'k2', 'groups': []}],
   [False, 'none']),
  ('segment sample 1',
   [{'included': ['k3'], 'excluded': ['k2', 'k1'], 'rules': [{'clauses': []}, {'clauses': []}]},
    {'key': 'k2', 'groups': ['beta'], 'tier': 'gold'}],
   [False, 'excluded'])],
 [('exclusion blocks a matching rule',
   [{'included': ['k2'], 'excluded': ['k1'], 'rules': [{'clauses': [['region', ['eu']]]}]},
    {'key': 'k1', 'region': 'eu'}],
   [False, 'excluded']),
  ('empty clause list never matches',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': []}]}, {'key': 'k3'}],
   [False, 'none']),
  ('absent attribute does not match a null value',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['tier', [None, 'gold']]]}]}, {'key': 'k3'}],
   [False, 'none']),
  ('absent attribute does not match an empty string value',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['region', ['']]]}]}, {'key': 'k4'}],
   [False, 'none']),
  ('list attribute matches through any element',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['groups', ['beta']]]}]},
    {'key': 'k2', 'groups': ['staff', 'beta']}],
   [True, 'rule:0']),
  ('empty list attribute is not a member',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['groups', ['beta']]]}]},
    {'key': 'k2', 'groups': []}],
   [False, 'none']),
  ('segment sample 6',
   [{'included': ['k4'], 'excluded': [], 'rules': []}, {'key': 'k2', 'region': 'us'}],
   [False, 'none']),
  ('segment sample 16',
   [{'included': ['k3', 'k1'], 'excluded': [], 'rules': [{'clauses': [['groups', ['gold', 'staff']]]}]},
    {'key': 'k2', 'groups': ['beta', 'staff'], 'region': 'eu'}],
   [True, 'rule:0'])],
 [('empty clause list never matches',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': []}]}, {'key': 'k3'}],
   [False, 'none']),
  ('absent attribute does not match a null value',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['tier', [None, 'gold']]]}]}, {'key': 'k3'}],
   [False, 'none']),
  ('absent attribute does not match an empty string value',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['region', ['']]]}]}, {'key': 'k4'}],
   [False, 'none']),
  ('list attribute matches through any element',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['groups', ['beta']]]}]},
    {'key': 'k2', 'groups': ['staff', 'beta']}],
   [True, 'rule:0']),
  ('empty list attribute is not a member',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['groups', ['beta']]]}]},
    {'key': 'k2', 'groups': []}],
   [False, 'none']),
  ('segment sample 11',
   [{'included': ['k1'], 'excluded': ['k3'], 'rules': [{'clauses': []}]},
    {'key': 'k2', 'groups': ['staff', 'eu'], 'tier': 'gold'}],
   [False, 'none']),
  ('segment sample 12',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['region', ['staff', '']]]}, {'clauses': []}]},
    {'key': 'k9', 'groups': 'beta'}],
   [False, 'none']),
  ('segment sample 16',
   [{'included': ['k3', 'k1'], 'excluded': [], 'rules': [{'clauses': [['groups', ['gold', 'staff']]]}]},
    {'key': 'k2', 'groups': ['beta', 'staff'], 'region': 'eu'}],
   [True, 'rule:0'])],
 [('absent attribute does not match a null value',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['tier', [None, 'gold']]]}]}, {'key': 'k3'}],
   [False, 'none']),
  ('absent attribute does not match an empty string value',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['region', ['']]]}]}, {'key': 'k4'}],
   [False, 'none']),
  ('list attribute matches through any element',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['groups', ['beta']]]}]},
    {'key': 'k2', 'groups': ['staff', 'beta']}],
   [True, 'rule:0']),
  ('empty list attribute is not a member',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['groups', ['beta']]]}]},
    {'key': 'k2', 'groups': []}],
   [False, 'none']),
  ('all clauses must match',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['region', ['eu']], ['groups', ['beta']]]}]},
    {'key': 'k1', 'region': 'eu', 'groups': ['x']}],
   [False, 'none']),
  ('segment sample 16',
   [{'included': ['k3', 'k1'], 'excluded': [], 'rules': [{'clauses': [['groups', ['gold', 'staff']]]}]},
    {'key': 'k2', 'groups': ['beta', 'staff'], 'region': 'eu'}],
   [True, 'rule:0']),
  ('segment sample 17',
   [{'included': [], 'excluded': ['k4'], 'rules': []},
    {'key': 'k3', 'groups': ['staff', 'eu'], 'region': 'us'}],
   [False, 'none']),
  ('segment sample 18',
   [{'included': ['k3'], 'excluded': [], 'rules': []}, {'key': 'k2', 'tier': None}],
   [False, 'none'])],
 [('absent attribute does not match an empty string value',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['region', ['']]]}]}, {'key': 'k4'}],
   [False, 'none']),
  ('list attribute matches through any element',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['groups', ['beta']]]}]},
    {'key': 'k2', 'groups': ['staff', 'beta']}],
   [True, 'rule:0']),
  ('empty list attribute is not a member',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['groups', ['beta']]]}]},
    {'key': 'k2', 'groups': []}],
   [False, 'none']),
  ('all clauses must match',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['region', ['eu']], ['groups', ['beta']]]}]},
    {'key': 'k1', 'region': 'eu', 'groups': ['x']}],
   [False, 'none']),
  ('second rule index',
   [{'included': [],
     'excluded': [],
     'rules': [{'clauses': [['region', ['us']]]}, {'clauses': [['region', ['eu']]]}]},
    {'key': 'k1', 'region': 'eu'}],
   [True, 'rule:1']),
  ('segment sample 21',
   [{'included': ['k3'], 'excluded': [], 'rules': []}, {'key': 'k9', 'groups': 'beta'}],
   [False, 'none']),
  ('segment sample 22',
   [{'included': [], 'excluded': ['k1'], 'rules': []}, {'key': 'k2', 'region': 'us'}],
   [False, 'none']),
  ('segment sample 23',
   [{'included': ['k1'], 'excluded': [], 'rules': [{'clauses': []}]},
    {'key': 'k3', 'region': 'us', 'tier': 'gold'}],
   [False, 'none'])]]
for label, args, expected in fixtures[N - 1]:
    check(label, solve(*args), expected)
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)
Boundary fixtureActualExpectedOutcome
explicit inclusion beats exclusion[True, 'included'][True, 'included']Passed
exclusion blocks a matching rule[False, 'excluded'][False, 'excluded']Passed
empty clause list never matches[False, 'none'][False, 'none']Passed
absent attribute does not match a null value[False, 'none'][False, 'none']Passed
absent attribute does not match an empty string value[False, 'none'][False, 'none']Passed
list attribute matches through any element[False, 'none'][True, 'rule:0']Failed
empty list attribute is not a member[False, 'none'][False, 'none']Passed
segment sample 1[False, 'excluded'][False, 'excluded']Passed

SHA-256 / 0557054abb0c54e06e5a1719fa3ed91b2a2df400d8d82fadc22720c822628670

2 / The unsuccessful fix

Exit 1
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(segment, user):
    key = user.get('key')
    def hit(clause):
        attr, values = clause
        if attr not in user:
            return False
        value = user[attr]
        items = value if isinstance(value, list) else [value]
        return all(item in values for item in items)
    if key in segment.get('included', []):
        return [True, 'included']
    if key in segment.get('excluded', []):
        return [False, 'excluded']
    for i, rule in enumerate(segment.get('rules', [])):
        clauses = rule.get('clauses', [])
        if clauses and all(hit(c) for c in clauses):
            return [True, 'rule:%d' % i]
    return [False, 'none']
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[('explicit inclusion beats exclusion',
   [{'included': ['k1'], 'excluded': ['k1'], 'rules': []}, {'key': 'k1'}],
   [True, 'included']),
  ('exclusion blocks a matching rule',
   [{'included': ['k2'], 'excluded': ['k1'], 'rules': [{'clauses': [['region', ['eu']]]}]},
    {'key': 'k1', 'region': 'eu'}],
   [False, 'excluded']),
  ('empty clause list never matches',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': []}]}, {'key': 'k3'}],
   [False, 'none']),
  ('absent attribute does not match a null value',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['tier', [None, 'gold']]]}]}, {'key': 'k3'}],
   [False, 'none']),
  ('absent attribute does not match an empty string value',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['region', ['']]]}]}, {'key': 'k4'}],
   [False, 'none']),
  ('list attribute matches through any element',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['groups', ['beta']]]}]},
    {'key': 'k2', 'groups': ['staff', 'beta']}],
   [True, 'rule:0']),
  ('empty list attribute is not a member',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['groups', ['beta']]]}]},
    {'key': 'k2', 'groups': []}],
   [False, 'none']),
  ('segment sample 1',
   [{'included': ['k3'], 'excluded': ['k2', 'k1'], 'rules': [{'clauses': []}, {'clauses': []}]},
    {'key': 'k2', 'groups': ['beta'], 'tier': 'gold'}],
   [False, 'excluded'])],
 [('exclusion blocks a matching rule',
   [{'included': ['k2'], 'excluded': ['k1'], 'rules': [{'clauses': [['region', ['eu']]]}]},
    {'key': 'k1', 'region': 'eu'}],
   [False, 'excluded']),
  ('empty clause list never matches',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': []}]}, {'key': 'k3'}],
   [False, 'none']),
  ('absent attribute does not match a null value',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['tier', [None, 'gold']]]}]}, {'key': 'k3'}],
   [False, 'none']),
  ('absent attribute does not match an empty string value',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['region', ['']]]}]}, {'key': 'k4'}],
   [False, 'none']),
  ('list attribute matches through any element',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['groups', ['beta']]]}]},
    {'key': 'k2', 'groups': ['staff', 'beta']}],
   [True, 'rule:0']),
  ('empty list attribute is not a member',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['groups', ['beta']]]}]},
    {'key': 'k2', 'groups': []}],
   [False, 'none']),
  ('segment sample 6',
   [{'included': ['k4'], 'excluded': [], 'rules': []}, {'key': 'k2', 'region': 'us'}],
   [False, 'none']),
  ('segment sample 16',
   [{'included': ['k3', 'k1'], 'excluded': [], 'rules': [{'clauses': [['groups', ['gold', 'staff']]]}]},
    {'key': 'k2', 'groups': ['beta', 'staff'], 'region': 'eu'}],
   [True, 'rule:0'])],
 [('empty clause list never matches',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': []}]}, {'key': 'k3'}],
   [False, 'none']),
  ('absent attribute does not match a null value',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['tier', [None, 'gold']]]}]}, {'key': 'k3'}],
   [False, 'none']),
  ('absent attribute does not match an empty string value',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['region', ['']]]}]}, {'key': 'k4'}],
   [False, 'none']),
  ('list attribute matches through any element',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['groups', ['beta']]]}]},
    {'key': 'k2', 'groups': ['staff', 'beta']}],
   [True, 'rule:0']),
  ('empty list attribute is not a member',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['groups', ['beta']]]}]},
    {'key': 'k2', 'groups': []}],
   [False, 'none']),
  ('segment sample 11',
   [{'included': ['k1'], 'excluded': ['k3'], 'rules': [{'clauses': []}]},
    {'key': 'k2', 'groups': ['staff', 'eu'], 'tier': 'gold'}],
   [False, 'none']),
  ('segment sample 12',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['region', ['staff', '']]]}, {'clauses': []}]},
    {'key': 'k9', 'groups': 'beta'}],
   [False, 'none']),
  ('segment sample 16',
   [{'included': ['k3', 'k1'], 'excluded': [], 'rules': [{'clauses': [['groups', ['gold', 'staff']]]}]},
    {'key': 'k2', 'groups': ['beta', 'staff'], 'region': 'eu'}],
   [True, 'rule:0'])],
 [('absent attribute does not match a null value',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['tier', [None, 'gold']]]}]}, {'key': 'k3'}],
   [False, 'none']),
  ('absent attribute does not match an empty string value',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['region', ['']]]}]}, {'key': 'k4'}],
   [False, 'none']),
  ('list attribute matches through any element',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['groups', ['beta']]]}]},
    {'key': 'k2', 'groups': ['staff', 'beta']}],
   [True, 'rule:0']),
  ('empty list attribute is not a member',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['groups', ['beta']]]}]},
    {'key': 'k2', 'groups': []}],
   [False, 'none']),
  ('all clauses must match',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['region', ['eu']], ['groups', ['beta']]]}]},
    {'key': 'k1', 'region': 'eu', 'groups': ['x']}],
   [False, 'none']),
  ('segment sample 16',
   [{'included': ['k3', 'k1'], 'excluded': [], 'rules': [{'clauses': [['groups', ['gold', 'staff']]]}]},
    {'key': 'k2', 'groups': ['beta', 'staff'], 'region': 'eu'}],
   [True, 'rule:0']),
  ('segment sample 17',
   [{'included': [], 'excluded': ['k4'], 'rules': []},
    {'key': 'k3', 'groups': ['staff', 'eu'], 'region': 'us'}],
   [False, 'none']),
  ('segment sample 18',
   [{'included': ['k3'], 'excluded': [], 'rules': []}, {'key': 'k2', 'tier': None}],
   [False, 'none'])],
 [('absent attribute does not match an empty string value',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['region', ['']]]}]}, {'key': 'k4'}],
   [False, 'none']),
  ('list attribute matches through any element',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['groups', ['beta']]]}]},
    {'key': 'k2', 'groups': ['staff', 'beta']}],
   [True, 'rule:0']),
  ('empty list attribute is not a member',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['groups', ['beta']]]}]},
    {'key': 'k2', 'groups': []}],
   [False, 'none']),
  ('all clauses must match',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['region', ['eu']], ['groups', ['beta']]]}]},
    {'key': 'k1', 'region': 'eu', 'groups': ['x']}],
   [False, 'none']),
  ('second rule index',
   [{'included': [],
     'excluded': [],
     'rules': [{'clauses': [['region', ['us']]]}, {'clauses': [['region', ['eu']]]}]},
    {'key': 'k1', 'region': 'eu'}],
   [True, 'rule:1']),
  ('segment sample 21',
   [{'included': ['k3'], 'excluded': [], 'rules': []}, {'key': 'k9', 'groups': 'beta'}],
   [False, 'none']),
  ('segment sample 22',
   [{'included': [], 'excluded': ['k1'], 'rules': []}, {'key': 'k2', 'region': 'us'}],
   [False, 'none']),
  ('segment sample 23',
   [{'included': ['k1'], 'excluded': [], 'rules': [{'clauses': []}]},
    {'key': 'k3', 'region': 'us', 'tier': 'gold'}],
   [False, 'none'])]]
for label, args, expected in fixtures[N - 1]:
    check(label, solve(*args), expected)
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)
Boundary fixtureActualExpectedOutcome
explicit inclusion beats exclusion[True, 'included'][True, 'included']Passed
exclusion blocks a matching rule[False, 'excluded'][False, 'excluded']Passed
empty clause list never matches[False, 'none'][False, 'none']Passed
absent attribute does not match a null value[False, 'none'][False, 'none']Passed
absent attribute does not match an empty string value[False, 'none'][False, 'none']Passed
list attribute matches through any element[False, 'none'][True, 'rule:0']Failed
empty list attribute is not a member[True, 'rule:0'][False, 'none']Failed
segment sample 1[False, 'excluded'][False, 'excluded']Passed

SHA-256 / da4ba7703b1ff716654e7b4bc7b8639ff98d487eaf4031ab49a3c18b61aa4449

3 / The verified repair

Exit 0
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(segment, user):
    key = user.get('key')
    def hit(clause):
        attr, values = clause
        if attr not in user:
            return False
        value = user[attr]
        items = value if isinstance(value, list) else [value]
        return any(item in values for item in items)
    if key in segment.get('included', []):
        return [True, 'included']
    if key in segment.get('excluded', []):
        return [False, 'excluded']
    for i, rule in enumerate(segment.get('rules', [])):
        clauses = rule.get('clauses', [])
        if clauses and all(hit(c) for c in clauses):
            return [True, 'rule:%d' % i]
    return [False, 'none']
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
fixtures = [[('explicit inclusion beats exclusion',
   [{'included': ['k1'], 'excluded': ['k1'], 'rules': []}, {'key': 'k1'}],
   [True, 'included']),
  ('exclusion blocks a matching rule',
   [{'included': ['k2'], 'excluded': ['k1'], 'rules': [{'clauses': [['region', ['eu']]]}]},
    {'key': 'k1', 'region': 'eu'}],
   [False, 'excluded']),
  ('empty clause list never matches',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': []}]}, {'key': 'k3'}],
   [False, 'none']),
  ('absent attribute does not match a null value',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['tier', [None, 'gold']]]}]}, {'key': 'k3'}],
   [False, 'none']),
  ('absent attribute does not match an empty string value',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['region', ['']]]}]}, {'key': 'k4'}],
   [False, 'none']),
  ('list attribute matches through any element',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['groups', ['beta']]]}]},
    {'key': 'k2', 'groups': ['staff', 'beta']}],
   [True, 'rule:0']),
  ('empty list attribute is not a member',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['groups', ['beta']]]}]},
    {'key': 'k2', 'groups': []}],
   [False, 'none']),
  ('segment sample 1',
   [{'included': ['k3'], 'excluded': ['k2', 'k1'], 'rules': [{'clauses': []}, {'clauses': []}]},
    {'key': 'k2', 'groups': ['beta'], 'tier': 'gold'}],
   [False, 'excluded'])],
 [('exclusion blocks a matching rule',
   [{'included': ['k2'], 'excluded': ['k1'], 'rules': [{'clauses': [['region', ['eu']]]}]},
    {'key': 'k1', 'region': 'eu'}],
   [False, 'excluded']),
  ('empty clause list never matches',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': []}]}, {'key': 'k3'}],
   [False, 'none']),
  ('absent attribute does not match a null value',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['tier', [None, 'gold']]]}]}, {'key': 'k3'}],
   [False, 'none']),
  ('absent attribute does not match an empty string value',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['region', ['']]]}]}, {'key': 'k4'}],
   [False, 'none']),
  ('list attribute matches through any element',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['groups', ['beta']]]}]},
    {'key': 'k2', 'groups': ['staff', 'beta']}],
   [True, 'rule:0']),
  ('empty list attribute is not a member',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['groups', ['beta']]]}]},
    {'key': 'k2', 'groups': []}],
   [False, 'none']),
  ('segment sample 6',
   [{'included': ['k4'], 'excluded': [], 'rules': []}, {'key': 'k2', 'region': 'us'}],
   [False, 'none']),
  ('segment sample 16',
   [{'included': ['k3', 'k1'], 'excluded': [], 'rules': [{'clauses': [['groups', ['gold', 'staff']]]}]},
    {'key': 'k2', 'groups': ['beta', 'staff'], 'region': 'eu'}],
   [True, 'rule:0'])],
 [('empty clause list never matches',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': []}]}, {'key': 'k3'}],
   [False, 'none']),
  ('absent attribute does not match a null value',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['tier', [None, 'gold']]]}]}, {'key': 'k3'}],
   [False, 'none']),
  ('absent attribute does not match an empty string value',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['region', ['']]]}]}, {'key': 'k4'}],
   [False, 'none']),
  ('list attribute matches through any element',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['groups', ['beta']]]}]},
    {'key': 'k2', 'groups': ['staff', 'beta']}],
   [True, 'rule:0']),
  ('empty list attribute is not a member',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['groups', ['beta']]]}]},
    {'key': 'k2', 'groups': []}],
   [False, 'none']),
  ('segment sample 11',
   [{'included': ['k1'], 'excluded': ['k3'], 'rules': [{'clauses': []}]},
    {'key': 'k2', 'groups': ['staff', 'eu'], 'tier': 'gold'}],
   [False, 'none']),
  ('segment sample 12',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['region', ['staff', '']]]}, {'clauses': []}]},
    {'key': 'k9', 'groups': 'beta'}],
   [False, 'none']),
  ('segment sample 16',
   [{'included': ['k3', 'k1'], 'excluded': [], 'rules': [{'clauses': [['groups', ['gold', 'staff']]]}]},
    {'key': 'k2', 'groups': ['beta', 'staff'], 'region': 'eu'}],
   [True, 'rule:0'])],
 [('absent attribute does not match a null value',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['tier', [None, 'gold']]]}]}, {'key': 'k3'}],
   [False, 'none']),
  ('absent attribute does not match an empty string value',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['region', ['']]]}]}, {'key': 'k4'}],
   [False, 'none']),
  ('list attribute matches through any element',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['groups', ['beta']]]}]},
    {'key': 'k2', 'groups': ['staff', 'beta']}],
   [True, 'rule:0']),
  ('empty list attribute is not a member',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['groups', ['beta']]]}]},
    {'key': 'k2', 'groups': []}],
   [False, 'none']),
  ('all clauses must match',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['region', ['eu']], ['groups', ['beta']]]}]},
    {'key': 'k1', 'region': 'eu', 'groups': ['x']}],
   [False, 'none']),
  ('segment sample 16',
   [{'included': ['k3', 'k1'], 'excluded': [], 'rules': [{'clauses': [['groups', ['gold', 'staff']]]}]},
    {'key': 'k2', 'groups': ['beta', 'staff'], 'region': 'eu'}],
   [True, 'rule:0']),
  ('segment sample 17',
   [{'included': [], 'excluded': ['k4'], 'rules': []},
    {'key': 'k3', 'groups': ['staff', 'eu'], 'region': 'us'}],
   [False, 'none']),
  ('segment sample 18',
   [{'included': ['k3'], 'excluded': [], 'rules': []}, {'key': 'k2', 'tier': None}],
   [False, 'none'])],
 [('absent attribute does not match an empty string value',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['region', ['']]]}]}, {'key': 'k4'}],
   [False, 'none']),
  ('list attribute matches through any element',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['groups', ['beta']]]}]},
    {'key': 'k2', 'groups': ['staff', 'beta']}],
   [True, 'rule:0']),
  ('empty list attribute is not a member',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['groups', ['beta']]]}]},
    {'key': 'k2', 'groups': []}],
   [False, 'none']),
  ('all clauses must match',
   [{'included': [], 'excluded': [], 'rules': [{'clauses': [['region', ['eu']], ['groups', ['beta']]]}]},
    {'key': 'k1', 'region': 'eu', 'groups': ['x']}],
   [False, 'none']),
  ('second rule index',
   [{'included': [],
     'excluded': [],
     'rules': [{'clauses': [['region', ['us']]]}, {'clauses': [['region', ['eu']]]}]},
    {'key': 'k1', 'region': 'eu'}],
   [True, 'rule:1']),
  ('segment sample 21',
   [{'included': ['k3'], 'excluded': [], 'rules': []}, {'key': 'k9', 'groups': 'beta'}],
   [False, 'none']),
  ('segment sample 22',
   [{'included': [], 'excluded': ['k1'], 'rules': []}, {'key': 'k2', 'region': 'us'}],
   [False, 'none']),
  ('segment sample 23',
   [{'included': ['k1'], 'excluded': [], 'rules': [{'clauses': []}]},
    {'key': 'k3', 'region': 'us', 'tier': 'gold'}],
   [False, 'none'])]]
for label, args, expected in fixtures[N - 1]:
    check(label, solve(*args), expected)
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)
Boundary fixtureActualExpectedOutcome
explicit inclusion beats exclusion[True, 'included'][True, 'included']Passed
exclusion blocks a matching rule[False, 'excluded'][False, 'excluded']Passed
empty clause list never matches[False, 'none'][False, 'none']Passed
absent attribute does not match a null value[False, 'none'][False, 'none']Passed
absent attribute does not match an empty string value[False, 'none'][False, 'none']Passed
list attribute matches through any element[True, 'rule:0'][True, 'rule:0']Passed
empty list attribute is not a member[False, 'none'][False, 'none']Passed
segment sample 1[False, 'excluded'][False, 'excluded']Passed

SHA-256 / 6d2729a46c541cf2cdfaac561049c721419664a47e36670bac904b55ab74e2a6

Verification & scope

A deterministic toy flag-evaluation model with a stipulated contract; it does not reproduce any vendor SDK byte for byte. This reproducer isolates one failure mechanism. Results cover the supplied fixtures. Variants within a family share a test contract and should remain grouped when constructing evaluation splits. Related mechanisms with a shared evaluation_group must also remain together; these controlled models are not independent production incidents.

Observations recorded using Python 3.12.14 at 2026-09-29T14:48:52.307759+00:00.

Case digest / 61bcc12d3512d3c7601188dca741521bf718a6dc16ad8bd0beadaf01c8635d11