CR's fixes: test only public API

Kava-Labs · May 3, 2024 · fe885c3 · fe885c3
1 parent 770e0ba
commit fe885c3
Showing 1 changed file with 64 additions and 40 deletions.
diff --git a/x/evm/types/params_test.go b/x/evm/types/params_test.go
@@ -245,89 +245,113 @@ func TestCheckIfEnabledPrecompilesAreRegistered(t *testing.T) {
 	}
 }
 
-func TestCheckIfSortedInBytesRepr(t *testing.T) {
-	addr1 := common.HexToAddress("0x1000000000000000000000000000000000000000")
-	addr2 := common.HexToAddress("0x2000000000000000000000000000000000000000")
+func TestEnabledPrecompilesOrderInBytesRepr(t *testing.T) {
+	addr1 := "0x1000000000000000000000000000000000000000"
+	addr2 := "0x2000000000000000000000000000000000000000"
 
 	// NOTE: we sort in bytes representation, so proper order will be []string{mixedCaseAddr, upperCaseAddr},
 	// and it differs from lexicographically sorted strings
-	upperCaseAddr := common.HexToAddress("0xAB00000000000000000000000000000000000000")
-	mixedCaseAddr := common.HexToAddress("0xaA00000000000000000000000000000000000000")
+	upperCaseAddr := "0xAB00000000000000000000000000000000000000"
+	mixedCaseAddr := "0xaA00000000000000000000000000000000000000"
 
 	testCases := []struct {
-		name   string
-		addrs  []common.Address
-		sorted bool
+		name      string
+		getParams func() Params
+		errorMsg  string
 	}{
 		{
-			name:   "success: addresses are sorted",
-			addrs:  []common.Address{addr1, addr2},
-			sorted: true,
+			name: "success: addresses are sorted",
+			getParams: func() Params {
+				params := DefaultParams()
+				params.EnabledPrecompiles = []string{addr1, addr2}
+				return params
+			},
+			errorMsg: "",
 		},
 		{
-			name:   "failure: addresses are in reverse order",
-			addrs:  []common.Address{addr2, addr1},
-			sorted: false,
+			name: "failure: addresses are in reverse order",
+			getParams: func() Params {
+				params := DefaultParams()
+				params.EnabledPrecompiles = []string{addr2, addr1}
+				return params
+			},
+			errorMsg: "enabled precompiles are not sorted",
 		},
 		{
-			name:   "success: addresses are sorted in bytes representation",
-			addrs:  []common.Address{mixedCaseAddr, upperCaseAddr},
-			sorted: true,
+			name: "success: addresses are sorted in bytes representation",
+			getParams: func() Params {
+				params := DefaultParams()
+				params.EnabledPrecompiles = []string{mixedCaseAddr, upperCaseAddr}
+				return params
+			},
+			errorMsg: "",
 		},
 	}
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			err := checkIfSortedInBytesRepr(tc.addrs)
+			err := tc.getParams().Validate()
 
-			if tc.sorted {
+			if tc.errorMsg == "" {
 				require.NoError(t, err, tc.name)
 			} else {
-				require.Error(t, err, tc.name)
+				require.ErrorContains(t, err, tc.errorMsg, tc.name)
 			}
 		})
 	}
 }
 
-func TestCheckIfUniqueInBytesRepr(t *testing.T) {
-	addr1 := common.HexToAddress("0x1000000000000000000000000000000000000000")
-	addr2 := common.HexToAddress("0x2000000000000000000000000000000000000000")
+func TestEnabledPrecompilesUniquenessInBytesRepr(t *testing.T) {
+	addr1 := "0x1000000000000000000000000000000000000000"
+	addr2 := "0x2000000000000000000000000000000000000000"
 
 	// NOTE: we check uniqueness in bytes representation, so lowerCaseAddr and mixedCaseAddr are the same,
 	// despite it differs in string representation
-	lowerCaseAddr := common.HexToAddress("0xab00000000000000000000000000000000000000")
-	mixedCaseAddr := common.HexToAddress("0xAb00000000000000000000000000000000000000")
+	lowerCaseAddr := "0xab00000000000000000000000000000000000000"
+	mixedCaseAddr := "0xAb00000000000000000000000000000000000000"
 
 	testCases := []struct {
-		name   string
-		addrs  []common.Address
-		unique bool
+		name      string
+		getParams func() Params
+		errorMsg  string
 	}{
 		{
-			name:   "success: addresses are unique",
-			addrs:  []common.Address{addr1, addr2},
-			unique: true,
+			name: "success: addresses are unique",
+			getParams: func() Params {
+				params := DefaultParams()
+				params.EnabledPrecompiles = []string{addr1, addr2}
+				return params
+			},
+			errorMsg: "",
 		},
 		{
-			name:   "failure: addresses are not unique",
-			addrs:  []common.Address{addr1, addr1},
-			unique: false,
+			name: "failure: addresses are not unique",
+			getParams: func() Params {
+				params := DefaultParams()
+				params.EnabledPrecompiles = []string{addr1, addr1}
+				return params
+			},
+			errorMsg: "enabled precompiles are not unique",
 		},
 		{
-			name:   "failure: addresses are not unique in bytes representation",
-			addrs:  []common.Address{lowerCaseAddr, mixedCaseAddr},
-			unique: false,
+			name: "failure: addresses are not unique in bytes representation",
+			getParams: func() Params {
+				params := DefaultParams()
+				params.EnabledPrecompiles = []string{lowerCaseAddr, mixedCaseAddr}
+				return params
+			},
+			errorMsg: "enabled precompiles are not unique",
 		},
 	}
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			err := checkIfUniqueInBytesRepr(tc.addrs)
+			err := tc.getParams().Validate()
 
-			if tc.unique {
+			if tc.errorMsg == "" {
 				require.NoError(t, err, tc.name)
 			} else {
-				require.Error(t, err, tc.name)
+				require.ErrorContains(t, err, tc.errorMsg, tc.name)
 			}
 		})
 	}