From 22b851902f38277e491a7ff79a9eec5bdcde3e5b Mon Sep 17 00:00:00 2001 From: Bilal Al-Shahwany Date: Thu, 10 Apr 2025 20:57:23 -0700 Subject: [PATCH 1/3] Added consumer classes --- .../io/split/client/SplitFactoryImpl.java | 5 +- ...CustomRuleBasedSegmentAdapterConsumer.java | 95 ++++++++++ ...CustomRuleBasedSegmentAdapterProducer.java | 57 ++++++ .../pluggable/domain/PrefixAdapter.java | 18 ++ client/src/test/java/io/split/TestHelper.java | 22 +++ .../RuleBasedSegmentParserTest.java | 16 +- ...omRuleBasedSegmentAdapterConsumerTest.java | 177 ++++++++++++++++++ 7 files changed, 373 insertions(+), 17 deletions(-) create mode 100644 client/src/main/java/io/split/storages/pluggable/adapters/UserCustomRuleBasedSegmentAdapterConsumer.java create mode 100644 client/src/main/java/io/split/storages/pluggable/adapters/UserCustomRuleBasedSegmentAdapterProducer.java create mode 100644 client/src/test/java/io/split/storages/pluggable/adapters/UserCustomRuleBasedSegmentAdapterConsumerTest.java diff --git a/client/src/main/java/io/split/client/SplitFactoryImpl.java b/client/src/main/java/io/split/client/SplitFactoryImpl.java index 5a3d2b34a..21f976c4b 100644 --- a/client/src/main/java/io/split/client/SplitFactoryImpl.java +++ b/client/src/main/java/io/split/client/SplitFactoryImpl.java @@ -80,6 +80,7 @@ import io.split.storages.pluggable.adapters.UserCustomSegmentAdapterConsumer; import io.split.storages.pluggable.adapters.UserCustomSplitAdapterConsumer; import io.split.storages.pluggable.adapters.UserCustomTelemetryAdapterProducer; +import io.split.storages.pluggable.adapters.UserCustomRuleBasedSegmentAdapterConsumer; import io.split.storages.pluggable.domain.UserStorageWrapper; import io.split.storages.pluggable.synchronizer.TelemetryConsumerSubmitter; import io.split.telemetry.storage.InMemoryTelemetryStorage; @@ -342,8 +343,8 @@ protected SplitFactoryImpl(String apiToken, SplitClientConfig config, CustomStor _gates = new SDKReadinessGates(); _telemetrySynchronizer = new TelemetryConsumerSubmitter(customStorageWrapper, _sdkMetadata); - // TODO Update the instance to UserCustomRuleBasedSegmentAdapterConsumer - RuleBasedSegmentCacheConsumer userCustomRuleBasedSegmentAdapterConsumer = new RuleBasedSegmentCacheInMemoryImp(); + UserCustomRuleBasedSegmentAdapterConsumer userCustomRuleBasedSegmentAdapterConsumer = + new UserCustomRuleBasedSegmentAdapterConsumer(customStorageWrapper); _evaluator = new EvaluatorImp(userCustomSplitAdapterConsumer, userCustomSegmentAdapterConsumer, userCustomRuleBasedSegmentAdapterConsumer); _impressionsSender = PluggableImpressionSender.create(customStorageWrapper); _uniqueKeysTracker = createUniqueKeysTracker(config); diff --git a/client/src/main/java/io/split/storages/pluggable/adapters/UserCustomRuleBasedSegmentAdapterConsumer.java b/client/src/main/java/io/split/storages/pluggable/adapters/UserCustomRuleBasedSegmentAdapterConsumer.java new file mode 100644 index 000000000..0b1dc88cd --- /dev/null +++ b/client/src/main/java/io/split/storages/pluggable/adapters/UserCustomRuleBasedSegmentAdapterConsumer.java @@ -0,0 +1,95 @@ +package io.split.storages.pluggable.adapters; + +import io.split.client.dtos.RuleBasedSegment; +import io.split.client.utils.Json; +import io.split.engine.experiments.ParsedRuleBasedSegment; +import io.split.engine.experiments.RuleBasedSegmentParser; +import io.split.storages.RuleBasedSegmentCacheConsumer; +import io.split.storages.pluggable.domain.PrefixAdapter; +import io.split.storages.pluggable.domain.UserStorageWrapper; +import io.split.storages.pluggable.utils.Helper; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import pluggable.CustomStorageWrapper; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.Set; +import java.util.stream.Collectors; + +import static com.google.common.base.Preconditions.checkNotNull; + +public class UserCustomRuleBasedSegmentAdapterConsumer implements RuleBasedSegmentCacheConsumer { + + private static final Logger _log = LoggerFactory.getLogger(UserCustomRuleBasedSegmentAdapterConsumer.class); + + private final RuleBasedSegmentParser _ruleBasedSegmentParser; + private final UserStorageWrapper _userStorageWrapper; + + public UserCustomRuleBasedSegmentAdapterConsumer(CustomStorageWrapper customStorageWrapper) { + _ruleBasedSegmentParser = new RuleBasedSegmentParser(); + _userStorageWrapper = new UserStorageWrapper(checkNotNull(customStorageWrapper)); + } + + @Override + public long getChangeNumber() { + String wrapperResponse = _userStorageWrapper.get(PrefixAdapter.buildRuleBasedSegmentChangeNumber()); + return Helper.responseToLong(wrapperResponse, -1L); + } + + @Override + public ParsedRuleBasedSegment get(String name) { + String wrapperResponse = _userStorageWrapper.get(PrefixAdapter.buildRuleBasedSegmentKey(name)); + if(wrapperResponse == null) { + return null; + } + RuleBasedSegment ruleBasedSegment = Json.fromJson(wrapperResponse, RuleBasedSegment.class); + if(ruleBasedSegment == null) { + _log.warn("Could not parse RuleBasedSegment."); + return null; + } + return _ruleBasedSegmentParser.parse(ruleBasedSegment); + } + + @Override + public Collection getAll() { + Set keys = _userStorageWrapper.getKeysByPrefix(PrefixAdapter.buildGetAllRuleBasedSegment()); + if(keys == null) { + return new ArrayList<>(); + } + List wrapperResponse = _userStorageWrapper.getMany(new ArrayList<>(keys)); + if(wrapperResponse == null) { + return new ArrayList<>(); + } + return stringsToParsedRuleBasedSegments(wrapperResponse); + } + + @Override + public List ruleBasedSegmentNames() { + Set ruleBasedSegmentNamesWithPrefix = _userStorageWrapper.getKeysByPrefix(PrefixAdapter.buildGetAllRuleBasedSegment()); + ruleBasedSegmentNamesWithPrefix = ruleBasedSegmentNamesWithPrefix.stream(). + map(key -> key.replace(PrefixAdapter.buildRuleBasedSegmentsPrefix(), "")). + collect(Collectors.toSet()); + return new ArrayList<>(ruleBasedSegmentNamesWithPrefix); + } + + @Override + public Set getSegments() { + return getAll().stream() + .flatMap(parsedRuleBasedSegment -> parsedRuleBasedSegment. + getSegmentsNames().stream()).collect(Collectors.toSet()); + } + + private List stringsToParsedRuleBasedSegments(List elements) { + List result = new ArrayList<>(); + for(String s : elements) { + if(s != null) { + result.add(_ruleBasedSegmentParser.parse(Json.fromJson(s, RuleBasedSegment.class))); + continue; + } + result.add(null); + } + return result; + } +} \ No newline at end of file diff --git a/client/src/main/java/io/split/storages/pluggable/adapters/UserCustomRuleBasedSegmentAdapterProducer.java b/client/src/main/java/io/split/storages/pluggable/adapters/UserCustomRuleBasedSegmentAdapterProducer.java new file mode 100644 index 000000000..87bee32b6 --- /dev/null +++ b/client/src/main/java/io/split/storages/pluggable/adapters/UserCustomRuleBasedSegmentAdapterProducer.java @@ -0,0 +1,57 @@ +package io.split.storages.pluggable.adapters; + +import io.split.client.dtos.RuleBasedSegment; +import io.split.client.utils.Json; +import io.split.engine.experiments.ParsedRuleBasedSegment; +import io.split.storages.RuleBasedSegmentCacheProducer; +import io.split.storages.pluggable.domain.PrefixAdapter; +import io.split.storages.pluggable.domain.UserStorageWrapper; +import io.split.storages.pluggable.utils.Helper; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import pluggable.CustomStorageWrapper; + +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +import static com.google.common.base.Preconditions.checkNotNull; + +public class UserCustomRuleBasedSegmentAdapterProducer implements RuleBasedSegmentCacheProducer { + + private static final Logger _log = LoggerFactory.getLogger(UserCustomRuleBasedSegmentAdapterProducer.class); + + private final UserStorageWrapper _userStorageWrapper; + + public UserCustomRuleBasedSegmentAdapterProducer(CustomStorageWrapper customStorageWrapper) { + _userStorageWrapper = new UserStorageWrapper(checkNotNull(customStorageWrapper)); + } + + @Override + public long getChangeNumber() { + String wrapperResponse = _userStorageWrapper.get(PrefixAdapter.buildRuleBasedSegmentChangeNumber()); + return Helper.responseToLong(wrapperResponse, -1L); + } + + @Override + public boolean remove(String ruleBasedSegmentName) { + // NoOp + return true; + } + + @Override + public void setChangeNumber(long changeNumber) { + //NoOp + } + + @Override + public void update(List toAdd, List toRemove, long changeNumber) { + //NoOp + } + + @Override + public Set getSegments() { + //NoOp + return new HashSet<>(); + } +} diff --git a/client/src/main/java/io/split/storages/pluggable/domain/PrefixAdapter.java b/client/src/main/java/io/split/storages/pluggable/domain/PrefixAdapter.java index 83842ef03..a785fbe74 100644 --- a/client/src/main/java/io/split/storages/pluggable/domain/PrefixAdapter.java +++ b/client/src/main/java/io/split/storages/pluggable/domain/PrefixAdapter.java @@ -20,6 +20,8 @@ public class PrefixAdapter { private static final String EXCEPTIONS = "exceptions"; private static final String INIT = "init"; private static final String FLAG_SET = "flagSet"; + private static final String RULE_BASED_SEGMENT_PREFIX = "rbsegment"; + private static final String RULE_BASED_SEGMENTS_PREFIX = "rbsegments"; public static String buildSplitKey(String name) { return String.format(DEFAULT_PREFIX+ SPLIT_PREFIX +"%s", name); @@ -37,6 +39,22 @@ public static String buildSplitsPrefix(){ return DEFAULT_PREFIX+SPLIT_PREFIX; } + public static String buildRuleBasedSegmentKey(String name) { + return String.format(DEFAULT_PREFIX+ RULE_BASED_SEGMENT_PREFIX +"%s", name); + } + + public static String buildRuleBasedSegmentsPrefix(){ + return DEFAULT_PREFIX+RULE_BASED_SEGMENT_PREFIX; + } + + public static String buildRuleBasedSegmentChangeNumber() { + return DEFAULT_PREFIX+RULE_BASED_SEGMENTS_PREFIX+"till"; + } + + public static String buildGetAllRuleBasedSegment() { + return DEFAULT_PREFIX+RULE_BASED_SEGMENT_PREFIX+"*"; + } + public static String buildTrafficTypeExists(String trafficType) { return String.format(DEFAULT_PREFIX+TRAFFIC_TYPE_PREFIX+"%s", trafficType); } diff --git a/client/src/test/java/io/split/TestHelper.java b/client/src/test/java/io/split/TestHelper.java index 449a692f6..577a1d00f 100644 --- a/client/src/test/java/io/split/TestHelper.java +++ b/client/src/test/java/io/split/TestHelper.java @@ -1,5 +1,9 @@ package io.split; +import io.split.client.dtos.Condition; +import io.split.client.dtos.Excluded; +import io.split.client.dtos.RuleBasedSegment; +import io.split.client.dtos.Status; import org.apache.hc.client5.http.impl.classic.CloseableHttpClient; import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse; import org.apache.hc.core5.http.ClassicHttpResponse; @@ -12,6 +16,8 @@ import java.io.IOException; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.List; public class TestHelper { public static CloseableHttpClient mockHttpClient(String jsonName, int httpStatus) throws IOException, IllegalAccessException, NoSuchMethodException, InvocationTargetException { @@ -36,4 +42,20 @@ public static CloseableHttpResponse classicResponseToCloseableMock(ClassicHttpRe adaptMethod.setAccessible(true); return (CloseableHttpResponse) adaptMethod.invoke(null, mocked); } + + public static RuleBasedSegment makeRuleBasedSegment(String name, List conditions, long changeNumber) { + Excluded excluded = new Excluded(); + excluded.segments = new ArrayList<>(); + excluded.keys = new ArrayList<>(); + + RuleBasedSegment ruleBasedSegment = new RuleBasedSegment(); + ruleBasedSegment.name = name; + ruleBasedSegment.status = Status.ACTIVE; + ruleBasedSegment.conditions = conditions; + ruleBasedSegment.trafficTypeName = "user"; + ruleBasedSegment.changeNumber = changeNumber; + ruleBasedSegment.excluded = excluded; + return ruleBasedSegment; + } + } diff --git a/client/src/test/java/io/split/engine/experiments/RuleBasedSegmentParserTest.java b/client/src/test/java/io/split/engine/experiments/RuleBasedSegmentParserTest.java index 1af224b8d..4c3973518 100644 --- a/client/src/test/java/io/split/engine/experiments/RuleBasedSegmentParserTest.java +++ b/client/src/test/java/io/split/engine/experiments/RuleBasedSegmentParserTest.java @@ -31,6 +31,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; +import static io.split.TestHelper.makeRuleBasedSegment; import static io.split.client.utils.FeatureFlagProcessor.processRuleBasedSegmentChanges; import static org.junit.Assert.assertTrue; @@ -542,21 +543,6 @@ public void setMatcherTest(Condition c, io.split.engine.matchers.Matcher m) { Assert.assertEquals(actual, expected); } - private RuleBasedSegment makeRuleBasedSegment(String name, List conditions, long changeNumber) { - Excluded excluded = new Excluded(); - excluded.segments = new ArrayList<>(); - excluded.keys = new ArrayList<>(); - - RuleBasedSegment ruleBasedSegment = new RuleBasedSegment(); - ruleBasedSegment.name = name; - ruleBasedSegment.status = Status.ACTIVE; - ruleBasedSegment.conditions = conditions; - ruleBasedSegment.trafficTypeName = "user"; - ruleBasedSegment.changeNumber = changeNumber; - ruleBasedSegment.excluded = excluded; - return ruleBasedSegment; - } - private SegmentChange getSegmentChange(long since, long till, String segmentName){ SegmentChange segmentChange = new SegmentChange(); segmentChange.name = segmentName; diff --git a/client/src/test/java/io/split/storages/pluggable/adapters/UserCustomRuleBasedSegmentAdapterConsumerTest.java b/client/src/test/java/io/split/storages/pluggable/adapters/UserCustomRuleBasedSegmentAdapterConsumerTest.java new file mode 100644 index 000000000..f1f39a730 --- /dev/null +++ b/client/src/test/java/io/split/storages/pluggable/adapters/UserCustomRuleBasedSegmentAdapterConsumerTest.java @@ -0,0 +1,177 @@ +package io.split.storages.pluggable.adapters; + +import com.google.common.collect.Lists; +import io.split.client.dtos.*; +import io.split.client.utils.Json; +import io.split.engine.ConditionsTestUtil; +import io.split.engine.experiments.*; +import io.split.storages.pluggable.domain.PrefixAdapter; +import io.split.storages.pluggable.domain.UserStorageWrapper; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mockito; +import pluggable.CustomStorageWrapper; + +import java.lang.reflect.Field; +import java.lang.reflect.Modifier; +import java.util.*; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import static io.split.TestHelper.makeRuleBasedSegment; + +public class UserCustomRuleBasedSegmentAdapterConsumerTest { + + private static final String RULE_BASED_SEGMENT_NAME = "RuleBasedSegmentName"; + private CustomStorageWrapper _customStorageWrapper; + private UserStorageWrapper _userStorageWrapper; + private UserCustomRuleBasedSegmentAdapterConsumer _userCustomRuleBasedSegmentAdapterConsumer; + + @Before + public void setUp() throws NoSuchFieldException, IllegalAccessException { + _customStorageWrapper = Mockito.mock(CustomStorageWrapper.class); + _userStorageWrapper = Mockito.mock(UserStorageWrapper.class); + _userCustomRuleBasedSegmentAdapterConsumer = new UserCustomRuleBasedSegmentAdapterConsumer(_customStorageWrapper); + Field userCustomRuleBasedSegmentAdapterConsumer = UserCustomRuleBasedSegmentAdapterConsumer.class.getDeclaredField("_userStorageWrapper"); + userCustomRuleBasedSegmentAdapterConsumer.setAccessible(true); + Field modifiersField = Field.class.getDeclaredField("modifiers"); + modifiersField.setAccessible(true); + modifiersField.setInt(userCustomRuleBasedSegmentAdapterConsumer, userCustomRuleBasedSegmentAdapterConsumer.getModifiers() & ~Modifier.FINAL); + userCustomRuleBasedSegmentAdapterConsumer.set(_userCustomRuleBasedSegmentAdapterConsumer, _userStorageWrapper); + } + + @Test + public void testGetChangeNumber() { + Mockito.when(_userStorageWrapper.get(PrefixAdapter.buildRuleBasedSegmentChangeNumber())).thenReturn(getLongAsJson(120L)); + Assert.assertEquals(120L, _userCustomRuleBasedSegmentAdapterConsumer.getChangeNumber()); + Mockito.verify(_userStorageWrapper, Mockito.times(1)).get(Mockito.anyString()); + } + + @Test + public void testGetChangeNumberWithWrapperFailing() { + Mockito.when(_userStorageWrapper.get(PrefixAdapter.buildRuleBasedSegmentChangeNumber())).thenReturn(null); + Assert.assertEquals(-1L, _userCustomRuleBasedSegmentAdapterConsumer.getChangeNumber()); + Mockito.verify(_userStorageWrapper, Mockito.times(1)).get(Mockito.anyString()); + } + + @Test + public void testGetChangeNumberWithGsonFailing() { + Mockito.when(_userStorageWrapper.get(PrefixAdapter.buildRuleBasedSegmentChangeNumber())).thenReturn("a"); + Assert.assertEquals(-1L, _userCustomRuleBasedSegmentAdapterConsumer.getChangeNumber()); + Mockito.verify(_userStorageWrapper, Mockito.times(1)).get(Mockito.anyString()); + } + + @Test + public void testGetRuleBasedSegment() { + RuleBasedSegmentParser ruleBasedSegmentParser = new RuleBasedSegmentParser(); + RuleBasedSegment ruleBasedSegment = getRuleBasedSegment(RULE_BASED_SEGMENT_NAME); + Mockito.when(_userStorageWrapper.get(PrefixAdapter.buildRuleBasedSegmentKey(RULE_BASED_SEGMENT_NAME))).thenReturn(getRuleBasedSegmentAsJson(ruleBasedSegment)); + ParsedRuleBasedSegment result = _userCustomRuleBasedSegmentAdapterConsumer.get(RULE_BASED_SEGMENT_NAME); + ParsedRuleBasedSegment expected = ruleBasedSegmentParser.parse(ruleBasedSegment); + Assert.assertEquals(expected, result); + } + + @Test + public void testGetRuleBasedSegmentNotFound() { + Mockito.when(_userStorageWrapper.get(PrefixAdapter.buildRuleBasedSegmentKey(RULE_BASED_SEGMENT_NAME))).thenReturn(null); + Mockito.when(_userStorageWrapper.get(PrefixAdapter.buildRuleBasedSegmentKey(RULE_BASED_SEGMENT_NAME))).thenReturn(null); + ParsedRuleBasedSegment result = _userCustomRuleBasedSegmentAdapterConsumer.get(RULE_BASED_SEGMENT_NAME); + Assert.assertNull(result); + } + + @Test + public void testGetAll() { + RuleBasedSegment ruleBasedSegment = getRuleBasedSegment(RULE_BASED_SEGMENT_NAME); + RuleBasedSegment ruleBasedSegment2 = getRuleBasedSegment(RULE_BASED_SEGMENT_NAME+"2"); + List listResultExpected = Stream.of(ruleBasedSegment, ruleBasedSegment2).collect(Collectors.toList()); + Set keysResult = Stream.of(RULE_BASED_SEGMENT_NAME, RULE_BASED_SEGMENT_NAME+"2").collect(Collectors.toSet()); + Mockito.when(_userStorageWrapper.getKeysByPrefix(Mockito.anyObject())). + thenReturn(keysResult); + List getManyExpected = Stream.of(Json.toJson(ruleBasedSegment), Json.toJson(ruleBasedSegment2)).collect(Collectors.toList()); + Mockito.when(_userStorageWrapper.getMany(Mockito.anyObject())). + thenReturn(getManyExpected); + List ruleBasedSegmentsResult = (List) _userCustomRuleBasedSegmentAdapterConsumer.getAll(); + Assert.assertNotNull(ruleBasedSegmentsResult); + Assert.assertEquals(listResultExpected.size(), ruleBasedSegmentsResult.size()); + Mockito.verify(_userStorageWrapper, Mockito.times(1)).getKeysByPrefix(Mockito.anyString()); + Mockito.verify(_userStorageWrapper, Mockito.times(1)).getMany(Mockito.anyObject()); + } + + @Test + public void testGetAllWithWrapperFailing() { + Mockito.when(_userStorageWrapper.get(PrefixAdapter.buildGetAllSplit())). + thenReturn(null); + List ruleBasedSegmentsResult = (List) _userCustomRuleBasedSegmentAdapterConsumer.getAll(); + Assert.assertNotNull(ruleBasedSegmentsResult); + Assert.assertEquals(0, ruleBasedSegmentsResult.size()); + } + + @Test + public void testGetAllNullOnWrappers() { + Mockito.when(_userStorageWrapper.getKeysByPrefix(PrefixAdapter.buildGetAllRuleBasedSegment())). + thenReturn(null); + List ruleBasedSegmentsResult = (List) _userCustomRuleBasedSegmentAdapterConsumer.getAll(); + Assert.assertEquals(0, ruleBasedSegmentsResult.size()); + } + + @Test + public void testGetAllNullOnGetMany() { + Set keysResult = Stream.of(RULE_BASED_SEGMENT_NAME, RULE_BASED_SEGMENT_NAME+"2").collect(Collectors.toSet()); + Mockito.when(_userStorageWrapper.getKeysByPrefix(Mockito.anyObject())). + thenReturn(keysResult); + Mockito.when(_userStorageWrapper.getMany(Mockito.anyObject())). + thenReturn(null); + List ruleBasedSegmentsResult = (List) _userCustomRuleBasedSegmentAdapterConsumer.getAll(); + Assert.assertEquals(0, ruleBasedSegmentsResult.size()); + } + + @Test + public void testGetSegments() { + Condition condition = ConditionsTestUtil.makeUserDefinedSegmentCondition(ConditionType.WHITELIST, "employee", + null, false); + RuleBasedSegment ruleBasedSegment = makeRuleBasedSegment("rbs", Arrays.asList(condition), 1); + List getManyExpected = Stream.of(Json.toJson(ruleBasedSegment)).collect(Collectors.toList()); + Mockito.when(_userStorageWrapper.getMany(Mockito.anyObject())). + thenReturn(getManyExpected); + HashSet segmentResult = (HashSet) _userCustomRuleBasedSegmentAdapterConsumer.getSegments(); + Assert.assertTrue(segmentResult.contains("employee")); + } + + @Test + public void testGetruleBasedSegmentNames() { + RuleBasedSegment ruleBasedSegment = getRuleBasedSegment(RULE_BASED_SEGMENT_NAME); + RuleBasedSegment ruleBasedSegment2 = getRuleBasedSegment(RULE_BASED_SEGMENT_NAME+"2"); + Set keysResult = Stream.of(RULE_BASED_SEGMENT_NAME, RULE_BASED_SEGMENT_NAME+"2").collect(Collectors.toSet()); + Mockito.when(_userStorageWrapper.getKeysByPrefix(Mockito.anyObject())). + thenReturn(keysResult); + List getManyExpected = Stream.of(Json.toJson(ruleBasedSegment), Json.toJson(ruleBasedSegment2)).collect(Collectors.toList()); + Mockito.when(_userStorageWrapper.getMany(Mockito.anyObject())). + thenReturn(getManyExpected); + List ruleBasedSegmentsResult = _userCustomRuleBasedSegmentAdapterConsumer.ruleBasedSegmentNames(); + Assert.assertNotNull(ruleBasedSegmentsResult); + Assert.assertEquals(keysResult.size(), ruleBasedSegmentsResult.size()); + Assert.assertEquals(keysResult, new HashSet<>(ruleBasedSegmentsResult)); + } + + public static String getLongAsJson(long value) { + return Json.toJson(value); + } + + public static String getRuleBasedSegmentAsJson(RuleBasedSegment ruleBasedSegment) { + return Json.toJson(ruleBasedSegment); + } + + private RuleBasedSegment getRuleBasedSegment(String name) { + ArrayList set = Lists.newArrayList("sms", "voice"); + Condition c = ConditionsTestUtil.containsString("user", + "products", + set, + false, + null + ); + + List conditions = Lists.newArrayList(c); + return makeRuleBasedSegment(name, conditions, 1); + } +} \ No newline at end of file From 42e03ceada7899b3fb59b77d6afc6ca16ab42c02 Mon Sep 17 00:00:00 2001 From: Bilal Al-Shahwany Date: Fri, 11 Apr 2025 09:36:45 -0700 Subject: [PATCH 2/3] polish --- client/src/main/java/io/split/client/SplitFactoryImpl.java | 1 - 1 file changed, 1 deletion(-) diff --git a/client/src/main/java/io/split/client/SplitFactoryImpl.java b/client/src/main/java/io/split/client/SplitFactoryImpl.java index 21f976c4b..ed66aa9db 100644 --- a/client/src/main/java/io/split/client/SplitFactoryImpl.java +++ b/client/src/main/java/io/split/client/SplitFactoryImpl.java @@ -67,7 +67,6 @@ import io.split.storages.SplitCache; import io.split.storages.SplitCacheConsumer; import io.split.storages.SplitCacheProducer; -import io.split.storages.RuleBasedSegmentCacheConsumer; import io.split.storages.RuleBasedSegmentCache; import io.split.storages.RuleBasedSegmentCacheProducer; import io.split.storages.enums.OperationMode; From f9abc5d341817bf914674f2e879934d3b84883f5 Mon Sep 17 00:00:00 2001 From: Bilal Al-Shahwany Date: Wed, 16 Apr 2025 12:41:11 -0700 Subject: [PATCH 3/3] deleted RBS storage producer --- ...CustomRuleBasedSegmentAdapterProducer.java | 57 ------------------- 1 file changed, 57 deletions(-) delete mode 100644 client/src/main/java/io/split/storages/pluggable/adapters/UserCustomRuleBasedSegmentAdapterProducer.java diff --git a/client/src/main/java/io/split/storages/pluggable/adapters/UserCustomRuleBasedSegmentAdapterProducer.java b/client/src/main/java/io/split/storages/pluggable/adapters/UserCustomRuleBasedSegmentAdapterProducer.java deleted file mode 100644 index 87bee32b6..000000000 --- a/client/src/main/java/io/split/storages/pluggable/adapters/UserCustomRuleBasedSegmentAdapterProducer.java +++ /dev/null @@ -1,57 +0,0 @@ -package io.split.storages.pluggable.adapters; - -import io.split.client.dtos.RuleBasedSegment; -import io.split.client.utils.Json; -import io.split.engine.experiments.ParsedRuleBasedSegment; -import io.split.storages.RuleBasedSegmentCacheProducer; -import io.split.storages.pluggable.domain.PrefixAdapter; -import io.split.storages.pluggable.domain.UserStorageWrapper; -import io.split.storages.pluggable.utils.Helper; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; -import pluggable.CustomStorageWrapper; - -import java.util.HashSet; -import java.util.List; -import java.util.Set; - -import static com.google.common.base.Preconditions.checkNotNull; - -public class UserCustomRuleBasedSegmentAdapterProducer implements RuleBasedSegmentCacheProducer { - - private static final Logger _log = LoggerFactory.getLogger(UserCustomRuleBasedSegmentAdapterProducer.class); - - private final UserStorageWrapper _userStorageWrapper; - - public UserCustomRuleBasedSegmentAdapterProducer(CustomStorageWrapper customStorageWrapper) { - _userStorageWrapper = new UserStorageWrapper(checkNotNull(customStorageWrapper)); - } - - @Override - public long getChangeNumber() { - String wrapperResponse = _userStorageWrapper.get(PrefixAdapter.buildRuleBasedSegmentChangeNumber()); - return Helper.responseToLong(wrapperResponse, -1L); - } - - @Override - public boolean remove(String ruleBasedSegmentName) { - // NoOp - return true; - } - - @Override - public void setChangeNumber(long changeNumber) { - //NoOp - } - - @Override - public void update(List toAdd, List toRemove, long changeNumber) { - //NoOp - } - - @Override - public Set getSegments() { - //NoOp - return new HashSet<>(); - } -}