fix for flagsmith string to double conversion issue(#1557)

Signed-off-by: Kush Batra <[email protected]>

Author: kushbatra

providers/flagd/src/main/java/dev/openfeature/contrib/providers/flagd/FlagdProvider.java

@@ -210,7 +210,7 @@ private void onProviderEvent(FlagdProviderEvent flagdProviderEvent) {
                         onConfigurationChanged(flagdProviderEvent);
                         break;
                     }
-                // intentional fall through
+                    // intentional fall through
                 case PROVIDER_READY:
                     /*
                      * Sync metadata is used to enrich the context, and is immutable in flagd,

providers/flagsmith/src/main/java/dev.openfeature.contrib.providers.flagsmith/FlagsmithProvider.java

@@ -180,19 +180,53 @@ private <T> ProviderEvaluation<T> buildEvaluation(
      * @param expectedType the type we expect for this value
      * @param <T> the type we want to convert to
      * @return A converted object
+     * @throws TypeMismatchError if the value cannot be converted to the expected type
      */
+    @SuppressWarnings("unchecked")
     private <T> T convertValue(Object value, Class<?> expectedType) {
         boolean isPrimitive = expectedType == Boolean.class
                 || expectedType == String.class
                 || expectedType == Integer.class
                 || expectedType == Double.class;
-        T flagValue = isPrimitive ? (T) value : (T) objectToValue(value);
+        Object flagValue;
+        String message = "Flag value had an unexpected type (" + (value != null ? value.getClass() : "null")
+                + "), expected (" + expectedType + ").";
+        if (isPrimitive) {
+            if (expectedType == Double.class) {
+                if (value instanceof Double) {
+                    flagValue = value;
+                } else if (value instanceof String) {
+                    try {
+                        flagValue = Double.parseDouble((String) value);
+                    } catch (NumberFormatException e) {
+                        throw new TypeMismatchError("Flag value string could not be parsed as Double: " + value);
+                    }
+                } else {
+                    throw new TypeMismatchError(message);
+                }
+            } else if (expectedType == Integer.class) {
+                if (value instanceof Integer) {
+                    flagValue = value;
+                } else if (value instanceof String) {
+                    try {
+                        flagValue = Integer.parseInt((String) value);
+                    } catch (NumberFormatException e) {
+                        throw new TypeMismatchError("Flag value string could not be parsed as Integer: " + value);
+                    }
+                } else {
+                    throw new TypeMismatchError(message);
+                }
+            } else {
+                flagValue = value;
+            }
+        } else {
+            flagValue = objectToValue(value);
+        }
 
-        if (flagValue.getClass() != expectedType) {
-            throw new TypeMismatchError(
-                    "Flag value had an unexpected type " + flagValue.getClass() + ", expected " + expectedType + ".");
+        if (!expectedType.isInstance(flagValue)) {
+            throw new TypeMismatchError(message);
         }
-        return flagValue;
+        return (T) flagValue;
     }
 
     /**

providers/flagsmith/src/test/java/dev.openfeature.contrib.providers.flagsmith/FlagsmithProviderTest.java

@@ -159,6 +159,53 @@ void tearDown() throws IOException {
         mockFlagsmithErrorServer.shutdown();
     }
 
+    @ParameterizedTest
+    @MethodSource("convertValueArguments")
+    void testConvertValue(Object input, Class<?> expectedType, Object expected) throws Exception {
+        var method = flagsmithProvider.getClass().getDeclaredMethod("convertValue", Object.class, Class.class);
+        method.setAccessible(true);
+        Object result = method.invoke(flagsmithProvider, input, expectedType);
+        assertEquals(expected, result);
+    }
+
+    private static Stream<Arguments> convertValueArguments() {
+        return Stream.of(
+                Arguments.of(true, Boolean.class, true),
+                Arguments.of("test", String.class, "test"),
+                Arguments.of(123, Integer.class, 123),
+                Arguments.of("123", Integer.class, 123),
+                Arguments.of(3.14, Double.class, 3.14),
+                Arguments.of("3.14", Double.class, 3.14));
+    }
+
+    @Test
+    void testConvertValueThrowsTypeMismatchErrorForInvalidInteger() throws Exception {
+        var method = flagsmithProvider.getClass().getDeclaredMethod("convertValue", Object.class, Class.class);
+        method.setAccessible(true);
+        assertThrows(dev.openfeature.sdk.exceptions.TypeMismatchError.class, () -> {
+            try {
+                method.invoke(flagsmithProvider, "abc", Integer.class);
+            } catch (java.lang.reflect.InvocationTargetException e) {
+                // Rethrow the actual exception thrown by convertValue
+                throw e.getCause();
+            }
+        });
+    }
+
+    @Test
+    void testConvertValueThrowsTypeMismatchErrorForInvalidDouble() throws Exception {
+        var method = flagsmithProvider.getClass().getDeclaredMethod("convertValue", Object.class, Class.class);
+        method.setAccessible(true);
+        assertThrows(dev.openfeature.sdk.exceptions.TypeMismatchError.class, () -> {
+            try {
+                method.invoke(flagsmithProvider, "abc", Double.class);
+            } catch (java.lang.reflect.InvocationTargetException e) {
+                // Rethrow the actual exception thrown by convertValue
+                throw e.getCause();
+            }
+        });
+    }
+
     @Test
     void shouldInitializeProviderWhenAllOptionsSet() {
         HashMap<String, String> headers = new HashMap<String, String>() {