FerretDB · rumyantseva · Apr 18, 2023 · Apr 12, 2023 · Apr 12, 2023 · Apr 12, 2023
@@ -835,6 +835,13 @@ func TestAggregateCompatLimit(t *testing.T) {
 				bson.D{{"$limit", math.MaxInt64}},
 			},
 		},
+		"MinInt64": {
+			pipeline: bson.A{
+				bson.D{{"$sort", bson.D{{"_id", -1}}}},
+				bson.D{{"$limit", math.MinInt64}},
+			},
+			resultType: emptyResult,
+		},
 		"Negative": {
 			pipeline: bson.A{
 				bson.D{{"$sort", bson.D{{"_id", -1}}}},
@@ -1367,6 +1374,13 @@ func TestAggregateCompatSkip(t *testing.T) {
 			},
 			resultType: emptyResult,
 		},
+		"MinInt64": {
+			pipeline: bson.A{
+				bson.D{{"$sort", bson.D{{"_id", -1}}}},
+				bson.D{{"$skip", math.MinInt64}},
+			},
+			resultType: emptyResult,
+		},
 		"Int64Overflow": {
 			pipeline: bson.A{
 				bson.D{{"$sort", bson.D{{"_id", -1}}}},

@@ -49,6 +49,17 @@ func TestAggregateCompatCollStats(t *testing.T) {
 		"StorageStatsWithScale": {
 			collStats: bson.D{{"storageStats", bson.D{{"scale", 1000}}}},
 		},
+		"StorageStatsNegativeScale": {
+			collStats:  bson.D{{"storageStats", bson.D{{"scale", -1000}}}},
+			resultType: emptyResult,
+		},
+		"StorageStatsFloatScale": {
+			collStats: bson.D{{"storageStats", bson.D{{"scale", 42.42}}}},
+		},
+		"StorageStatsInvalidScale": {
+			collStats:  bson.D{{"storageStats", bson.D{{"scale", "invalid"}}}},
+			resultType: emptyResult,
+		},
 		"CountAndStorageStats": {
 			collStats: bson.D{{"count", bson.D{}}, {"storageStats", bson.D{}}},
 		},

@@ -0,0 +1,178 @@
+// Copyright 2021 FerretDB Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package integration
+
+import (
+	"errors"
+	"math"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/mongo"
+
+	"github.com/FerretDB/FerretDB/integration/setup"
+	"github.com/FerretDB/FerretDB/integration/shareddata"
+	"github.com/FerretDB/FerretDB/internal/util/must"
+)
+
+func TestCommandsAdministrationCompatCollStatsWithScale(t *testing.T) {
+	t.Parallel()
+
+	s := setup.SetupCompatWithOpts(t, &setup.SetupCompatOpts{
+		Providers:                []shareddata.Provider{shareddata.DocumentsDocuments},
+		AddNonExistentCollection: true,
+	})
+
+	ctx, targetCollection, compatCollection := s.Ctx, s.TargetCollections[0], s.CompatCollections[0]
+
+	for name, tc := range map[string]struct { //nolint:vet // for readability
+		scale      any
+		resultType compatTestCaseResultType
+		altMessage string
+	}{
+		"scaleOne":           {scale: int32(1)},
+		"scaleBig":           {scale: int64(1000)},
+		"scaleMaxInt":        {scale: math.MaxInt64},
+		"scaleZero":          {scale: int32(0), resultType: emptyResult},
+		"scaleNegative":      {scale: int32(-100), resultType: emptyResult},
+		"scaleFloat":         {scale: 2.8},
+		"scaleFloatNegative": {scale: -2.8, resultType: emptyResult},
+		"scaleMinFloat":      {scale: -math.MaxFloat64, resultType: emptyResult},
+		"scaleMaxFloat":      {scale: math.MaxFloat64},
+		"scaleString": {
+			scale:      "1",
+			resultType: emptyResult,
+			altMessage: `BSON field 'collStats.scale' is the wrong type 'string', expected types '[long, int, decimal, double]'`,
+		},
+		"scaleObject": {
+			scale:      bson.D{{"a", 1}},
+			resultType: emptyResult,
+			altMessage: `BSON field 'collStats.scale' is the wrong type 'object', expected types '[long, int, decimal, double]'`,
+		},
+		"scaleNull": {scale: nil},
+	} {
+		name, tc := name, tc
+
+		t.Run(name, func(t *testing.T) {
+			t.Helper()
+
+			t.Parallel()
+
+			var targetRes bson.D
+			targetCommand := bson.D{{"collStats", targetCollection.Name()}, {"scale", tc.scale}}
+			targetErr := targetCollection.Database().RunCommand(ctx, targetCommand).Decode(&targetRes)
+
+			var compatRes bson.D
+			compatCommand := bson.D{{"collStats", compatCollection.Name()}, {"scale", tc.scale}}
+			compatErr := compatCollection.Database().RunCommand(ctx, compatCommand).Decode(&compatRes)
+
+			if tc.resultType == emptyResult {
+				require.Error(t, compatErr)
+
+				targetErr = UnsetRaw(t, targetErr)
+				compatErr = UnsetRaw(t, compatErr)
+
+				if tc.altMessage != "" {
+					var expectedErr mongo.CommandError
+					require.True(t, errors.As(compatErr, &expectedErr))
+					AssertEqualAltError(t, expectedErr, tc.altMessage, targetErr)
+				} else {
+					assert.Equal(t, compatErr, targetErr)
+				}
+
+				return
+			}
+
+			require.NoError(t, compatErr)
+			require.NoError(t, targetErr)
+
+			targetDoc := ConvertDocument(t, targetRes)
+			compatDoc := ConvertDocument(t, compatRes)
+
+			targetFactor := must.NotFail(targetDoc.Get("scaleFactor"))
+			compatFactor := must.NotFail(compatDoc.Get("scaleFactor"))
+
+			assert.Equal(t, compatFactor, targetFactor)
+		})
+	}
+}
+
+func TestCommandsAdministrationCompatDBStatsWithScale(t *testing.T) {
+	t.Parallel()
+
+	s := setup.SetupCompatWithOpts(t, &setup.SetupCompatOpts{
+		Providers:                []shareddata.Provider{shareddata.DocumentsDocuments},
+		AddNonExistentCollection: true,
+	})
+
+	ctx, targetCollection, compatCollection := s.Ctx, s.TargetCollections[0], s.CompatCollections[0]
+
+	for name, tc := range map[string]struct { //nolint:vet // for readability
+		scale      any
+		resultType compatTestCaseResultType
+		altMessage string
+	}{
+		"scaleOne":   {scale: int32(1)},
+		"scaleBig":   {scale: int64(1000)},
+		"scaleFloat": {scale: 2.8},
+		"scaleNull":  {scale: nil},
+	} {
+		name, tc := name, tc
+
+		t.Run(name, func(t *testing.T) {
+			t.Helper()
+
+			t.Parallel()
+
+			var targetRes bson.D
+			targetCommand := bson.D{{"dbStats", int32(1)}, {"scale", tc.scale}}
+			targetErr := targetCollection.Database().RunCommand(ctx, targetCommand).Decode(&targetRes)
+
+			var compatRes bson.D
+			compatCommand := bson.D{{"dbStats", int32(1)}, {"scale", tc.scale}}
+			compatErr := compatCollection.Database().RunCommand(ctx, compatCommand).Decode(&compatRes)
+
+			if tc.resultType == emptyResult {
+				require.Error(t, compatErr)
+
+				targetErr = UnsetRaw(t, targetErr)
+				compatErr = UnsetRaw(t, compatErr)
+
+				if tc.altMessage != "" {
+					var expectedErr mongo.CommandError
+					require.True(t, errors.As(compatErr, &expectedErr))
+					AssertEqualAltError(t, expectedErr, tc.altMessage, targetErr)
+				} else {
+					assert.Equal(t, compatErr, targetErr)
+				}
+
+				return
+			}
+
+			require.NoError(t, compatErr)
+			require.NoError(t, targetErr)
+
+			targetDoc := ConvertDocument(t, targetRes)
+			compatDoc := ConvertDocument(t, compatRes)
+
+			targetFactor := must.NotFail(targetDoc.Get("scaleFactor"))
+			compatFactor := must.NotFail(compatDoc.Get("scaleFactor"))
+
+			assert.Equal(t, compatFactor, targetFactor)
+		})
+	}
+}
@@ -16,6 +16,7 @@ package integration
 
 import (
 	"errors"
+	"math"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -210,6 +211,11 @@ func TestCountCompat(t *testing.T) {
 			optSkip:    -1.888,
 			resultType: emptyResult,
 		},
+		"SkipMinFloat": {
+			filter:     bson.D{},
+			optSkip:    -math.MaxFloat64,
+			resultType: emptyResult,
+		},
 		"SkipNull": {
 			filter: bson.D{},
 		},

@@ -318,6 +318,11 @@ func TestQueryCompatSkip(t *testing.T) {
 			optSkip:    pointer.ToInt64(math.MaxInt64),
 			resultType: emptyResult,
 		},
+		"MinInt64": {
+			filter:     bson.D{},
+			optSkip:    pointer.ToInt64(math.MinInt64),
+			resultType: emptyResult,
+		},
 	}
 
 	testQueryCompat(t, testCases)

@@ -62,13 +62,13 @@ func newCollStats(stage *types.Document) (Stage, error) {
 	if fields.Has("storageStats") {
 		cs.storageStats = new(storageStats)
 
-		// TODO Add proper support for scale: https://github.com/FerretDB/FerretDB/issues/1346
-		cs.storageStats.scale, err = common.GetOptionalPositiveNumber(
-			must.NotFail(fields.Get("storageStats")).(*types.Document),
-			"scale",
-		)
-		if err != nil || cs.storageStats.scale == 0 {
-			cs.storageStats.scale = 1
+		storageStatsFields := must.NotFail(fields.Get("storageStats")).(*types.Document)
+
+		var s any
+		if s, err = storageStatsFields.Get("scale"); err == nil {
+			if cs.storageStats.scale, err = common.GetScaleParam("$collStats.storageStats", s); err != nil {
+				return nil, err
+			}
 		}
 	}
 

@@ -121,7 +121,8 @@ var (
 	errNotBinaryMask         = fmt.Errorf("not a binary mask")
 	errUnexpectedLeftOpType  = fmt.Errorf("unexpected left operand type")
 	errUnexpectedRightOpType = fmt.Errorf("unexpected right operand type")
-	errLongExceeded          = fmt.Errorf("long exceeded")
+	errLongExceededPositive  = fmt.Errorf("long exceeded - positive value")
+	errLongExceededNegative  = fmt.Errorf("long exceeded - negative value")
 	errIntExceeded           = fmt.Errorf("int exceeded")
 	errInfinity              = fmt.Errorf("infinity")
 )
@@ -132,16 +133,14 @@ func GetWholeNumberParam(value any) (int64, error) {
 	switch value := value.(type) {
 	// TODO: add string support https://github.com/FerretDB/FerretDB/issues/1089
 	case float64:
-		if math.IsInf(value, 1) {
+		switch {
+		case math.IsInf(value, 1):
 			return 0, errInfinity
-		}
-
-		if value > float64(math.MaxInt64) ||
-			value < float64(math.MinInt64) {
-			return 0, errLongExceeded
-		}
-
-		if value != math.Trunc(value) {
+		case value > float64(math.MaxInt64):
+			return 0, errLongExceededPositive
+		case value < float64(math.MinInt64):
+			return 0, errLongExceededNegative
+		case value != math.Trunc(value):
 			return 0, errNotWholeNumber
 		}
 
@@ -174,7 +173,7 @@ func GetLimitStageParam(value any) (int64, error) {
 			fmt.Sprintf("invalid argument to $limit stage: Expected an integer: $limit: %#v", value),
 			"$limit (stage)",
 		)
-	case errors.Is(err, errLongExceeded):
+	case errors.Is(err, errLongExceededPositive), errors.Is(err, errLongExceededNegative):
 		return 0, commonerrors.NewCommandErrorMsgWithArgument(
 			commonerrors.ErrStageLimitInvalidArg,
 			fmt.Sprintf("invalid argument to $limit stage: Cannot represent as a 64-bit integer: $limit: %#v", value),
@@ -215,7 +214,7 @@ func GetSkipStageParam(value any) (int64, error) {
 			fmt.Sprintf("invalid argument to $skip stage: Expected an integer: $skip: %#v", value),
 			"$skip (stage)",
 		)
-	case errors.Is(err, errLongExceeded):
+	case errors.Is(err, errLongExceededPositive), errors.Is(err, errLongExceededNegative):
 		return 0, commonerrors.NewCommandErrorMsgWithArgument(
 			commonerrors.ErrStageSkipBadValue,
 			fmt.Sprintf("invalid argument to $skip stage: Cannot represent as a 64-bit integer: $skip: %#v", value),
@@ -363,11 +362,11 @@ func addNumbers(v1, v2 any) (any, error) {
 		case int64:
 			if v2 > 0 {
 				if int64(v1) > math.MaxInt64-v2 {
-					return nil, errLongExceeded
+					return nil, errLongExceededPositive
 				}
 			} else {
 				if int64(v1) < math.MinInt64-v2 {
-					return nil, errLongExceeded
+					return nil, errLongExceededNegative
 				}
 			}
 
@@ -394,11 +393,11 @@ func addNumbers(v1, v2 any) (any, error) {
 		case int64:
 			if v2 > 0 {
 				if v1 > math.MaxInt64-v2 {
-					return nil, errLongExceeded
+					return nil, errLongExceededPositive
 				}
 			} else {
 				if v1 < math.MinInt64-v2 {
-					return nil, errLongExceeded
+					return nil, errLongExceededNegative
 				}
 			}
 
@@ -483,12 +482,12 @@ func multiplyLongSafely(v1, v2 int64) (int64, error) {
 	// This check is necessary only for MinInt64, as multiplying MinInt64 by -1
 	// results in overflow with the MinInt64 as result.
 	case v1 == math.MinInt64 || v2 == math.MinInt64:
-		return 0, errLongExceeded
+		return 0, errLongExceededNegative
 	}
 
 	res := v1 * v2
 	if res/v2 != v1 {
-		return 0, errLongExceeded
+		return 0, errLongExceededPositive
 	}
 
 	return res, nil