Skip to content

Commit

Permalink
feat: added tests for hex array decoding and regex functions
Browse files Browse the repository at this point in the history
  • Loading branch information
@Yashk767
Yashk767 committed Dec 20, 2023
1 parent 59c0651 commit d8240d1
Show file tree
Hide file tree
Showing 2 changed files with 277 additions and 2 deletions.
17 changes: 15 additions & 2 deletions utils/asset_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -658,11 +658,16 @@ func TestGetDataToCommitFromJob(t *testing.T) {
Url: "https://api.gemini.com/v1/pubticker/ethusd/apiKey=${SAMPLE_API_KEY_NEW}",
}

postJob := bindings.StructsJob{Id: 1, SelectorType: 0, Weight: 100,
postJobUniswapV3 := bindings.StructsJob{Id: 1, SelectorType: 0, Weight: 100,
Power: 2, Name: "ethusd_sample", Selector: "result",
Url: `{"type": "POST","url": "https://rpc.ankr.com/eth","body": {"jsonrpc":"2.0","method":"eth_call","params":[{"to":"0xb27308f9f90d607463bb33ea1bebb41c27ce5ab6","data":"0xf7729d43000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb480000000000000000000000000000000000000000000000000000000000000bb80000000000000000000000000000000000000000000000000de0b6b3a76400000000000000000000000000000000000000000000000000000000000000000000"},"latest"],"id":5},"header": {"content-type": "application/json"}, "returnType": "hex"}`,
}

postJobUniswapV2 := bindings.StructsJob{Id: 1, SelectorType: 0, Weight: 100,
Power: 6, Name: "ethusd_sample", Selector: "result",
Url: `{"type": "POST","url": "https://rpc.ankr.com/eth","body": {"jsonrpc":"2.0","id":7269270904970082,"method":"eth_call","params":[{"from":"0x0000000000000000000000000000000000000000","data":"0xd06ca61f0000000000000000000000000000000000000000000000000de0b6b3a76400000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000200000000000000000000000050de6856358cc35f3a9a57eaaa34bd4cb707d2cd0000000000000000000000008e870d67f660d95d5be530380d0ec0bd388289e1","to":"0x7a250d5630b4cf539739df2c5dacb4c659f2488d"},"latest"]},"header": {"content-type": "application/json"}, "returnType": "hexArray[1]"}`,
}

invalidDataSourceStructJob := bindings.StructsJob{Id: 1, SelectorType: 0, Weight: 100,
Power: 2, Name: "ethusd_sample", Selector: "result",
Url: `{"type": true,"url1": {}}`,
Expand Down Expand Up @@ -700,7 +705,7 @@ func TestGetDataToCommitFromJob(t *testing.T) {
{
name: "Test 3: When GetDataToCommitFromJob() executes successfully for a POST Job",
args: args{
job: postJob,
job: postJobUniswapV3,
},
wantErr: false,
},
Expand All @@ -720,6 +725,14 @@ func TestGetDataToCommitFromJob(t *testing.T) {
want: nil,
wantErr: true,
},
{
name: "Test 6: When GetDataToCommitFromJob() executes successfully for a POST uniswap v2 Job",
args: args{
job: postJobUniswapV2,
},
want: nil,
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
Expand Down
262 changes: 262 additions & 0 deletions utils/math_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1035,3 +1035,265 @@ func TestConvertHexToBigFloat(t *testing.T) {
})
}
}

func TestHandleHexArray(t *testing.T) {
type args struct {
hexStr string
returnType string
}
tests := []struct {
name string
args args
want *big.Float
wantErr bool
}{
{
name: "Test 1: Valid token price input",
args: args{
hexStr: "0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000de0b6b3a76400000000000000000000000000000000000000000000000000000012aee97c8ee4b8",
returnType: "hexArray[1]",
},
want: big.NewFloat(0.00525886742),
wantErr: false,
},
{
name: "Test 2: Valid another token price input",
args: args{
hexStr: "0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000de0b6b3a764000000000000000000000000000000000000000000000000000000000000000ba121",
returnType: "hexArray[1]",
},
want: big.NewFloat(0.000000000000762145),
wantErr: false,
},
{
name: "Test 3: Invalid hex string",
args: args{
hexStr: "0x00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000002",
returnType: "hexArray[1]",
},
want: big.NewFloat(0),
wantErr: true,
},
{
name: "Test 4: Invalid return type to extract index",
args: args{
hexStr: "0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000de0b6b3a76400000000000000000000000000000000000000000000000000000012aee97c8ee4b8",
returnType: "hexArray[1a]",
},
want: big.NewFloat(0),
wantErr: true,
},
{
name: "Test 5: When decoded value of data is 0, wei to eth conversion will throw error",
args: args{
hexStr: "0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000",
returnType: "hexArray[0]",
},
want: big.NewFloat(0),
wantErr: true,
},
{
name: "Test 6: When extracted index is out of bounds",
args: args{
hexStr: "0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000",
returnType: "hexArray[1]",
},
want: big.NewFloat(0),
wantErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := HandleHexArray(tt.args.hexStr, tt.args.returnType)
if (err != nil) != tt.wantErr {
t.Errorf("HandleHexArray() error = %v, wantErr %v", err, tt.wantErr)
return
}
// Use a small tolerance for comparison
tolerance := big.NewFloat(1e-10).SetPrec(1024)

diff := new(big.Float).Sub(got, tt.want)
diff.Abs(diff)

// Check if the difference is greater than or equal to tolerance
if diff.Cmp(tolerance) >= 0 {
t.Errorf("HandleHexArray() got = %v, want %v, difference = %v", got, tt.want, diff)
}
})
}
}

func Test_decodeHexString(t *testing.T) {
type args struct {
hexStr string
}
tests := []struct {
name string
args args
want []*big.Int
wantErr bool
}{
{
name: "Valid hex string which is a result from uniswap v2 datasource",
args: args{hexStr: "0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000de0b6b3a76400000000000000000000000000000000000000000000000000000012aee97c8ee4b8"},
want: []*big.Int{
big.NewInt(1000000000000000000),
big.NewInt(5258867421144248),
},
wantErr: false,
},
{
name: "Valid single element",
args: args{hexStr: "0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001"},
want: []*big.Int{big.NewInt(1)},
wantErr: false,
},
{
name: "Valid hex string is provided but length of array doesnt match",
args: args{hexStr: "0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000de0b6b3a7640000"},
want: nil,
wantErr: true,
},
{
name: "Invalid hex string",
args: args{hexStr: "0x12345"},
want: nil,
wantErr: true,
},
{
name: "Invalid length field",
args: args{hexStr: "0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000Z"},
want: nil,
wantErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := decodeHexString(tt.args.hexStr)
if (err != nil) != tt.wantErr {
t.Errorf("decodeHexString() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("decodeHexString() got = %v, want %v", got, tt.want)
}
})
}
}

func Test_extractIndex(t *testing.T) {
type args struct {
s string
}
tests := []struct {
name string
args args
want int
wantErr bool
}{
{
name: "Valid input with index 1",
args: args{s: "hexArray[1]"},
want: 1,
wantErr: false,
},
{
name: "Valid input with index 123",
args: args{s: "hexArray[123]"},
want: 123,
wantErr: false,
},
{
name: "Invalid input - missing brackets",
args: args{s: "hexArray1"},
want: 0,
wantErr: true,
},
{
name: "Invalid input - non-numeric index",
args: args{s: "hexArray[abc]"},
want: 0,
wantErr: true,
},
{
name: "Invalid input - negative index",
args: args{s: "hexArray[-1]"},
want: 0,
wantErr: true,
},
{
name: "Invalid input - empty string",
args: args{s: ""},
want: 0,
wantErr: true,
},
}

for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := extractIndex(tt.args.s)
if (err != nil) != tt.wantErr {
t.Errorf("extractIndex() error = %v, wantErr %v", err, tt.wantErr)
return
}
if got != tt.want {
t.Errorf("extractIndex() got = %v, want %v", got, tt.want)
}
})
}
}

func Test_isHexArrayPattern(t *testing.T) {
type args struct {
s string
}
tests := []struct {
name string
args args
want bool
}{
{
name: "Valid pattern with index 0",
args: args{s: "hexArray[0]"},
want: true,
},
{
name: "Valid pattern with index 123",
args: args{s: "hexArray[123]"},
want: true,
},
{
name: "Invalid pattern - missing brackets",
args: args{s: "hexArray1"},
want: false,
},
{
name: "Invalid pattern - non-numeric index",
args: args{s: "hexArray[abc]"},
want: false,
},
{
name: "Invalid pattern - negative index",
args: args{s: "hexArray[-1]"},
want: false,
},
{
name: "Invalid pattern - empty string",
args: args{s: ""},
want: false,
},
{
name: "Invalid pattern - extra characters",
args: args{s: "hexArray[10]abc"},
want: false,
},
// Additional test cases can be added here.
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := isHexArrayPattern(tt.args.s); got != tt.want {
t.Errorf("isHexArrayPattern() = %v, want %v", got, tt.want)
}
})
}
}

0 comments on commit d8240d1

Please sign in to comment.