def test_create_tree_multiple_keys(self):
config = get_simple_config()
config["ANY"] = [
{"EQ": {"field": "is_mod", "value": True}},
{"EQ": {"field": "user_id", "values": ["t2_1", "t2_2", "t2_3", "t2_4"]}},
]
with self.assertRaises(TargetingNodeError):
create_targeting_tree(config)
def test_bad_inputs(self):
inputs = get_input_set()
targeting_config_str = {"OVERRIDE": "string"}
targeting_tree_str = create_targeting_tree(targeting_config_str)
self.assertFalse(targeting_tree_str.evaluate(**inputs))
targeting_config_struct = {"OVERRIDE": {"key": "value"}}
targeting_tree_struct = create_targeting_tree(targeting_config_struct)
self.assertFalse(targeting_tree_struct.evaluate(**inputs))
def test_nominal(self):
inputs = get_input_set()
targeting_config_true = {"OVERRIDE": True}
targeting_tree_true = create_targeting_tree(targeting_config_true)
self.assertTrue(targeting_tree_true.evaluate(**inputs))
targeting_config_false = {"OVERRIDE": False}
targeting_tree_false = create_targeting_tree(targeting_config_false)
self.assertFalse(targeting_tree_false.evaluate(**inputs))
def test_not_node_bad_inputs(self):
targeting_config_empty = {"NOT": {}}
with self.assertRaises(TargetingNodeError):
create_targeting_tree(targeting_config_empty)
targeting_config_multiple_args = {
"NOT": {
"EQ": {"field": "is_mod", "value": True},
"ALL": {"field": "user_id", "values": ["t2_1", "t2_2", "t2_3", "t2_4"]},
}
}
with self.assertRaises(TargetingNodeError):
create_targeting_tree(targeting_config_multiple_args)
def test_comparison_ne_none(self):
inputs = get_input_set()
# test explicit none in inputs
targeting_config_none = {"NE": {"field": "explicit_none_field", "value": None}}
targeting_tree_none = create_targeting_tree(targeting_config_none)
self.assertFalse(targeting_tree_none.evaluate(**inputs))
# test field missing in inputs (implicit none)
targeting_config_none = {"NE": {"field": "implicit_none_field", "value": None}}
targeting_tree_none = create_targeting_tree(targeting_config_none)
self.assertFalse(targeting_tree_none.evaluate(**inputs))
def test_equal_list_value_node_none(self):
inputs = get_input_set()
# test explicit none in inputs
targeting_config_none = {"EQ": {"field": "explicit_none_field", "values": [None, True]}}
targeting_tree_none = create_targeting_tree(targeting_config_none)
self.assertTrue(targeting_tree_none.evaluate(**inputs))
# test field missing in inputs (implicit none)
targeting_config_none = {"EQ": {"field": "implicit_none_field", "values": [None]}}
targeting_tree_none = create_targeting_tree(targeting_config_none)
self.assertTrue(targeting_tree_none.evaluate(**inputs))
def test_ne_node(self):
inputs = get_input_set()
targeting_config_eq = {"NE": {"field": "num_field", "value": 5}}
targeting_tree_eq = create_targeting_tree(targeting_config_eq)
self.assertFalse(targeting_tree_eq.evaluate(**inputs))
targeting_config_lt = {"NE": {"field": "num_field", "value": 4}}
targeting_tree_lt = create_targeting_tree(targeting_config_lt)
self.assertTrue(targeting_tree_lt.evaluate(**inputs))
targeting_config_gt = {"NE": {"field": "num_field", "value": 6}}
targeting_tree_gt = create_targeting_tree(targeting_config_gt)
self.assertTrue(targeting_tree_gt.evaluate(**inputs))
def _generate_targeting(
targeting_config: Optional[Dict[str, Any]]) -> Targeting:
"""Generate the targeting tree for this experiment.
If no config is provided, then assume we want to target all. If an invalid
config is provided, then target none.
"""
if targeting_config is None:
return create_targeting_tree({"OVERRIDE": True})
try:
return create_targeting_tree(targeting_config)
except Exception:
logger.error("Unable to create targeting tree. No targeting applied.")
return create_targeting_tree({"OVERRIDE": False})
def test_equal_list_value_node_bool(self):
inputs = get_input_set()
# test bool field
targeting_config_bool = {"EQ": {"field": "bool_field", "values": [True, False]}}
targeting_tree_bool = create_targeting_tree(targeting_config_bool)
self.assertTrue(targeting_tree_bool.evaluate(**inputs))
def test_equal_list_value_node_number(self):
inputs = get_input_set()
targeting_config_num = {"EQ": {"field": "num_field", "values": [5, 6, 7, 8, 9]}}
targeting_tree_num = create_targeting_tree(targeting_config_num)
self.assertTrue(targeting_tree_num.evaluate(**inputs))
def test_any_node_empty_list(self):
inputs = get_input_set()
targeting_config_empty_list = {"ANY": []}
targeting_tree_empty_list = create_targeting_tree(targeting_config_empty_list)
self.assertFalse(targeting_tree_empty_list.evaluate(**inputs))
def test_equal_single_value_node_string(self):
inputs = get_input_set()
# test string field
targeting_config_str = {"EQ": {"field": "str_field", "value": "string_value"}}
targeting_tree_str = create_targeting_tree(targeting_config_str)
self.assertTrue(targeting_tree_str.evaluate(**inputs))
def test_equal_single_value_node_num(self):
inputs = get_input_set()
# test numeric field
targeting_config_num = {"EQ": {"field": "num_field", "value": 5}}
targeting_tree_num = create_targeting_tree(targeting_config_num)
self.assertTrue(targeting_tree_num.evaluate(**inputs))
def test_not_node(self):
inputs = {}
inputs["str_field"] = "string_value"
targeting_config = {"NOT": {"EQ": {"field": "str_field", "value": "string_value"}}}
targeting_tree_str = create_targeting_tree(targeting_config)
self.assertFalse(targeting_tree_str.evaluate(**inputs))
inputs["str_field"] = "str_value"
self.assertTrue(targeting_tree_str.evaluate(**inputs))
def test_equal_list_value_node_string(self):
inputs = get_input_set()
targeting_config_str = {
"EQ": {
"field": "str_field",
"values": ["string_value", "string_value_2", "string_value_3"],
}
}
targeting_tree_str = create_targeting_tree(targeting_config_str)
self.assertTrue(targeting_tree_str.evaluate(**inputs))
def test_any_node_no_match(self):
inputs = get_input_set()
targeting_config = {
"ANY": [
{"EQ": {"field": "num_field", "value": 6}},
{"EQ": {"field": "str_field", "value": "str_value_1"}},
{"EQ": {"field": "bool_field", "value": False}},
]
}
targeting_tree = create_targeting_tree(targeting_config)
self.assertFalse(targeting_tree.evaluate(**inputs))
def test_all_node_all_match(self):
inputs = get_input_set()
targeting_config = {
"ALL": [
{"EQ": {"field": "num_field", "value": 5}},
{"EQ": {"field": "str_field", "value": "string_value"}},
{"EQ": {"field": "bool_field", "value": True}},
]
}
targeting_tree = create_targeting_tree(targeting_config)
self.assertTrue(targeting_tree.evaluate(**inputs))
def test_comparison_node_bad_inputs(self):
targeting_config_empty = {"LE": {}}
with self.assertRaises(TargetingNodeError):
create_targeting_tree(targeting_config_empty)
targeting_config_one_arg = {"LE": {"field": "some_field"}}
with self.assertRaises(TargetingNodeError):
create_targeting_tree(targeting_config_one_arg)
targeting_config_three_args = {
"LE": {"field": "some_field", "values": ["one", True], "value": "str_arg"}
}
with self.assertRaises(TargetingNodeError):
create_targeting_tree(targeting_config_three_args)
targeting_config_no_field = {"LE": {"fields": "some_field", "value": "str_arg"}}
with self.assertRaises(TargetingNodeError):
create_targeting_tree(targeting_config_no_field)
targeting_config_no_value = {"LE": {"field": "some_field", "valu": "str_arg"}}
with self.assertRaises(TargetingNodeError):
create_targeting_tree(targeting_config_no_value)
def test_nominal(self):
targeting_tree = create_targeting_tree(get_simple_config())
inputs = {}
inputs["user_id"] = "t2_1"
inputs["is_mod"] = False
inputs["is_pita"] = False
inputs["random_numeric"] = 5
self.assertFalse(targeting_tree.evaluate(**inputs))
inputs["is_logged_in"] = True
self.assertTrue(targeting_tree.evaluate(**inputs))
def test_create_tree_unknown_operator(self):
config = get_simple_config()
config["UNKNOWN"] = config.pop("ALL")
with self.assertRaises(UnknownTargetingOperatorError):
create_targeting_tree(config)
def test_all_node_invalid_inputs(self):
targeting_config_not_list = {"ALL": {"field": "fieldname", "value": "notalist"}}
with self.assertRaises(TargetingNodeError):
create_targeting_tree(targeting_config_not_list)
