Merge branch 'master' into feature/PRXS-1609-ExtensionAPI

pkg/schema/field/number.go

@@ -10,6 +10,10 @@ import (
 const (
 	NumberFormatInt   = "int"
 	NumberFormatFloat = "float"
+
+	// The largest integer that can be represented in IEEE 754 double (64-bit) is a value from -2^53 to 2^53.
+	maxInt = 1<<53 - 1
+	minInt = -1<<53 + 1
 )
 
 var numberType = &NumberType{}
@@ -84,10 +88,19 @@ func (NumberType) decode(_ context.Context, field *Field, v interface{}) (interf
 	case NumberFormatInt:
 		switch i := n.(type) {
 		case int64:
+			if i > maxInt || i < minInt {
+				return nil, errors.New("integer out of range")
+			}
 			return i, nil
 		case uint64:
+			if i > maxInt {
+				return nil, errors.New("integer out of range")
+			}
 			return i, nil
 		case float64:
+			if i > maxInt || i < minInt {
+				return nil, errors.New("integer out of range")
+			}
 			return int64(math.Round(i)), nil
 		}
 	case NumberFormatFloat:

pkg/schema/field/number_test.go

 package field
 
 import (
+	"context"
+	"math"
 	"reflect"
 	"testing"
 )
@@ -19,12 +21,19 @@ func TestNumberField_Decode(t *testing.T) {
 		{"Correct", Number("int"), float32(2.2), int64(2), false},                           // #3
 		{"Correct", Number("int"), float64(2.6), int64(3), false},                           // #4
 		{"Correct", Number("int"), 2.6, int64(3), false},                                    // #5
+		{"MaxInt64", Number(NumberFormatInt), int64(math.MaxInt64), nil, true},              // #6
+		{"MinInt64", Number(NumberFormatInt), int64(math.MinInt64), nil, true},              // #7
+		{"maxInt in float", Number(NumberFormatInt), float64(maxInt), int64(maxInt), false}, // #8
+		{"minInt in float", Number(NumberFormatInt), float64(minInt), int64(minInt), false}, // #9
+		{"Convert error", Number(NumberFormatInt), math.MaxFloat64, nil, true},              // #10
+		{"Convert error", Number(NumberFormatInt), -math.MaxFloat64, nil, true},             // #11
+		{"Convert error", Number(NumberFormatInt), float64(math.MaxInt64), nil, true},       // #13
+		{"Convert error", Number(NumberFormatInt), float64(math.MinInt64), nil, true},       // #14
 
-		{"Correct", Number("float"), int8(2), 2.0, false},                    // #6
-		{"Correct", Number("float"), 2.2, 2.2, false},                        // #7
-		{"Correct", Number("float"), 2, 2.0, false},                          // #8
-		{"Correct", Number("float"), float32(2.2), 2.200000047683716, false}, // #9
-		{"Correct", Number("float"), int64(2), 2.0, false},                   // #10
+		{"Correct", Number("float"), int8(2), 2.0, false},  // #15
+		{"Correct", Number("float"), 2.2, 2.2, false},      // #16
+		{"Correct", Number("float"), 2, 2.0, false},        // #17
+		{"Correct", Number("float"), int64(2), 2.0, false}, // #18
 
 		{"Wrong data", Number("int"), "", nil, true},         // #0
 		{"Wrong data", Number("int"), []byte(""), nil, true}, // #1
@@ -34,7 +43,7 @@ func TestNumberField_Decode(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got, err := Decode(nil, tt.field, tt.data)
+			got, err := Decode(context.Background(), tt.field, tt.data)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("Decode() error = %v, wantErr %v", err, tt.wantErr)
 				return
@@ -64,8 +73,7 @@ func TestNumberField_Encode(t *testing.T) {
 		{"Correct", Number("float"), int8(2), 2.0, false},  // #6
 		{"Correct", Number("float"), 2.2, 2.2, false},      // #7
 		{"Correct", Number("float"), 2, 2.0, false},        // #8
-		{"Correct", Number("float"), float32(2.2), 2.200000047683716, false}, // #9
-		{"Correct", Number("float"), int64(2), 2.0, false},                   // #10
+		{"Correct", Number("float"), int64(2), 2.0, false}, // #9
 
 		{"Wrong data", Number("int"), "", nil, true},         // #0
 		{"Wrong data", Number("int"), []byte(""), nil, true}, // #1
@@ -75,7 +83,7 @@ func TestNumberField_Encode(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got, err := Encode(nil, tt.field, tt.data)
+			got, err := Encode(context.Background(), tt.field, tt.data)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("Decode() error = %v, wantErr %v", err, tt.wantErr)
 				return

pkg/schema/test/object_test.go

@@ -74,6 +74,80 @@ func TestNumberField_JSON(t *testing.T) {
 	assert.Equal(t, fld, res)
 }
 
+func TestNumberField_JSON_With_MaxInt(t *testing.T) {
+	t.Run("Without overflow from int64", func(t *testing.T) {
+		fld := field.Object("num", field.Number(field.NumberFormatInt))
+
+		itemData := map[string]interface{}{"num": 1<<53 - 1}
+
+		b, err := json.Marshal(itemData)
+		require.NoError(t, err)
+
+		itemDataToDecode := make(map[string]interface{})
+		require.NoError(t, json.Unmarshal(b, &itemDataToDecode))
+
+		_, err = field.Decode(context.Background(), fld, itemDataToDecode)
+		require.NoError(t, err)
+	})
+	t.Run("Without overflow from float64", func(t *testing.T) {
+		fld := field.Object("num", field.Number(field.NumberFormatInt))
+
+		itemData := map[string]interface{}{"num": float64(1<<53 - 1)}
+
+		b, err := json.Marshal(itemData)
+		require.NoError(t, err)
+
+		itemDataToDecode := make(map[string]interface{})
+		require.NoError(t, json.Unmarshal(b, &itemDataToDecode))
+
+		_, err = field.Decode(context.Background(), fld, itemDataToDecode)
+		require.NoError(t, err)
+	})
+	t.Run("With overflow from int64", func(t *testing.T) {
+		fld := field.Object("num", field.Number(field.NumberFormatInt))
+
+		itemData := map[string]interface{}{"num": 1 << 53}
+
+		b, err := json.Marshal(itemData)
+		require.NoError(t, err)
+
+		itemDataToDecode := make(map[string]interface{})
+		require.NoError(t, json.Unmarshal(b, &itemDataToDecode))
+
+		_, err = field.Decode(context.Background(), fld, itemDataToDecode)
+		require.Error(t, err, "integer out of range")
+	})
+	t.Run("With overflow from uint64", func(t *testing.T) {
+		fld := field.Object("num", field.Number(field.NumberFormatInt))
+
+		itemData := map[string]interface{}{"num": uint64(1 << 53)}
+
+		b, err := json.Marshal(itemData)
+		require.NoError(t, err)
+
+		itemDataToDecode := make(map[string]interface{})
+		require.NoError(t, json.Unmarshal(b, &itemDataToDecode))
+
+		_, err = field.Decode(context.Background(), fld, itemDataToDecode)
+		require.Error(t, err, "integer out of range")
+	})
+	t.Run("With overflow from float64", func(t *testing.T) {
+		fld := field.Object("num", field.Number(field.NumberFormatInt))
+
+		itemData := map[string]interface{}{"num": float64(1 << 53)}
+
+		b, err := json.Marshal(itemData)
+		require.NoError(t, err)
+
+		itemDataToDecode := make(map[string]interface{})
+		require.NoError(t, json.Unmarshal(b, &itemDataToDecode))
+
+		_, err = field.Decode(context.Background(), fld, itemDataToDecode)
+		require.Error(t, err, "integer out of range")
+	})
+
+}
+
 func TestSchema_JSON(t *testing.T) {
 	enumStr := field.String().AddOptions(
 		validate.Enum(

pkg/setup/collection.go

@@ -45,7 +45,10 @@ func NewCollectionConfig(collection *collections.Collection, opt ...CollectionsO
 func OverwriteCollection() CollectionsOption {
 	return func(c *CollectionConfig) {
 		c.UpdateFn = func(s *Setup, old, new *collections.Collection) (*collections.Collection, bool, bool, error) {
-			return new, true, true, nil
+			update := new.Name != old.Name || new.IsSingle() != old.IsSingle() || new.IsSystem() != old.IsSystem() ||
+				new.IsNoData() != old.IsNoData() || new.Hidden != old.Hidden || new.IsView() != old.IsView() || !data.ElementsMatch(old.Tags, new.Tags)
+
+			return new, update, !reflect.DeepEqual(old.Schema, new.Schema), nil
 		}
 	}
 }