def test_overrides_previous_conditions(self):
feature_name = "FLAG"
overriden_condition = Condition(value=True)
new_conditions = [Condition(new_value=True), Condition(id__in=[1, 2])]
self.client.create(feature_name)
self.client.add_condition(feature_name, overriden_condition)
self.client.set_conditions(feature_name, new_conditions)
conditions_array = self.client.get_meta(feature_name)["conditions"]
expected_conditions_array = [
{
"new_value": [{
"variable": "new_value",
"value": True,
"operator": None
}]
},
{
"id": [{
"variable": "id",
"value": [1, 2],
"operator": "in"
}]
},
]
self.assertEqual(expected_conditions_array, conditions_array)
def test_overrides_previous_conditions(self):
self.store.create(self.name)
overriden_condition = Condition(value=True)
new_conditions = [Condition(new_value=True), Condition(id__in=[1, 2])]
self.flag.add_condition(overriden_condition)
self.flag.set_conditions(new_conditions)
conditions_array = self.flag.get_meta()["conditions"]
expected_conditions_array = [
{
"new_value": [{
"variable": "new_value",
"value": True,
"operator": None
}]
},
{
"id": [{
"variable": "id",
"value": [1, 2],
"operator": "in"
}]
},
]
self.assertEqual(expected_conditions_array, conditions_array)
def test_condition_gets_included_in_meta(self):
condition_checks = {self.txt(): True}
condition = Condition(**condition_checks)
self.store.create(self.name)
self.flag.add_condition(condition)
meta = self.flag.get_meta()
self.assertTrue(condition.to_dict() in meta["conditions"])
def test_events_are_emitted(self):
feature_name = "FLAG"
new_conditions = [Condition(new_value=True), Condition(id__in=[1, 2])]
self.client.create(feature_name)
self.client.set_conditions(feature_name, new_conditions)
assert self.subscriber.events == [
("pre_set_conditions", feature_name, new_conditions),
("post_set_conditions", feature_name, new_conditions),
]
def test_condition_gets_included_in_meta(self):
feature_name = self.txt()
condition_checks = {self.txt(): True}
condition = Condition(**condition_checks)
self.client.create(feature_name)
self.client.add_condition(feature_name, condition)
meta = self.client.get_meta(feature_name)
self.assertTrue(condition.to_dict() in meta["conditions"])
def test_sets_conditions_correctly(self):
feature_name = self.txt()
self.fast.create(feature_name)
condition = Condition(**{self.txt(): self.txt()})
meta = FeatureFlagStoreMeta(int(datetime.now().timestamp()),
conditions=[condition])
self.fast.set_meta(feature_name, meta)
self.assertEqual(condition.to_dict(),
self.fast.get(feature_name).meta["conditions"][0])
def test_returns_true_when_all_checks_are_met(self):
condition = Condition(
foo=True,
bar=False,
baz__gt=99,
baz__lt=103,
herp__gte=10,
herp__lte=20,
derp__ne=2,
derp__in=[2, 43, 5, 8],
derp__not_in=[8, 1000],
)
self.assertTrue(
condition.check(foo=True, bar=False, baz=101, herp=20, derp=5))
def test_returns_false_when_at_least_one_check_is_not_met(self):
condition = Condition(
foo=True,
bar=False,
baz__gt=99,
baz__lt=103,
herp__gte=10,
herp__lte=20,
derp__ne=2,
derp__in=[2, 43, 5, 8],
derp__not_in=[8, 1000],
)
self.assertFalse(
condition.check(foo=True, bar=False, baz=101, herp=21, derp=5))
def test_returns_false_if_feature_disabled_despite_condition(self):
feature_name = self.txt()
self.client.create(feature_name, is_enabled=False)
self.client.add_condition(feature_name, Condition(foo=True))
self.assertFalse(self.client.is_enabled(feature_name, foo=True))
def test_calls_rpc_client_with_correct_args(self):
feature_name = self.txt()
client_data = {self.txt(): self.txt()}
created_date = self.date()
meta = FeatureFlagStoreMeta(
created_date,
client_data,
conditions=[Condition(foo__lte=99)],
bucketer=ConsistentHashPercentageBucketer(
key_whitelist=["baz"], percentage=LinearRampPercentage()
),
)
self.store.set_meta(feature_name, meta)
self.client.SetMeta.assert_called_once_with(
feature_name,
TFeatureFlagStoreMeta(
created_date=meta.created_date,
client_data=json.dumps(client_data),
conditions=[
{
"foo": [
TConditionCheck(
variable="foo",
value="99",
operator=TConditionOperator(symbol="lte"),
)
]
}
],
bucketer=json.dumps(meta.bucketer.to_dict()),
),
)
def test_returns_false_if_condition_specifies(self):
feature_name = self.txt()
self.client.create(feature_name, is_enabled=True)
self.client.add_condition(feature_name, Condition(foo=True))
self.assertFalse(self.client.is_enabled(feature_name, foo=False))
def test_includes_all_checks(self):
input = {
"foo": [{
"variable": "foo",
"value": True,
"operator": None
}],
"bar": [{
"variable": "bar",
"value": False,
"operator": None
}],
"baz": [
{
"variable": "baz",
"value": 99,
"operator": "gt"
},
{
"variable": "baz",
"value": 103,
"operator": "lt"
},
],
"herp": [
{
"variable": "herp",
"value": 10,
"operator": "gte"
},
{
"variable": "herp",
"value": 20,
"operator": "lte"
},
],
"derp": [
{
"variable": "derp",
"value": 2,
"operator": "ne"
},
{
"variable": "derp",
"value": [2, 43, 5, 8],
"operator": "in"
},
{
"variable": "derp",
"value": [8, 1000],
"operator": "not_in"
},
],
}
condition = Condition.from_dict(input)
self._compare(input, condition.to_dict())
def test_returns_false_when_bucketer_returns_true_and_conditions_return_false(
self
): # noqa: E501
# flag.is_enabled(user_id=1, is_admin=False) # False
bucketer = MagicMock()
bucketer.check.return_value = True
condition = Condition(is_admin=True)
meta = FeatureFlagStoreMeta(self.now, bucketer=bucketer, conditions=[condition])
item = FeatureFlagStoreItem(self.txt(), True, meta)
self.assertFalse(item.is_enabled(is_admin=False))
def test_condition_gets_appended_to_meta(self):
condition_checks = {self.txt(): True}
condition = Condition(**condition_checks)
self.store.create(self.name)
self.flag.add_condition(condition)
self.flag.add_condition(condition)
meta = self.flag.get_meta()
self.assertEqual(2, len(meta["conditions"]))
def test_condition_gets_appended_to_meta(self):
feature_name = self.txt()
condition_checks = {self.txt(): True}
condition = Condition(**condition_checks)
self.client.create(feature_name)
self.client.add_condition(feature_name, condition)
self.client.add_condition(feature_name, condition)
meta = self.client.get_meta(feature_name)
self.assertEqual(2, len(meta["conditions"]))
def test_emits_post_add_condition_event(self):
feature_name = self.txt()
events = FlipperEventEmitter()
listener = MagicMock()
events.on(EventType.POST_ADD_CONDITION, f=listener)
condition_checks = {self.txt(): True}
condition = Condition(**condition_checks)
self.client.events = events
self.store.create(feature_name)
self.client.add_condition(feature_name, condition)
listener.assert_called_once_with(feature_name, condition)
def test_converts_metadata_properly(self):
feature_name = self.txt()
self.store.create(feature_name, is_enabled=True)
item = self.store.get(feature_name)
expected = FeatureFlagStoreMeta(
created_date=self.meta.created_date,
client_data=json.loads(self.meta.client_data),
conditions=[Condition(foo__lte=99)],
bucketer=ConsistentHashPercentageBucketer(
key_whitelist=["baz"],
percentage=LinearRampPercentage(
initial_time=json.loads(self.meta.bucketer)["percentage"][
"initial_time"
]
),
),
)
self.assertEqual(expected.to_dict(), item.meta)
def test_can_check_less_than_or_equal_false(self):
condition = Condition(foo__lte=5)
self.assertFalse(condition.check(foo=8))
def test_can_check_less_than_false_when_equal(self):
condition = Condition(foo__lt=5)
self.assertFalse(condition.check(foo=5))
def test_can_check_less_than_true(self):
condition = Condition(foo__lt=5)
self.assertTrue(condition.check(foo=4))
def test_can_check_greater_than_or_equal_false(self):
condition = Condition(foo__gte=5)
self.assertFalse(condition.check(foo=4))
def test_can_check_greater_than_or_equal_true(self):
condition = Condition(foo__gte=5)
self.assertTrue(condition.check(foo=11))
def test_can_check_equality_false(self):
condition = Condition(foo=True)
self.assertFalse(condition.check(foo=False))
def test_can_check_negation_false(self):
condition = Condition(foo__ne="abc")
self.assertFalse(condition.check(foo="abc"))
def test_can_check_less_than_or_equal_true_when_equal(self):
condition = Condition(foo__lte=5)
self.assertTrue(condition.check(foo=5))
def test_can_check_negated_set_membership_false(self):
condition = Condition(foo__not_in=[1, 2, 3])
self.assertFalse(condition.check(foo=3))
def test_can_check_negation_true(self):
condition = Condition(foo__ne="abc")
self.assertTrue(condition.check(foo="def"))
def test_includes_all_checks(self):
condition = Condition(
foo=True,
bar=False,
baz__gt=99,
baz__lt=103,
herp__gte=10,
herp__lte=20,
derp__ne=2,
derp__in=[2, 43, 5, 8],
derp__not_in=[8, 1000],
)
expected = {
"foo": [{
"variable": "foo",
"value": True,
"operator": None
}],
"bar": [{
"variable": "bar",
"value": False,
"operator": None
}],
"baz": [
{
"variable": "baz",
"value": 99,
"operator": "gt"
},
{
"variable": "baz",
"value": 103,
"operator": "lt"
},
],
"herp": [
{
"variable": "herp",
"value": 10,
"operator": "gte"
},
{
"variable": "herp",
"value": 20,
"operator": "lte"
},
],
"derp": [
{
"variable": "derp",
"value": 2,
"operator": "ne"
},
{
"variable": "derp",
"value": [2, 43, 5, 8],
"operator": "in"
},
{
"variable": "derp",
"value": [8, 1000],
"operator": "not_in"
},
],
}
self._compare(expected, condition.to_dict())
def test_can_check_set_membership_true(self):
condition = Condition(foo__in=[1, 2, 3])
self.assertTrue(condition.check(foo=3))
def test_can_check_equality_true(self):
condition = Condition(foo=True)
self.assertTrue(condition.check(foo=True))
