Fix Details dialog with no payload entries (#172)

* add logging, ensure seekKey is not a reference but a duplicate

* add unit test at GetResPayload level

* fix failing unit test

pkg/sloop/queries/eventquery_test.go

@@ -91,7 +91,7 @@ func Test_GetEventData_True(t *testing.T) {
 	values := helper_get_params()
 	values[KindParam] = []string{"someKinda"}
 	values[NamespaceParam] = []string{"someNamespace"}
-	values[NameParam] = []string{"someName"}
+	values[NameParam] = []string{"someName.xx"}
 	var keys []string
 	keys = append(keys, typed.NewWatchTableKey(partitionId, "Event", "someNamespace", "someName.xx", someTs).String())
 	keys = append(keys, typed.NewWatchTableKey(partitionId, "Event", "someNamespaceb", "someName.xx", someTs).String())

pkg/sloop/queries/respayloadquery.go

@@ -21,6 +21,10 @@ import (
 	"time"
 )
 
+const (
+	glogVerbose = 10
+)
+
 type ResPayLoadData struct {
 	PayloadList []PayloadOuput `json:"payloadList"`
 }
@@ -32,6 +36,8 @@ type PayloadOuput struct {
 }
 
 func GetResPayload(params url.Values, t typed.Tables, startTime time.Time, endTime time.Time, requestId string) ([]byte, error) {
+
+	glog.V(glogVerbose).Infof("GetResPayload: startTime: %v, endTime: %v", startTime.Unix(), endTime.Unix())
 	var watchRes map[typed.WatchTableKey]*typed.KubeWatchResult
 	var previousKey *typed.WatchTableKey
 	var previousVal *typed.KubeWatchResult
@@ -40,32 +46,40 @@ func GetResPayload(params url.Values, t typed.Tables, startTime time.Time, endTi
 		var stats typed.RangeReadStats
 
 		keyComparator := getKeyComparator(params)
+		glog.V(glogVerbose).Infof("GetResPayload: keyComparator: %v", keyComparator.String())
 		valPredFn := typed.KubeWatchResult_ValPredicateFns(isResPayloadInTimeRange(startTime, endTime))
 
 		var rangeReadErr error
 		watchRes, _, rangeReadErr = t.WatchTable().RangeRead(txn, keyComparator, nil, valPredFn, startTime, endTime)
 		if rangeReadErr != nil {
+			glog.V(glogVerbose).Infof("GetResPayload: range read error: %v", rangeReadErr)
 			return rangeReadErr
 		}
+		glog.V(glogVerbose).Infof("GetResPayload: range read found: %v payload", len(watchRes))
 
 		// get the previous key for those who has same payload but just before startTime
 		var getPreviousErr error
 		seekKey := getSeekKey(keyComparator, startTime)
+		glog.V(glogVerbose).Infof("GetResPayload: seekKey: %v", seekKey.String())
 		previousKey, getPreviousErr = t.WatchTable().GetPreviousKey(txn, seekKey, keyComparator)
 
 		// when getPreviousErr is not nil, we will not return err since it is ok we did not find previous key from startTime,
 		// we can continue using the result from rangeRead to proceed the rest payload
 		if getPreviousErr == nil {
+			glog.V(glogVerbose).Infof("GetResPayload: previousKey: %v", previousKey.String())
 			var getErr error
 			previousVal, getErr = t.WatchTable().Get(txn, previousKey.String())
 			if getErr == nil {
 				watchRes[*previousKey] = previousVal
 			} else {
+				glog.V(glogVerbose).Infof("GetResPayload: getErr: %v", getErr)
 				// we need to return error when getErr is not nil and its error is not keyNotFound
 				if getErr != badger.ErrKeyNotFound {
 					return getErr
 				}
 			}
+		} else {
+			glog.V(glogVerbose).Infof("GetResPayload: no previous key found. seekKey: %v, err: %v", seekKey.String(), getPreviousErr)
 		}
 
 		stats.Log(requestId)
@@ -91,11 +105,11 @@ func GetResPayload(params url.Values, t typed.Tables, startTime time.Time, endTi
 	return bytes, nil
 }
 
-//todo: add unit tests
 func getSeekKey(keyComparator *typed.WatchTableKey, startTime time.Time) *typed.WatchTableKey {
-	seekKey := keyComparator
-	seekKey.PartitionId = untyped.GetPartitionId(startTime)
-	seekKey.Timestamp = startTime
+	kind := keyComparator.Kind
+	namespace := keyComparator.Namespace
+	name := keyComparator.Name
+	seekKey := typed.NewWatchTableKey(untyped.GetPartitionId(startTime), kind, namespace, name, startTime)
 	return seekKey
 }
 
@@ -136,7 +150,10 @@ func removeDupePayloads(payloads []PayloadOuput) []PayloadOuput {
 	lastPayload := ""
 	for _, val := range payloads {
 		if val.Payload != lastPayload {
+			glog.V(glogVerbose).Infof("removeDupePayloads: found key: %v", len(val.PayloadKey))
 			ret = append(ret, val)
+		} else {
+			glog.V(glogVerbose).Infof("removeDupePayloads: duplicate key: %v", len(val.PayloadKey))
 		}
 		lastPayload = val.Payload
 	}

pkg/sloop/queries/respayloadquery_test.go

@@ -212,3 +212,52 @@ func Test_GetResPayload_True_HasSamePrefix(t *testing.T) {
 ]`
 	assertex.JsonEqual(t, expectedRes, string(res))
 }
+
+func Test_GetResPayload_NoDataInTimeRangeStillFindsPayload(t *testing.T) {
+	untyped.TestHookSetPartitionDuration(time.Hour)
+	partitionId := untyped.GetPartitionId(someTs)
+	values := helper_get_params()
+	expectedKind := "someKind"
+	expectedNS := "someNamespace"
+	expectedName := "someName"
+	values[KindParam] = []string{expectedKind}
+	values[NamespaceParam] = []string{expectedNS}
+	values[NameParam] = []string{expectedName}
+
+	var keys []string
+	keys = append(keys, typed.NewWatchTableKey(partitionId, expectedKind, expectedNS, expectedName, someTs).String())
+	tables := helper_get_resPayload(keys, t, somePTime)
+
+	queryTs := someTs.Add(5 * time.Hour)
+	res, err := GetResPayload(values, tables, queryTs.Add(-15*time.Minute), queryTs.Add(15*time.Minute), someRequestId)
+	assert.Nil(t, err)
+	expectedRes := `[
+ {
+  "payloadTime": 1546398245000000006,
+  "payload": "{\n  \"metadata\": {\n    \"name\": \"someName\",\n    \"namespace\": \"someNamespace\",\n    \"uid\": \"6c2a9795-a282-11e9-ba2f-14187761de09\",\n    \"creationTimestamp\": \"2019-07-09T19:47:45Z\"\n  }\n}",
+  "payloadKey": "/watch/001546398000/someKind/someNamespace/someName/1546398245000000006"
+ }
+]`
+	assertex.JsonEqual(t, expectedRes, string(res))
+}
+
+func Test_getSeekKey(t *testing.T) {
+	untyped.TestHookSetPartitionDuration(time.Hour)
+
+	keyTime := time.Now().Add(-3 * untyped.GetPartitionDuration())
+	seekTime := time.Now()
+	assert.NotEqual(t, untyped.GetPartitionId(keyTime), untyped.GetPartitionId(seekTime))
+
+	// returns COPY populated with contents from source & adjusts for new time
+	keyComparator := typed.NewWatchTableKey(untyped.GetPartitionId(keyTime), "k", "ns", "n", keyTime)
+	seekKey := getSeekKey(keyComparator, seekTime)
+	assert.Equal(t, untyped.GetPartitionId(seekTime), seekKey.PartitionId)
+	assert.Equal(t, keyComparator.Kind, seekKey.Kind)
+	assert.Equal(t, keyComparator.Namespace, seekKey.Namespace)
+	assert.Equal(t, keyComparator.Name, seekKey.Name)
+	assert.Equal(t, seekTime, seekKey.Timestamp)
+
+	// doesn't touch original!
+	assert.Equal(t, untyped.GetPartitionId(keyTime), keyComparator.PartitionId)
+	assert.Equal(t, keyTime, keyComparator.Timestamp)
+}