fix test failures

Author: RIT3shSapata

base/error.go

@@ -83,6 +83,8 @@ var (
 
 	// ErrInvalidJSON is returned when the JSON being unmarshalled cannot be parsed.
 	ErrInvalidJSON = HTTPErrorf(http.StatusBadRequest, "Invalid JSON")
+
+	ErrSyncFnDryRun = &sgError{"Error returned from Sync Function:"}
 )
 
 func (e *sgError) Error() string {

db/crud.go

@@ -1697,36 +1697,15 @@ func (db *DatabaseCollectionWithUser) PutExistingRevWithBody(ctx context.Context
 // SyncFnDryrun Runs a document through the sync function and returns expiry, channels doc was placed in, access map for users, roles, handler errors and sync fn exceptions.
 // If a docID is a non empty string, the document will be fetched from the bucket, otherwise the body will be used. If both are specified, this function returns an error.
 // The first error return value represents an error that occurs before the sync function is run. The second error return value represents an exception from the sync function.
-func (db *DatabaseCollectionWithUser) SyncFnDryrun(ctx context.Context, body Body, docID, syncFn string) (*channels.ChannelMapperOutput, error, error) {
-	doc := &Document{
-		ID:    docID,
-		_body: body,
-	}
-	oldDoc := doc
-	if docID != "" {
-		if docInBucket, err := db.GetDocument(ctx, docID, DocUnmarshalAll); err == nil {
-			oldDoc = docInBucket
-			if len(doc._body) == 0 {
-				body = oldDoc.Body(ctx)
-				doc._body = body
-				// If no body is given, use doc in bucket as doc with no old doc
-				oldDoc._body = nil
-			}
-			doc._body[BodyRev] = oldDoc.SyncData.GetRevTreeID()
-		} else {
-			return nil, err, nil
-		}
-	} else {
-		oldDoc._body = nil
-	}
+func (db *DatabaseCollectionWithUser) SyncFnDryrun(ctx context.Context, oldDoc *Document, body Body, docID, syncFn string) (*channels.ChannelMapperOutput, error) {
 
 	delete(body, BodyId)
 
 	// Get the revision ID to match, and the new generation number:
 	matchRev, _ := body[BodyRev].(string)
 	generation, _ := ParseRevID(ctx, matchRev)
 	if generation < 0 {
-		return nil, base.HTTPErrorf(http.StatusBadRequest, "Invalid revision ID"), nil
+		return nil, base.HTTPErrorf(http.StatusBadRequest, "Invalid revision ID")
 	}
 	generation++
 
@@ -1742,12 +1721,12 @@ func (db *DatabaseCollectionWithUser) SyncFnDryrun(ctx context.Context, body Bod
 
 	err := validateAPIDocUpdate(body)
 	if err != nil {
-		return nil, err, nil
+		return nil, err
 	}
 	bodyWithoutInternalProps, wasStripped := StripInternalProperties(body)
 	canonicalBytesForRevID, err := base.JSONMarshalCanonical(bodyWithoutInternalProps)
 	if err != nil {
-		return nil, err, nil
+		return nil, err
 	}
 
 	// We needed to keep _deleted around in the body until we generated a rev ID, but now we can ditch it.
@@ -1770,30 +1749,33 @@ func (db *DatabaseCollectionWithUser) SyncFnDryrun(ctx context.Context, body Bod
 	mutableBody, metaMap, _, err := db.prepareSyncFn(oldDoc, newDoc)
 	if err != nil {
 		base.InfofCtx(ctx, base.KeyDiagnostic, "Failed to prepare to run sync function: %v", err)
-		return nil, err, nil
+		return nil, err
 	}
 
 	syncOptions, err := MakeUserCtx(db.user, db.ScopeName, db.Name)
 	if err != nil {
-		return nil, err, nil
+		return nil, err
 	}
 	var output *channels.ChannelMapperOutput
 	if syncFn == "" {
 		output, err = db.ChannelMapper.MapToChannelsAndAccess(ctx, mutableBody, string(oldDoc._rawBody), metaMap, syncOptions)
+		if err != nil {
+			err = fmt.Errorf("%s%s", base.ErrSyncFnDryRun, err)
+		}
 	} else {
 		jsTimeout := time.Duration(base.DefaultJavascriptTimeoutSecs) * time.Second
 		syncRunner, err := channels.NewSyncRunner(ctx, syncFn, jsTimeout)
 		if err != nil {
-			return nil, fmt.Errorf("failed to create sync runner: %v", err), nil
+			return nil, fmt.Errorf("failed to create sync runner: %v", err)
 		}
 		jsOutput, err := syncRunner.Call(ctx, mutableBody, string(oldDoc._rawBody), metaMap, syncOptions)
 		if err != nil {
-			return nil, err, nil
+			err = fmt.Errorf("%s%s", base.ErrSyncFnDryRun, err)
 		}
 		output = jsOutput.(*channels.ChannelMapperOutput)
 	}
 
-	return output, nil, err
+	return output, err
 }
 
 // revTreeConflictCheck checks for conflicts in the rev tree history and returns the parent revid, currentRevIndex

rest/diagnostic_doc_api.go

@@ -14,6 +14,7 @@ import (
 	"fmt"
 	"mime"
 	"net/http"
+	"strings"
 
 	"github.com/couchbase/sync_gateway/auth"
 	"github.com/couchbase/sync_gateway/base"
@@ -89,16 +90,33 @@ func (h *handler) handleSyncFnDryRun() error {
 		return base.HTTPErrorf(http.StatusUnprocessableEntity, "Error reading sync function payload: %v", err)
 	}
 
-	output, err, syncFnErr := h.collection.SyncFnDryrun(h.ctx(), syncDryRunPayload.Doc, docid, syncDryRunPayload.Function)
-	if err != nil {
-		return err
+	oldDoc := &db.Document{ID: docid}
+	oldDoc.UpdateBody(syncDryRunPayload.Doc)
+	if docid != "" {
+		if docInbucket, err := h.collection.GetDocument(h.ctx(), docid, db.DocUnmarshalAll); err == nil {
+			oldDoc = docInbucket
+			if len(syncDryRunPayload.Doc) == 0 {
+				syncDryRunPayload.Doc = oldDoc.Body(h.ctx())
+				oldDoc.UpdateBody(nil)
+			}
+		} else {
+			return base.HTTPErrorf(http.StatusNotFound, "Error reading document: %v", err)
+		}
+	} else {
+		oldDoc.UpdateBody(nil)
 	}
-	if syncFnErr != nil {
-		resp := SyncFnDryRun{
-			Exception: syncFnErr.Error(),
+
+	output, err := h.collection.SyncFnDryrun(h.ctx(), oldDoc, syncDryRunPayload.Doc, docid, syncDryRunPayload.Function)
+	if err != nil {
+		if strings.Contains(err.Error(), base.ErrSyncFnDryRun.Error()) {
+			errMsg := strings.ReplaceAll(err.Error(), base.ErrSyncFnDryRun.Error(), "")
+			resp := SyncFnDryRun{
+				Exception: errMsg,
+			}
+			h.writeJSON(resp)
+			return nil
 		}
-		h.writeJSON(resp)
-		return nil
+		return err
 	}
 	errorMsg := ""
 	if output.Rejection != nil {

rest/diagnostic_doc_api_test.go

@@ -1143,7 +1143,7 @@ func TestSyncFuncDryRun(t *testing.T) {
 			existingDocBody: `{"user":{"num":123, "name":["user1"]}, "channel":"channel1"}`,
 			expectedOutput: SyncFnDryRun{
 				Channels:  base.SetFromArray([]string{"channel1"}),
-				Access:    channels.AccessMap{"user1": channels.BaseSetOf(t, "channel1")},
+				Access:    channels.AccessMap{},
 				Roles:     channels.AccessMap{},
 				Exception: "",
 			},