update roundtrip.Check with more features and use in a bunch of places

Author: cce

crypto/onetimesig_test.go

@@ -20,6 +20,9 @@ import (
 	"fmt"
 	"testing"
 
+	"github.com/stretchr/testify/require"
+
+	"github.com/algorand/go-algorand/data/basics/testing/roundtrip"
 	"github.com/algorand/go-algorand/test/partitiontest"
 )
 
@@ -140,6 +143,28 @@ func testOneTimeSignVerifyNewStyle(t *testing.T, c *OneTimeSignatureSecrets, c2
 	}
 }
 
+func TestHeartbeatProofRoundTrip(t *testing.T) {
+	partitiontest.PartitionTest(t)
+
+	toOTS := func(h HeartbeatProof) OneTimeSignature { return h.ToOneTimeSignature() }
+	toProof := func(ots OneTimeSignature) HeartbeatProof { return ots.ToHeartbeatProof() }
+
+	proofs := []HeartbeatProof{{}}
+	for i := 0; i < 5; i++ {
+		var p HeartbeatProof
+		RandBytes(p.Sig[:])
+		RandBytes(p.PK[:])
+		RandBytes(p.PK2[:])
+		RandBytes(p.PK1Sig[:])
+		RandBytes(p.PK2Sig[:])
+		proofs = append(proofs, p)
+	}
+
+	for _, proof := range proofs {
+		require.True(t, roundtrip.Check(t, proof, toOTS, toProof), proof)
+	}
+}
+
 func BenchmarkOneTimeSigBatchVerification(b *testing.B) {
 	for _, enabled := range []bool{false, true} {
 		b.Run(fmt.Sprintf("batch=%v", enabled), func(b *testing.B) {

daemon/algod/api/server/v2/account_test.go

@@ -25,11 +25,31 @@ import (
 	"github.com/algorand/go-algorand/config"
 	"github.com/algorand/go-algorand/daemon/algod/api/server/v2/generated/model"
 	"github.com/algorand/go-algorand/data/basics"
+	"github.com/algorand/go-algorand/data/basics/testing/roundtrip"
 	ledgertesting "github.com/algorand/go-algorand/ledger/testing"
 	"github.com/algorand/go-algorand/protocol"
 	"github.com/algorand/go-algorand/test/partitiontest"
 )
 
+// makeAccountConverters creates conversion functions for round-trip testing between
+// basics.AccountData and model.Account.
+func makeAccountConverters(t *testing.T, addrStr string, round basics.Round, proto *config.ConsensusParams, withoutRewards basics.MicroAlgos) (
+	toModel func(basics.AccountData) model.Account,
+	toBasics func(model.Account) basics.AccountData,
+) {
+	toModel = func(ad basics.AccountData) model.Account {
+		converted, err := AccountDataToAccount(addrStr, &ad, round, proto, withoutRewards)
+		require.NoError(t, err)
+		return converted
+	}
+	toBasics = func(acc model.Account) basics.AccountData {
+		converted, err := AccountToAccountData(&acc)
+		require.NoError(t, err)
+		return converted
+	}
+	return toModel, toBasics
+}
+
 func TestAccount(t *testing.T) {
 	partitiontest.PartitionTest(t)
 	t.Parallel()
@@ -106,8 +126,9 @@ func TestAccount(t *testing.T) {
 	b := a.WithUpdatedRewards(proto.RewardUnit, 100)
 
 	addr := basics.Address{}.String()
-	conv, err := AccountDataToAccount(addr, &b, round, &proto, a.MicroAlgos)
-	require.NoError(t, err)
+	toModel, toBasics := makeAccountConverters(t, addr, round, &proto, a.MicroAlgos)
+
+	conv := toModel(b)
 	require.Equal(t, addr, conv.Address)
 	require.Equal(t, b.MicroAlgos.Raw, conv.Amount)
 	require.Equal(t, a.MicroAlgos.Raw, conv.AmountWithoutPendingRewards)
@@ -145,6 +166,21 @@ func TestAccount(t *testing.T) {
 	verifyCreatedApp(0, appIdx1, appParams1)
 	verifyCreatedApp(1, appIdx2, appParams2)
 
+	appRoundTrip := func(idx basics.AppIndex, params basics.AppParams) {
+		require.True(t, roundtrip.Check(t, params,
+			func(ap basics.AppParams) model.Application {
+				return AppParamsToApplication(addr, idx, &ap)
+			},
+			func(app model.Application) basics.AppParams {
+				converted, err := ApplicationParamsToAppParams(&app.Params)
+				require.NoError(t, err)
+				return converted
+			}))
+	}
+
+	appRoundTrip(appIdx1, appParams1)
+	appRoundTrip(appIdx2, appParams2)
+
 	makeTKV := func(k string, v interface{}) model.TealKeyValue {
 		value := model.TealValue{}
 		switch v.(type) {
@@ -198,9 +234,7 @@ func TestAccount(t *testing.T) {
 	verifyCreatedAsset(0, assetIdx1, assetParams1)
 	verifyCreatedAsset(1, assetIdx2, assetParams2)
 
-	c, err := AccountToAccountData(&conv)
-	require.NoError(t, err)
-	require.Equal(t, b, c)
+	require.True(t, roundtrip.Check(t, b, toModel, toBasics))
 
 	t.Run("IsDeterministic", func(t *testing.T) {
 		// convert the same account a few more times to make sure we always
@@ -223,11 +257,91 @@ func TestAccountRandomRoundTrip(t *testing.T) {
 		for addr, acct := range accts {
 			round := basics.Round(2)
 			proto := config.Consensus[protocol.ConsensusFuture]
-			conv, err := AccountDataToAccount(addr.String(), &acct, round, &proto, acct.MicroAlgos)
-			require.NoError(t, err)
-			c, err := AccountToAccountData(&conv)
+			toModel, toBasics := makeAccountConverters(t, addr.String(), round, &proto, acct.MicroAlgos)
+			// AccountData has constraints (Status field must be valid), and this test
+			// already uses RandomAccounts to generate valid random accounts
+			require.True(t, roundtrip.Check(t, acct, toModel, toBasics, roundtrip.NoRandomCases()))
+		}
+	}
+}
+
+func TestConvertTealKeyValueRoundTrip(t *testing.T) {
+	partitiontest.PartitionTest(t)
+	t.Parallel()
+
+	t.Run("nil input", func(t *testing.T) {
+		require.Nil(t, convertTKVToGenerated(nil))
+		result, err := convertGeneratedTKV(nil)
+		require.NoError(t, err)
+		require.Nil(t, result)
+	})
+
+	t.Run("empty map treated as nil", func(t *testing.T) {
+		empty := basics.TealKeyValue{}
+		require.Nil(t, convertTKVToGenerated(&empty))
+		result, err := convertGeneratedTKV(convertTKVToGenerated(&empty))
+		require.NoError(t, err)
+		require.Nil(t, result)
+	})
+
+	t.Run("round-trip non-empty map", func(t *testing.T) {
+		kv := basics.TealKeyValue{
+			"alpha": {Type: basics.TealUintType, Uint: 17},
+			"beta":  {Type: basics.TealBytesType, Bytes: "\x00\x01binary"},
+		}
+
+		toGenerated := func(val basics.TealKeyValue) *model.TealKeyValueStore {
+			return convertTKVToGenerated(&val)
+		}
+		toBasics := func(store *model.TealKeyValueStore) basics.TealKeyValue {
+			converted, err := convertGeneratedTKV(store)
 			require.NoError(t, err)
-			require.Equal(t, acct, c)
+			return converted
 		}
+
+		require.True(t, roundtrip.Check(t, kv, toGenerated, toBasics))
+	})
+}
+
+func TestAppLocalStateRoundTrip(t *testing.T) {
+	partitiontest.PartitionTest(t)
+	t.Parallel()
+
+	appIdx := basics.AppIndex(42)
+	cases := map[string]basics.AppLocalState{
+		"empty kv": {
+			Schema:   basics.StateSchema{NumUint: 1, NumByteSlice: 0},
+			KeyValue: nil,
+		},
+		"mixed kv": {
+			Schema: basics.StateSchema{NumUint: 2, NumByteSlice: 3},
+			KeyValue: basics.TealKeyValue{
+				"counter": {Type: basics.TealUintType, Uint: 99},
+				"note":    {Type: basics.TealBytesType, Bytes: "hello world"},
+			},
+		},
+	}
+
+	for name, state := range cases {
+		state := state
+		t.Run(name, func(t *testing.T) {
+			modelState := AppLocalState(state, appIdx)
+			modelStates := []model.ApplicationLocalState{modelState}
+
+			acc := model.Account{
+				Status:         basics.Offline.String(),
+				Amount:         0,
+				AppsLocalState: &modelStates,
+			}
+
+			ad, err := AccountToAccountData(&acc)
+			require.NoError(t, err)
+
+			require.NotNil(t, ad.AppLocalStates)
+			got, ok := ad.AppLocalStates[appIdx]
+			require.True(t, ok)
+			require.Equal(t, state.Schema, got.Schema)
+			require.Equal(t, state.KeyValue, got.KeyValue)
+		})
 	}
 }

daemon/algod/api/server/v2/dryrun_test.go

@@ -32,6 +32,7 @@ import (
 	"github.com/algorand/go-algorand/crypto"
 	"github.com/algorand/go-algorand/daemon/algod/api/server/v2/generated/model"
 	"github.com/algorand/go-algorand/data/basics"
+	"github.com/algorand/go-algorand/data/basics/testing/roundtrip"
 	"github.com/algorand/go-algorand/data/transactions"
 	"github.com/algorand/go-algorand/data/transactions/logic"
 	"github.com/algorand/go-algorand/data/txntest"
@@ -1087,6 +1088,30 @@ func TestStateDeltaToStateDelta(t *testing.T) {
 	gsd := globalDeltaToStateDelta(sd)
 	require.Equal(t, 3, len(gsd))
 
+	decode := func(msd model.StateDelta) basics.StateDelta {
+		if len(msd) == 0 {
+			return nil
+		}
+		result := make(basics.StateDelta, len(msd))
+		for _, kv := range msd {
+			keyBytes, err := base64.StdEncoding.DecodeString(kv.Key)
+			require.NoError(t, err)
+			vd := basics.ValueDelta{Action: basics.DeltaAction(kv.Value.Action)}
+			if kv.Value.Bytes != nil {
+				decoded, err := base64.StdEncoding.DecodeString(*kv.Value.Bytes)
+				require.NoError(t, err)
+				vd.Bytes = string(decoded)
+			}
+			if kv.Value.Uint != nil {
+				vd.Uint = *kv.Value.Uint
+			}
+			result[string(keyBytes)] = vd
+		}
+		return result
+	}
+
+	require.True(t, roundtrip.Check(t, sd, globalDeltaToStateDelta, decode))
+
 	var keys []string
 	// test with a loop because sd is a map and iteration order is random
 	for _, item := range gsd {

data/basics/teal_test.go

@@ -20,10 +20,37 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/require"
+	"pgregory.net/rapid"
 
+	"github.com/algorand/go-algorand/data/basics/testing/roundtrip"
 	"github.com/algorand/go-algorand/test/partitiontest"
 )
 
+// genTealValue generates a valid TealValue with proper Type/field correspondence.
+func genTealValue() *rapid.Generator[TealValue] {
+	return rapid.Custom(func(t *rapid.T) TealValue {
+		tealType := rapid.OneOf(rapid.Just(TealUintType), rapid.Just(TealBytesType)).Draw(t, "type")
+
+		if tealType == TealUintType {
+			return TealValue{Type: TealUintType, Uint: rapid.Uint64().Draw(t, "uint")}
+		}
+		return TealValue{Type: TealBytesType, Bytes: rapid.String().Draw(t, "bytes")}
+	})
+}
+
+// genValueDelta generates a valid ValueDelta with proper Action/field correspondence.
+// Note: DeleteAction is excluded as it doesn't round-trip to TealValue.
+func genValueDelta() *rapid.Generator[ValueDelta] {
+	return rapid.Custom(func(t *rapid.T) ValueDelta {
+		action := rapid.OneOf(rapid.Just(SetUintAction), rapid.Just(SetBytesAction)).Draw(t, "action")
+
+		if action == SetUintAction {
+			return ValueDelta{Action: SetUintAction, Uint: rapid.Uint64().Draw(t, "uint")}
+		}
+		return ValueDelta{Action: SetBytesAction, Bytes: rapid.String().Draw(t, "bytes")}
+	})
+}
+
 func TestStateDeltaEqual(t *testing.T) {
 	partitiontest.PartitionTest(t)
 
@@ -60,3 +87,45 @@ func TestStateDeltaEqual(t *testing.T) {
 	d2 = StateDelta{"test": {Action: SetBytesAction, Bytes: "val1"}}
 	a.False(d1.Equal(d2))
 }
+
+func TestTealValueRoundTrip(t *testing.T) {
+	partitiontest.PartitionTest(t)
+
+	// Test with a simple example value
+	example := TealValue{Type: TealUintType, Uint: 17}
+
+	// Use roundtrip.Check with WithRapid for property-based testing
+	require.True(t, roundtrip.Check(t, example,
+		func(tv TealValue) ValueDelta { return tv.ToValueDelta() },
+		func(vd ValueDelta) TealValue {
+			tv, ok := vd.ToTealValue()
+			require.True(t, ok)
+			return tv
+		},
+		roundtrip.WithRapid(genTealValue())))
+}
+
+func TestValueDeltaRoundTrip(t *testing.T) {
+	partitiontest.PartitionTest(t)
+
+	// Test with a simple example value
+	example := ValueDelta{Action: SetUintAction, Uint: 42}
+
+	// Use roundtrip.Check with WithRapid for property-based testing
+	require.True(t, roundtrip.Check(t, example,
+		func(vd ValueDelta) TealValue {
+			tv, ok := vd.ToTealValue()
+			require.True(t, ok)
+			return tv
+		},
+		func(tv TealValue) ValueDelta { return tv.ToValueDelta() },
+		roundtrip.WithRapid(genValueDelta())))
+}
+
+func TestValueDeltaDeleteDoesNotRoundTrip(t *testing.T) {
+	partitiontest.PartitionTest(t)
+
+	vd := ValueDelta{Action: DeleteAction}
+	_, ok := vd.ToTealValue()
+	require.False(t, ok)
+}

ledger/store/trackerdb/data_test.go

@@ -27,6 +27,7 @@ import (
 	"github.com/algorand/go-algorand/crypto"
 	"github.com/algorand/go-algorand/data/basics"
 	basics_testing "github.com/algorand/go-algorand/data/basics/testing"
+	"github.com/algorand/go-algorand/data/basics/testing/roundtrip"
 	"github.com/algorand/go-algorand/ledger/ledgercore"
 	ledgertesting "github.com/algorand/go-algorand/ledger/testing"
 	"github.com/algorand/go-algorand/protocol"
@@ -1292,7 +1293,7 @@ func TestCopyFunctions(t *testing.T) {
 		return rd.GetAssetParams()
 	}
 	for _, nz := range basics_testing.NearZeros(t, basics.AssetParams{}) {
-		assert.True(t, basics_testing.RoundTrip(t, nz, assetToRD, rdToAsset), nz)
+		assert.True(t, roundtrip.Check(t, nz, assetToRD, rdToAsset), nz)
 	}
 
 	// Asset holdings are copied into and out of ResourceData losslessly
@@ -1305,7 +1306,7 @@ func TestCopyFunctions(t *testing.T) {
 		return rd.GetAssetHolding()
 	}
 	for _, nz := range basics_testing.NearZeros(t, basics.AssetHolding{}) {
-		assert.True(t, basics_testing.RoundTrip(t, nz, holdingToRD, rdToHolding), nz)
+		assert.True(t, roundtrip.Check(t, nz, holdingToRD, rdToHolding), nz)
 	}
 
 	// AppParams are copied into and out of ResourceData losslessly
@@ -1318,7 +1319,7 @@ func TestCopyFunctions(t *testing.T) {
 		return rd.GetAppParams()
 	}
 	for _, nz := range basics_testing.NearZeros(t, basics.AppParams{}) {
-		assert.True(t, basics_testing.RoundTrip(t, nz, apToRD, rdToAP), nz)
+		assert.True(t, roundtrip.Check(t, nz, apToRD, rdToAP), nz)
 	}
 
 	// AppLocalStates are copied into and out of ResourceData losslessly
@@ -1331,7 +1332,7 @@ func TestCopyFunctions(t *testing.T) {
 		return rd.GetAppLocalState()
 	}
 	for _, nz := range basics_testing.NearZeros(t, basics.AppLocalState{}) {
-		assert.True(t, basics_testing.RoundTrip(t, nz, localsToRD, rdToLocals), nz)
+		assert.True(t, roundtrip.Check(t, nz, localsToRD, rdToLocals), nz)
 	}
 
 }