From 23b405d64021164af0b54a9891d48d42cbe3b1e2 Mon Sep 17 00:00:00 2001
From: Kapish Malik <malikkapish@gmail.com>
Date: Sun, 1 Dec 2024 00:53:57 +0530
Subject: [PATCH] Bugfix resolve #1155 (#1158)

* Revert "Revert "bugfix - resolve issue #1155" (#1157)"

This reverts commit 25457ed9111c4870399edf3617ffea03c85bbbf5.

* added unit test for user provided input
---
 core/util/util.go      | 35 ++++++++++++++++++++++++++++++-----
 core/util/util_test.go | 21 +++++++++++++++++++++
 2 files changed, 51 insertions(+), 5 deletions(-)

diff --git a/core/util/util.go b/core/util/util.go
index 33bfe2aa3..661710a3d 100644
--- a/core/util/util.go
+++ b/core/util/util.go
@@ -14,6 +14,7 @@ import (
 	log "github.com/sirupsen/logrus"
 	"io/ioutil"
 	"k8s.io/client-go/util/jsonpath"
+	"math/big"
 	"math/rand"
 	"net/http"
 	"net/url"
@@ -401,11 +402,14 @@ func jsonPath(query, toMatch string) interface{} {
 
 	// Jsonpath library converts large int into a string with scientific notion, the following
 	// reverts that process to avoid mismatching when using the jsonpath result for csv data lookup
-	floatResult, err := strconv.ParseFloat(result, 64)
-	// if the string is a float and a whole number
-	if err == nil && floatResult == float64(int64(floatResult)) {
-		intResult := int(floatResult)
-		result = strconv.Itoa(intResult)
+	// Handle large integers in scientific notation by converting back to big.Int
+	if isScientific(result) {
+		// If result is in scientific notation, try converting to a big.Int
+		bigInt := new(big.Int)
+		bigInt, success := bigIntFromString(result)
+		if success {
+			result = bigInt.String() // Convert back to string representation of the big integer
+		}
 	}
 
 	// convert to array data if applicable
@@ -420,6 +424,27 @@ func jsonPath(query, toMatch string) interface{} {
 	return arrayData
 }
 
+// isScientific checks if a string is in scientific notation (e.g., "1.349599e+37")
+func isScientific(value string) bool {
+	return strings.Contains(value, "e") || strings.Contains(value, "E")
+}
+
+// bigIntFromString converts a string representing a number (potentially in scientific notation) to big.Int
+func bigIntFromString(value string) (*big.Int, bool) {
+	// Parse the string as a big.Float to handle scientific notation
+	flt := new(big.Float)
+	flt, _, err := big.ParseFloat(value, 10, 0, big.ToNearestEven)
+	if err != nil {
+		return nil, false
+	}
+
+	// Convert the big.Float to big.Int (rounding down)
+	bigInt := new(big.Int)
+	flt.Int(bigInt)
+
+	return bigInt, true
+}
+
 func xPath(query, toMatch string) string {
 	result, err := XpathExecution(query, toMatch)
 	if err != nil {
diff --git a/core/util/util_test.go b/core/util/util_test.go
index ddc888014..4ebac73fd 100644
--- a/core/util/util_test.go
+++ b/core/util/util_test.go
@@ -234,6 +234,27 @@ func Test_CopyMap(t *testing.T) {
 	Expect(newMap["second"]).To(Equal("2"))
 }
 
+func Test_JsonPathMethod_WithBigFloatingNumber(t *testing.T) {
+
+	RegisterTestingT(t)
+	res := jsonPath("$.registrant", `{"registrant":"13495985898986869898697879879987978978.12345566777"}`)
+	Expect(res).To(Equal("13495985898986869898697879879987978978.12345566777"))
+}
+
+func Test_JsonPathMethod_WithBigIntegerUserProvidedNumber(t *testing.T) {
+
+	RegisterTestingT(t)
+	res := jsonPath("$.registrant", `{"registrant":"0009007199254740999"}`)
+	Expect(res).To(Equal("0009007199254740999"))
+}
+
+func Test_JsonPathMethod_WithWordContainingEe(t *testing.T) {
+
+	RegisterTestingT(t)
+	res := jsonPath("$.registrant", `{"registrant":"ETest"}`)
+	Expect(res).To(Equal("ETest"))
+}
+
 func Test_Identical_ReturnsTrue_WithExactlySameArray(t *testing.T) {
 	RegisterTestingT(t)
 	first := [2]string{"q1", "q2"}