From 0e23677a3331cf3e548db6af7cdbb197678063e9 Mon Sep 17 00:00:00 2001
From: Christopher Kolstad <chriswk@getunleash.io>
Date: Mon, 6 May 2024 14:25:51 +0200
Subject: [PATCH] fix: check that contextValue starts with (#240)

* fix: check that contextValue starts with

There had been an inversion of variable usage for one of our cases in
the matcher. This PR makes sure to compare contextValue to see if it
starts with the requested value in the constraint, instead of the other
way around.

fixes #238
---
 .../constraints/StringConstraintOperator.java | 11 ++--
 .../StringConstraintOperatorTest.java         | 52 +++++++++++++++++++
 2 files changed, 58 insertions(+), 5 deletions(-)

diff --git a/src/main/java/io/getunleash/strategy/constraints/StringConstraintOperator.java b/src/main/java/io/getunleash/strategy/constraints/StringConstraintOperator.java
index 5a300b420..3106d1c8b 100644
--- a/src/main/java/io/getunleash/strategy/constraints/StringConstraintOperator.java
+++ b/src/main/java/io/getunleash/strategy/constraints/StringConstraintOperator.java
@@ -58,17 +58,18 @@ private boolean startsWith(
             List<String> values, Optional<String> contextValue, boolean caseInsensitive) {
         return contextValue
                 .map(
-                        c ->
+                        actualContextValue ->
                                 values.stream()
                                         .anyMatch(
-                                                v -> {
+                                                value -> {
                                                     if (caseInsensitive) {
-                                                        return v.toLowerCase(comparisonLocale)
+                                                        return actualContextValue
+                                                                .toLowerCase(comparisonLocale)
                                                                 .startsWith(
-                                                                        c.toLowerCase(
+                                                                        value.toLowerCase(
                                                                                 comparisonLocale));
                                                     } else {
-                                                        return c.startsWith(v);
+                                                        return actualContextValue.startsWith(value);
                                                     }
                                                 }))
                 .orElse(false);
diff --git a/src/test/java/io/getunleash/strategy/constraints/StringConstraintOperatorTest.java b/src/test/java/io/getunleash/strategy/constraints/StringConstraintOperatorTest.java
index 34234ee85..1ed3f76dd 100644
--- a/src/test/java/io/getunleash/strategy/constraints/StringConstraintOperatorTest.java
+++ b/src/test/java/io/getunleash/strategy/constraints/StringConstraintOperatorTest.java
@@ -211,4 +211,56 @@ public void shouldSupportInvertingStringContains() {
                         .build();
         assertThat(strategy.isEnabled(parameters, ctx, constraintList)).isFalse();
     }
+
+    @Test
+    public void startsWithShouldMatchCorrectlyWhenCaseSensitive() {
+        Strategy strategy = new DefaultStrategy();
+        List<Constraint> constraintList =
+                Collections.singletonList(
+                        new Constraint(
+                                "email",
+                                Operator.STR_STARTS_WITH,
+                                Collections.singletonList("testuser"),
+                                false,
+                                false));
+        Map<String, String> parameters = new HashMap<>();
+        UnleashContext ctx =
+                UnleashContext.builder()
+                        .environment("dev")
+                        .addProperty("email", "TESTUSER@getunleash.io")
+                        .build();
+        assertThat(strategy.isEnabled(parameters, ctx, constraintList)).isFalse();
+        UnleashContext ctx2 =
+                UnleashContext.builder()
+                        .environment("dev")
+                        .addProperty("email", "testuser@getunleash.io")
+                        .build();
+        assertThat(strategy.isEnabled(parameters, ctx2, constraintList)).isTrue();
+    }
+
+    @Test
+    public void startsWithShouldMatchCorrectlyWhenCaseInsensitive() {
+        Strategy strategy = new DefaultStrategy();
+        List<Constraint> constraintList =
+                Collections.singletonList(
+                        new Constraint(
+                                "email",
+                                Operator.STR_STARTS_WITH,
+                                Collections.singletonList("testuser"),
+                                false,
+                                true));
+        Map<String, String> parameters = new HashMap<>();
+        UnleashContext ctx =
+                UnleashContext.builder()
+                        .environment("dev")
+                        .addProperty("email", "TESTUSER@getunleash.io")
+                        .build();
+        assertThat(strategy.isEnabled(parameters, ctx, constraintList)).isTrue();
+        UnleashContext ctx2 =
+                UnleashContext.builder()
+                        .environment("dev")
+                        .addProperty("email", "testuser@getunleash.io")
+                        .build();
+        assertThat(strategy.isEnabled(parameters, ctx2, constraintList)).isTrue();
+    }
 }