Patch the return time with MaxInt64 in robustness test

Reference:
- #19579

Signed-off-by: Chun-Hung Tseng <[email protected]>

Author: Chun-Hung Tseng

tests/robustness/model/history.go

@@ -290,8 +290,6 @@ func (h *AppendableHistory) appendFailed(request EtcdRequest, start, end time.Du
 	}
 	isRead := request.IsRead()
 	if !isRead {
-		// Failed writes can still be persisted, setting -1 for now as don't know when request has took effect.
-		op.Return = -1
 		// Operations of single client needs to be sequential.
 		// As we don't know return time of failed operations, all new writes need to be done with new stream id.
 		h.streamID = h.idProvider.NewStreamID()
@@ -300,7 +298,7 @@ func (h *AppendableHistory) appendFailed(request EtcdRequest, start, end time.Du
 }
 
 func (h *AppendableHistory) append(op porcupine.Operation) {
-	if op.Return != -1 && op.Call >= op.Return {
+	if op.Call >= op.Return {
 		panic(fmt.Sprintf("Invalid operation, call(%d) >= return(%d)", op.Call, op.Return))
 	}
 	if len(h.operations) > 0 {
@@ -488,36 +486,10 @@ func (h History) Len() int {
 
 func (h History) Operations() []porcupine.Operation {
 	operations := make([]porcupine.Operation, 0, len(h.operations))
-	maxTime := h.lastObservedTime()
-	for _, op := range h.operations {
-		// Failed requests don't have a known return time.
-		if op.Return == -1 {
-			// Simulate Infinity by using last observed time.
-			op.Return = maxTime + time.Second.Nanoseconds()
-		}
-		operations = append(operations, op)
-	}
+	operations = append(operations, h.operations...)
 	return operations
 }
 
-func (h History) lastObservedTime() int64 {
-	var maxTime int64
-	for _, op := range h.operations {
-		if op.Return == -1 {
-			// Collect call time from failed operations
-			if op.Call > maxTime {
-				maxTime = op.Call
-			}
-		} else {
-			// Collect return time from successful operations
-			if op.Return > maxTime {
-				maxTime = op.Return
-			}
-		}
-	}
-	return maxTime
-}
-
 func (h History) MaxRevision() int64 {
 	var maxRevision int64
 	for _, op := range h.operations {

tests/robustness/validate/patch_history.go

@@ -16,6 +16,7 @@ package validate
 
 import (
 	"fmt"
+	"math"
 
 	"github.com/anishathalye/porcupine"
 
@@ -29,7 +30,9 @@ func patchLinearizableOperations(reports []report.ClientReport, persistedRequest
 	persistedPutCount := countPersistedPuts(persistedRequests)
 	clientPutCount := countClientPuts(reports)
 	putReturnTime := uniquePutReturnTime(allOperations, reports, persistedRequests, clientPutCount)
-	return patchOperations(allOperations, putRevision, putReturnTime, clientPutCount, persistedPutCount)
+	patchedOperations := patchOperations(allOperations, putRevision, putReturnTime, clientPutCount, persistedPutCount)
+	patchFailedOperations(&patchedOperations)
+	return patchedOperations
 }
 
 func relevantOperations(reports []report.ClientReport) []porcupine.Operation {
@@ -239,6 +242,17 @@ func uniquePutReturnTime(allOperations []porcupine.Operation, reports []report.C
 	return earliestReturnTime
 }
 
+// Failed writes can still be persisted, but we don't know when request has took effect, so we override it with MaxInt64
+func patchFailedOperations(operations *[]porcupine.Operation) {
+	for opIdx := range *operations {
+		request := (*operations)[opIdx].Input.(model.EtcdRequest)
+		resp := (*operations)[opIdx].Output.(model.MaybeEtcdResponse)
+		if resp.Error != "" && !request.IsRead() {
+			(*operations)[opIdx].Return = math.MaxInt64
+		}
+	}
+}
+
 func countClientPuts(reports []report.ClientReport) map[keyValue]int64 {
 	counter := map[keyValue]int64{}
 	for _, client := range reports {