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))