From 4a7c39b175d45f9e7cbf95e92a2e28588d1e4225 Mon Sep 17 00:00:00 2001 From: Gaston Thea Date: Tue, 7 Nov 2023 16:33:24 -0300 Subject: [PATCH 1/4] New method parsing for Android --- .../main/java/io/split/splitio/Constants.java | 6 ++ .../split/splitio/SplitMethodParserImpl.java | 82 +++++++++++++++++++ .../splitio/SplitMethodParserImplTest.java | 82 +++++++++++++++++++ .../lib/split_view.dart | 2 +- 4 files changed, 171 insertions(+), 1 deletion(-) diff --git a/splitio_android/android/src/main/java/io/split/splitio/Constants.java b/splitio_android/android/src/main/java/io/split/splitio/Constants.java index 35ceb63..4537843 100644 --- a/splitio_android/android/src/main/java/io/split/splitio/Constants.java +++ b/splitio_android/android/src/main/java/io/split/splitio/Constants.java @@ -15,6 +15,10 @@ static class Method { static final String GET_TREATMENTS = "getTreatments"; static final String GET_TREATMENT_WITH_CONFIG = "getTreatmentWithConfig"; static final String GET_TREATMENTS_WITH_CONFIG = "getTreatmentsWithConfig"; + static final String GET_TREATMENTS_BY_FLAG_SET = "getTreatmentsByFlagSet"; + static final String GET_TREATMENTS_BY_FLAG_SETS = "getTreatmentsByFlagSets"; + static final String GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET = "getTreatmentsWithConfigByFlagSet"; + static final String GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS = "getTreatmentsWithConfigByFlagSets"; static final String TRACK = "track"; static final String GET_ATTRIBUTE = "getAttribute"; static final String GET_ALL_ATTRIBUTES = "getAllAttributes"; @@ -42,6 +46,8 @@ static class Argument { static final String VALUE = "value"; static final String PROPERTIES = "properties"; static final String ATTRIBUTE_NAME = "attributeName"; + static final String FLAG_SET = "flagSet"; + static final String FLAG_SETS = "flagSets"; } static class Error { diff --git a/splitio_android/android/src/main/java/io/split/splitio/SplitMethodParserImpl.java b/splitio_android/android/src/main/java/io/split/splitio/SplitMethodParserImpl.java index fb3ad5d..19bd218 100644 --- a/splitio_android/android/src/main/java/io/split/splitio/SplitMethodParserImpl.java +++ b/splitio_android/android/src/main/java/io/split/splitio/SplitMethodParserImpl.java @@ -5,6 +5,8 @@ import static io.split.splitio.Constants.Argument.ATTRIBUTE_NAME; import static io.split.splitio.Constants.Argument.BUCKETING_KEY; import static io.split.splitio.Constants.Argument.EVENT_TYPE; +import static io.split.splitio.Constants.Argument.FLAG_SET; +import static io.split.splitio.Constants.Argument.FLAG_SETS; import static io.split.splitio.Constants.Argument.MATCHING_KEY; import static io.split.splitio.Constants.Argument.PROPERTIES; import static io.split.splitio.Constants.Argument.SDK_CONFIGURATION; @@ -25,7 +27,11 @@ import static io.split.splitio.Constants.Method.GET_ATTRIBUTE; import static io.split.splitio.Constants.Method.GET_TREATMENT; import static io.split.splitio.Constants.Method.GET_TREATMENTS; +import static io.split.splitio.Constants.Method.GET_TREATMENTS_BY_FLAG_SET; +import static io.split.splitio.Constants.Method.GET_TREATMENTS_BY_FLAG_SETS; import static io.split.splitio.Constants.Method.GET_TREATMENTS_WITH_CONFIG; +import static io.split.splitio.Constants.Method.GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET; +import static io.split.splitio.Constants.Method.GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS; import static io.split.splitio.Constants.Method.GET_TREATMENT_WITH_CONFIG; import static io.split.splitio.Constants.Method.GET_USER_CONSENT; import static io.split.splitio.Constants.Method.INIT; @@ -132,6 +138,34 @@ public void onMethodCall(String methodName, Object arguments, @NonNull MethodCha mArgumentParser.getStringListArgument(SPLIT_NAME, arguments), mArgumentParser.getMapArgument(ATTRIBUTES, arguments))); break; + case GET_TREATMENTS_BY_FLAG_SET: + result.success(getTreatmentsByFlagSet( + mArgumentParser.getStringArgument(MATCHING_KEY, arguments), + mArgumentParser.getStringArgument(BUCKETING_KEY, arguments), + mArgumentParser.getStringArgument(FLAG_SET, arguments), + mArgumentParser.getMapArgument(ATTRIBUTES, arguments))); + break; + case GET_TREATMENTS_BY_FLAG_SETS: + result.success(getTreatmentsByFlagSets( + mArgumentParser.getStringArgument(MATCHING_KEY, arguments), + mArgumentParser.getStringArgument(BUCKETING_KEY, arguments), + mArgumentParser.getStringListArgument(FLAG_SETS, arguments), + mArgumentParser.getMapArgument(ATTRIBUTES, arguments))); + break; + case GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET: + result.success(getTreatmentsWithConfigByFlagSet( + mArgumentParser.getStringArgument(MATCHING_KEY, arguments), + mArgumentParser.getStringArgument(BUCKETING_KEY, arguments), + mArgumentParser.getStringArgument(FLAG_SET, arguments), + mArgumentParser.getMapArgument(ATTRIBUTES, arguments))); + break; + case GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS: + result.success(getTreatmentsWithConfigByFlagSets( + mArgumentParser.getStringArgument(MATCHING_KEY, arguments), + mArgumentParser.getStringArgument(BUCKETING_KEY, arguments), + mArgumentParser.getStringListArgument(FLAG_SETS, arguments), + mArgumentParser.getMapArgument(ATTRIBUTES, arguments))); + break; case TRACK: result.success(track( mArgumentParser.getStringArgument(MATCHING_KEY, arguments), @@ -279,6 +313,52 @@ private Map> getTreatmentsWithConfig( return resultMap; } + private Map getTreatmentsByFlagSet( + String matchingKey, + String bucketingKey, + String flagSet, + Map attributes) { + return mSplitWrapper.getTreatmentsByFlagSet(matchingKey, bucketingKey, flagSet, attributes); + } + + private Map getTreatmentsByFlagSets( + String matchingKey, + String bucketingKey, + List flagSets, + Map attributes) { + return mSplitWrapper.getTreatmentsByFlagSets(matchingKey, bucketingKey, flagSets, attributes); + } + + private Map> getTreatmentsWithConfigByFlagSet( + String matchingKey, + String bucketingKey, + String flagSet, + Map attributes) { + Map treatmentsWithConfig = mSplitWrapper.getTreatmentsWithConfigByFlagSet(matchingKey, bucketingKey, flagSet, attributes); + Map> resultMap = new HashMap<>(); + + for (Map.Entry entry : treatmentsWithConfig.entrySet()) { + resultMap.put(entry.getKey(), getSplitResultMap(entry.getValue())); + } + + return resultMap; + } + + private Map> getTreatmentsWithConfigByFlagSets( + String matchingKey, + String bucketingKey, + List flagSets, + Map attributes) { + Map treatmentsWithConfig = mSplitWrapper.getTreatmentsWithConfigByFlagSets(matchingKey, bucketingKey, flagSets, attributes); + Map> resultMap = new HashMap<>(); + + for (Map.Entry entry : treatmentsWithConfig.entrySet()) { + resultMap.put(entry.getKey(), getSplitResultMap(entry.getValue())); + } + + return resultMap; + } + private boolean track(String matchingKey, String bucketingKey, String eventType, @@ -395,6 +475,8 @@ private static Map getSplitViewAsMap(@Nullable SplitView splitVi splitViewMap.put("treatments", splitView.treatments); splitViewMap.put("changeNumber", splitView.changeNumber); splitViewMap.put("configs", splitView.configs); + splitViewMap.put("defaultTreatment", splitView.defaultTreatment); + splitViewMap.put("sets", splitView.sets); return splitViewMap; } diff --git a/splitio_android/android/src/test/java/io/split/splitio/SplitMethodParserImplTest.java b/splitio_android/android/src/test/java/io/split/splitio/SplitMethodParserImplTest.java index 538ea0e..c2f98d6 100644 --- a/splitio_android/android/src/test/java/io/split/splitio/SplitMethodParserImplTest.java +++ b/splitio_android/android/src/test/java/io/split/splitio/SplitMethodParserImplTest.java @@ -504,4 +504,86 @@ public void setUserConsentDisabled() { verify(mResult).success(null); verify(mSplitWrapper).setUserConsent(false); } + + @Test + public void getTreatmentsByFlagSetWorksCorrectly() { + Map map = new HashMap<>(); + map.put("matchingKey", "user-key"); + map.put("bucketingKey", "bucketing-key"); + map.put("flagSet", "set_1"); + map.put("attributes", Collections.singletonMap("age", 10)); + + when(mArgumentParser.getStringArgument("matchingKey", map)).thenReturn("user-key"); + when(mArgumentParser.getStringArgument("bucketingKey", map)).thenReturn("bucketing-key"); + when(mArgumentParser.getStringArgument("flagSet", map)).thenReturn("set_1"); + when(mArgumentParser.getMapArgument("attributes", map)).thenReturn(Collections.singletonMap("age", 10)); + when(mSplitWrapper.getTreatmentsByFlagSet(any(), any(), any(), any())).thenReturn(Collections.singletonMap("flag_1", "on")); + + mMethodParser.onMethodCall("getTreatmentsByFlagSet", map, mResult); + + verify(mSplitWrapper).getTreatmentsByFlagSet("user-key", "bucketing-key", "set_1", Collections.singletonMap("age", 10)); + verify(mResult).success(Collections.singletonMap("flag_1", "on")); + } + + @Test + public void getTreatmentsByFlagSetsWorksCorrectly() { + Map map = new HashMap<>(); + map.put("matchingKey", "user-key"); + map.put("bucketingKey", "bucketing-key"); + map.put("flagSets", Arrays.asList("set_1", "set_2")); + map.put("attributes", Collections.singletonMap("age", 10)); + + when(mArgumentParser.getStringArgument("matchingKey", map)).thenReturn("user-key"); + when(mArgumentParser.getStringArgument("bucketingKey", map)).thenReturn("bucketing-key"); + when(mArgumentParser.getStringListArgument("flagSets", map)).thenReturn(Arrays.asList("set_1", "set_2")); + when(mArgumentParser.getMapArgument("attributes", map)).thenReturn(Collections.singletonMap("age", 10)); + when(mSplitWrapper.getTreatmentsByFlagSets(any(), any(), any(), any())).thenReturn(Collections.singletonMap("flag_1", "on")); + + mMethodParser.onMethodCall("getTreatmentsByFlagSets", map, mResult); + + verify(mSplitWrapper).getTreatmentsByFlagSets("user-key", "bucketing-key", Arrays.asList("set_1", "set_2"), Collections.singletonMap("age", 10)); + verify(mResult).success(Collections.singletonMap("flag_1", "on")); + } + + @Test + public void getTreatmentsWithConfigByFlagSetWorksCorrectly() { + Map map = new HashMap<>(); + map.put("matchingKey", "user-key"); + map.put("bucketingKey", "bucketing-key"); + map.put("flagSet", "set_1"); + map.put("attributes", Collections.singletonMap("age", 10)); + + when(mArgumentParser.getStringArgument("matchingKey", map)).thenReturn("user-key"); + when(mArgumentParser.getStringArgument("bucketingKey", map)).thenReturn("bucketing-key"); + when(mArgumentParser.getStringArgument("flagSet", map)).thenReturn("set_1"); + when(mArgumentParser.getMapArgument("attributes", map)).thenReturn(Collections.singletonMap("age", 10)); + SplitResult splitResult = new SplitResult("on", "{config}"); + when(mSplitWrapper.getTreatmentsWithConfigByFlagSet(any(), any(), any(), any())).thenReturn(Collections.singletonMap("flag_1", splitResult)); + + mMethodParser.onMethodCall("getTreatmentsWithConfigByFlagSet", map, mResult); + + verify(mSplitWrapper).getTreatmentsWithConfigByFlagSet("user-key", "bucketing-key", "set_1", Collections.singletonMap("age", 10)); + verify(mResult).success(Collections.singletonMap("flag_1", splitResult)); + } + + @Test + public void getTreatmentsWithConfigByFlagSetsWorksCorrectly() { + Map map = new HashMap<>(); + map.put("matchingKey", "user-key"); + map.put("bucketingKey", "bucketing-key"); + map.put("flagSets", Arrays.asList("set_1", "set_2")); + map.put("attributes", Collections.singletonMap("age", 10)); + + when(mArgumentParser.getStringArgument("matchingKey", map)).thenReturn("user-key"); + when(mArgumentParser.getStringArgument("bucketingKey", map)).thenReturn("bucketing-key"); + when(mArgumentParser.getStringListArgument("flagSets", map)).thenReturn(Arrays.asList("set_1", "set_2")); + when(mArgumentParser.getMapArgument("attributes", map)).thenReturn(Collections.singletonMap("age", 10)); + SplitResult splitResult = new SplitResult("on", "{config}"); + when(mSplitWrapper.getTreatmentsWithConfigByFlagSets(any(), any(), any(), any())).thenReturn(Collections.singletonMap("flag_1", splitResult)); + + mMethodParser.onMethodCall("getTreatmentsWithConfigByFlagSets", map, mResult); + + verify(mSplitWrapper).getTreatmentsWithConfigByFlagSets("user-key", "bucketing-key", Arrays.asList("set_1", "set_2"), Collections.singletonMap("age", 10)); + verify(mResult).success(Collections.singletonMap("flag_1", splitResult)); + } } diff --git a/splitio_platform_interface/lib/split_view.dart b/splitio_platform_interface/lib/split_view.dart index 40451c5..11e7508 100644 --- a/splitio_platform_interface/lib/split_view.dart +++ b/splitio_platform_interface/lib/split_view.dart @@ -32,7 +32,7 @@ class SplitView { entry['changeNumber'], mappedConfig, entry['defaultTreatment'] ?? '', - entry['sets'] ?? []); + (entry['sets'] as List).map((el) => el as String).toList()); } @override From f2ec3e92653d681d8321c83be8823db7bcf05865 Mon Sep 17 00:00:00 2001 From: Gaston Thea Date: Tue, 7 Nov 2023 16:35:38 -0300 Subject: [PATCH 2/4] refactor' --- .../split/splitio/SplitMethodParserImpl.java | 35 ++++++++----------- 1 file changed, 14 insertions(+), 21 deletions(-) diff --git a/splitio_android/android/src/main/java/io/split/splitio/SplitMethodParserImpl.java b/splitio_android/android/src/main/java/io/split/splitio/SplitMethodParserImpl.java index 19bd218..69ee124 100644 --- a/splitio_android/android/src/main/java/io/split/splitio/SplitMethodParserImpl.java +++ b/splitio_android/android/src/main/java/io/split/splitio/SplitMethodParserImpl.java @@ -304,13 +304,7 @@ private Map> getTreatmentsWithConfig( List splitNames, Map attributes) { Map treatmentsWithConfig = mSplitWrapper.getTreatmentsWithConfig(matchingKey, bucketingKey, splitNames, attributes); - Map> resultMap = new HashMap<>(); - - for (Map.Entry entry : treatmentsWithConfig.entrySet()) { - resultMap.put(entry.getKey(), getSplitResultMap(entry.getValue())); - } - - return resultMap; + return mapToSplitResults(treatmentsWithConfig); } private Map getTreatmentsByFlagSet( @@ -335,13 +329,7 @@ private Map> getTreatmentsWithConfigByFlagSet( String flagSet, Map attributes) { Map treatmentsWithConfig = mSplitWrapper.getTreatmentsWithConfigByFlagSet(matchingKey, bucketingKey, flagSet, attributes); - Map> resultMap = new HashMap<>(); - - for (Map.Entry entry : treatmentsWithConfig.entrySet()) { - resultMap.put(entry.getKey(), getSplitResultMap(entry.getValue())); - } - - return resultMap; + return mapToSplitResults(treatmentsWithConfig); } private Map> getTreatmentsWithConfigByFlagSets( @@ -350,13 +338,7 @@ private Map> getTreatmentsWithConfigByFlagSets( List flagSets, Map attributes) { Map treatmentsWithConfig = mSplitWrapper.getTreatmentsWithConfigByFlagSets(matchingKey, bucketingKey, flagSets, attributes); - Map> resultMap = new HashMap<>(); - - for (Map.Entry entry : treatmentsWithConfig.entrySet()) { - resultMap.put(entry.getKey(), getSplitResultMap(entry.getValue())); - } - - return resultMap; + return mapToSplitResults(treatmentsWithConfig); } private boolean track(String matchingKey, @@ -436,6 +418,17 @@ private static void invokeCallback(MethodChannel methodChannel, String matchingK methodChannel.invokeMethod(methodName, arguments); } + @NonNull + private static Map> mapToSplitResults(Map treatmentsWithConfig) { + Map> resultMap = new HashMap<>(); + + for (Map.Entry entry : treatmentsWithConfig.entrySet()) { + resultMap.put(entry.getKey(), getSplitResultMap(entry.getValue())); + } + + return resultMap; + } + private static Map getSplitResultMap(SplitResult splitResult) { if (splitResult == null) { return new HashMap<>(); From c7beb5a9afef3304da2107c1092cf1665dcf8111 Mon Sep 17 00:00:00 2001 From: Gaston Thea Date: Tue, 7 Nov 2023 16:37:08 -0300 Subject: [PATCH 3/4] Minor fix --- splitio_platform_interface/lib/split_view.dart | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/splitio_platform_interface/lib/split_view.dart b/splitio_platform_interface/lib/split_view.dart index 11e7508..023ec0a 100644 --- a/splitio_platform_interface/lib/split_view.dart +++ b/splitio_platform_interface/lib/split_view.dart @@ -32,7 +32,7 @@ class SplitView { entry['changeNumber'], mappedConfig, entry['defaultTreatment'] ?? '', - (entry['sets'] as List).map((el) => el as String).toList()); + (entry['sets'] ?? [] as List).map((el) => el as String).toList()); } @override From 74e5a5054c4742980a3c4764a405b01e92d303b8 Mon Sep 17 00:00:00 2001 From: Gaston Thea Date: Tue, 7 Nov 2023 16:51:11 -0300 Subject: [PATCH 4/4] Fix test --- .../split/splitio/SplitMethodParserImpl.java | 4 ++++ .../splitio/SplitMethodParserImplTest.java | 18 ++++++++++++------ 2 files changed, 16 insertions(+), 6 deletions(-) diff --git a/splitio_android/android/src/main/java/io/split/splitio/SplitMethodParserImpl.java b/splitio_android/android/src/main/java/io/split/splitio/SplitMethodParserImpl.java index 69ee124..812143c 100644 --- a/splitio_android/android/src/main/java/io/split/splitio/SplitMethodParserImpl.java +++ b/splitio_android/android/src/main/java/io/split/splitio/SplitMethodParserImpl.java @@ -422,6 +422,10 @@ private static void invokeCallback(MethodChannel methodChannel, String matchingK private static Map> mapToSplitResults(Map treatmentsWithConfig) { Map> resultMap = new HashMap<>(); + if (treatmentsWithConfig == null) { + return resultMap; + } + for (Map.Entry entry : treatmentsWithConfig.entrySet()) { resultMap.put(entry.getKey(), getSplitResultMap(entry.getValue())); } diff --git a/splitio_android/android/src/test/java/io/split/splitio/SplitMethodParserImplTest.java b/splitio_android/android/src/test/java/io/split/splitio/SplitMethodParserImplTest.java index c2f98d6..7f7a225 100644 --- a/splitio_android/android/src/test/java/io/split/splitio/SplitMethodParserImplTest.java +++ b/splitio_android/android/src/test/java/io/split/splitio/SplitMethodParserImplTest.java @@ -553,17 +553,20 @@ public void getTreatmentsWithConfigByFlagSetWorksCorrectly() { map.put("flagSet", "set_1"); map.put("attributes", Collections.singletonMap("age", 10)); + Map resultMap1 = new HashMap<>(); + resultMap1.put("treatment", "on"); + resultMap1.put("config", "{config}"); + when(mArgumentParser.getStringArgument("matchingKey", map)).thenReturn("user-key"); when(mArgumentParser.getStringArgument("bucketingKey", map)).thenReturn("bucketing-key"); when(mArgumentParser.getStringArgument("flagSet", map)).thenReturn("set_1"); when(mArgumentParser.getMapArgument("attributes", map)).thenReturn(Collections.singletonMap("age", 10)); - SplitResult splitResult = new SplitResult("on", "{config}"); - when(mSplitWrapper.getTreatmentsWithConfigByFlagSet(any(), any(), any(), any())).thenReturn(Collections.singletonMap("flag_1", splitResult)); + when(mSplitWrapper.getTreatmentsWithConfigByFlagSet(any(), any(), any(), any())).thenReturn(Collections.singletonMap("flag_1", new SplitResult("on", "{config}"))); mMethodParser.onMethodCall("getTreatmentsWithConfigByFlagSet", map, mResult); verify(mSplitWrapper).getTreatmentsWithConfigByFlagSet("user-key", "bucketing-key", "set_1", Collections.singletonMap("age", 10)); - verify(mResult).success(Collections.singletonMap("flag_1", splitResult)); + verify(mResult).success(Collections.singletonMap("flag_1", resultMap1)); } @Test @@ -574,16 +577,19 @@ public void getTreatmentsWithConfigByFlagSetsWorksCorrectly() { map.put("flagSets", Arrays.asList("set_1", "set_2")); map.put("attributes", Collections.singletonMap("age", 10)); + Map resultMap1 = new HashMap<>(); + resultMap1.put("treatment", "on"); + resultMap1.put("config", "{config}"); + when(mArgumentParser.getStringArgument("matchingKey", map)).thenReturn("user-key"); when(mArgumentParser.getStringArgument("bucketingKey", map)).thenReturn("bucketing-key"); when(mArgumentParser.getStringListArgument("flagSets", map)).thenReturn(Arrays.asList("set_1", "set_2")); when(mArgumentParser.getMapArgument("attributes", map)).thenReturn(Collections.singletonMap("age", 10)); - SplitResult splitResult = new SplitResult("on", "{config}"); - when(mSplitWrapper.getTreatmentsWithConfigByFlagSets(any(), any(), any(), any())).thenReturn(Collections.singletonMap("flag_1", splitResult)); + when(mSplitWrapper.getTreatmentsWithConfigByFlagSets(any(), any(), any(), any())).thenReturn(Collections.singletonMap("flag_1", new SplitResult("on", "{config}"))); mMethodParser.onMethodCall("getTreatmentsWithConfigByFlagSets", map, mResult); verify(mSplitWrapper).getTreatmentsWithConfigByFlagSets("user-key", "bucketing-key", Arrays.asList("set_1", "set_2"), Collections.singletonMap("age", 10)); - verify(mResult).success(Collections.singletonMap("flag_1", splitResult)); + verify(mResult).success(Collections.singletonMap("flag_1", resultMap1)); } }