Support $currentDate field update operator

integration/helpers.go

@@ -76,7 +76,7 @@ func Convert(t testing.TB, v any) any {
 	case int32:
 		return v
 	case primitive.Timestamp:
-		return types.Timestamp(uint64(v.I)<<32 + uint64(v.T))
+		return types.NewTimestamp(uint64(v.T), uint64(v.I))
 	case int64:
 		return v
 	default:

integration/update_test.go

@@ -17,14 +17,18 @@ package integration
 import (
 	"math"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/bson/primitive"
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
 
 	"github.com/FerretDB/FerretDB/integration/shareddata"
+	"github.com/FerretDB/FerretDB/internal/types"
+	"github.com/FerretDB/FerretDB/internal/util/testutil"
 )
 
 func TestUpdateUpsert(t *testing.T) {
@@ -673,3 +677,211 @@ func TestUpdateMany(t *testing.T) {
 		})
 	}
 }
+
+func TestCurrentDate(t *testing.T) {
+	t.Parallel()
+
+	// maxTimeDelta is a maximum amount of seconds can differ the value in placeholder from actual value
+	maxTimeDelta := time.Duration(30 * time.Second)
+
+	now := primitive.NewDateTimeFromTime(time.Now().UTC())
+	nowTimestamp := primitive.Timestamp{T: uint32(time.Now().UTC().Unix()), I: uint32(0)}
+
+	for name, tc := range map[string]struct {
+		id     string
+		update bson.D
+		result bson.D
+		paths  []types.Path
+		err    *mongo.WriteError
+		stat   *mongo.UpdateResult
+		alt    string
+	}{
+		"DocumentEmpty": {
+			id:     "double",
+			update: bson.D{{"$currentDate", bson.D{}}},
+			stat: &mongo.UpdateResult{
+				MatchedCount:  1,
+				ModifiedCount: 0,
+				UpsertedCount: 0,
+			},
+			result: bson.D{{"_id", "double"}, {"value", float64(42.13)}},
+		},
+		"Array": {
+			id:     "double",
+			update: bson.D{{"$currentDate", bson.A{}}},
+			err: &mongo.WriteError{
+				Code: 9,
+				Message: "Modifiers operate on fields but we found type array instead. " +
+					"For example: {$mod: {<field>: ...}} not {$currentDate: []}",
+			},
+			alt: "Modifiers operate on fields but we found another type instead",
+		},
+		"WrongInt32": {
+			id:     "double",
+			update: bson.D{{"$currentDate", int32(1)}},
+			err: &mongo.WriteError{
+				Code: 9,
+				Message: "Modifiers operate on fields but we found type int instead. " +
+					"For example: {$mod: {<field>: ...}} not {$currentDate: 1}",
+			},
+			alt: "Modifiers operate on fields but we found another type instead",
+		},
+		"Nil": {
+			id:     "double",
+			update: bson.D{{"$currentDate", nil}},
+			err: &mongo.WriteError{
+				Code: 9,
+				Message: "Modifiers operate on fields but we found type null instead. " +
+					"For example: {$mod: {<field>: ...}} not {$currentDate: null}",
+			},
+			alt: "Modifiers operate on fields but we found another type instead",
+		},
+		"True": {
+			id:     "double",
+			update: bson.D{{"$currentDate", bson.D{{"value", true}}}},
+			stat: &mongo.UpdateResult{
+				MatchedCount:  1,
+				ModifiedCount: 1,
+				UpsertedCount: 0,
+			},
+			paths:  []types.Path{types.NewPathFromString("value")},
+			result: bson.D{{"_id", "double"}, {"value", now}},
+		},
+		"TwoTrue": {
+			id:     "double",
+			update: bson.D{{"$currentDate", bson.D{{"value", true}, {"unexistent", true}}}},
+			stat: &mongo.UpdateResult{
+				MatchedCount:  1,
+				ModifiedCount: 1,
+				UpsertedCount: 0,
+			},
+			paths: []types.Path{
+				types.NewPathFromString("value"),
+				types.NewPathFromString("unexistent"),
+			},
+			result: bson.D{{"_id", "double"}, {"value", now}, {"unexistent", now}},
+		},
+		"False": {
+			id:     "double",
+			update: bson.D{{"$currentDate", bson.D{{"value", false}}}},
+			stat: &mongo.UpdateResult{
+				MatchedCount:  1,
+				ModifiedCount: 1,
+				UpsertedCount: 0,
+			},
+			paths:  []types.Path{types.NewPathFromString("value")},
+			result: bson.D{{"_id", "double"}, {"value", now}},
+		},
+		"Int32": {
+			id:     "double",
+			update: bson.D{{"$currentDate", bson.D{{"value", int32(1)}}}},
+			err: &mongo.WriteError{
+				Code:    2,
+				Message: "int is not valid type for $currentDate. Please use a boolean ('true') or a $type expression ({$type: 'timestamp/date'}).",
+			},
+		},
+		"Timestamp": {
+			id:     "double",
+			update: bson.D{{"$currentDate", bson.D{{"value", bson.D{{"$type", "timestamp"}}}}}},
+			stat: &mongo.UpdateResult{
+				MatchedCount:  1,
+				ModifiedCount: 1,
+				UpsertedCount: 0,
+			},
+			paths:  []types.Path{types.NewPathFromString("value")},
+			result: bson.D{{"_id", "double"}, {"value", nowTimestamp}},
+		},
+		"TimestampCapitalised": {
+			id:     "double",
+			update: bson.D{{"$currentDate", bson.D{{"value", bson.D{{"$type", "Timestamp"}}}}}},
+			err: &mongo.WriteError{
+				Code:    2,
+				Message: "The '$type' string field is required to be 'date' or 'timestamp': {$currentDate: {field : {$type: 'date'}}}",
+			},
+			alt: "The '$type' string field is required to be 'date' or 'timestamp'",
+		},
+		"Date": {
+			id:     "double",
+			update: bson.D{{"$currentDate", bson.D{{"value", bson.D{{"$type", "date"}}}}}},
+			stat: &mongo.UpdateResult{
+				MatchedCount:  1,
+				ModifiedCount: 1,
+				UpsertedCount: 0,
+			},
+			paths:  []types.Path{types.NewPathFromString("value")},
+			result: bson.D{{"_id", "double"}, {"value", now}},
+		},
+		"WrongType": {
+			id:     "double",
+			update: bson.D{{"$currentDate", bson.D{{"value", bson.D{{"$type", bson.D{{"abcd", int32(1)}}}}}}}},
+			err: &mongo.WriteError{
+				Code:    2,
+				Message: "The '$type' string field is required to be 'date' or 'timestamp': {$currentDate: {field : {$type: 'date'}}}",
+			},
+			alt: "The '$type' string field is required to be 'date' or 'timestamp'",
+		},
+		"NoField": {
+			id:     "double",
+			update: bson.D{{"$currentDate", bson.D{{"unexsistent", bson.D{{"$type", "date"}}}}}},
+			stat: &mongo.UpdateResult{
+				MatchedCount:  1,
+				ModifiedCount: 1,
+				UpsertedCount: 0,
+			},
+			paths:  []types.Path{types.NewPathFromString("unexsistent")},
+			result: bson.D{{"_id", "double"}, {"value", 42.13}, {"unexsistent", now}},
+		},
+		"UnrecognizedOption": {
+			id: "array",
+			update: bson.D{{
+				"$currentDate",
+				bson.D{{
+					"value",
+					bson.D{{
+						"array", bson.D{{"unexsistent", bson.D{}}},
+					}},
+				}},
+			}},
+			err: &mongo.WriteError{
+				Code:    2,
+				Message: "Unrecognized $currentDate option: array",
+			},
+		},
+	} {
+		name, tc := name, tc
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+			ctx, collection := setup(t, shareddata.Scalars, shareddata.Composites)
+
+			res, err := collection.UpdateOne(ctx, bson.D{{"_id", tc.id}}, tc.update)
+			if tc.err != nil {
+				require.Nil(t, tc.paths)
+				require.Nil(t, tc.stat)
+				AssertEqualAltWriteError(t, *tc.err, tc.alt, err)
+				return
+			}
+			require.NoError(t, err)
+			require.Equal(t, tc.stat, res)
+
+			var actualB bson.D
+			err = collection.FindOne(ctx, bson.D{{"_id", tc.id}}).Decode(&actualB)
+			require.NoError(t, err)
+
+			expected := ConvertDocument(t, tc.result)
+			actual := ConvertDocument(t, actualB)
+
+			for _, path := range tc.paths {
+				testutil.CompareAndSetByPathTime(
+					t,
+					expected,
+					actual,
+					maxTimeDelta,
+					path,
+				)
+				expected.RemoveByPath(path)
+				actual.RemoveByPath(path)
+			}
+			assert.Equal(t, expected, actual)
+		})
+	}
+}