go.chromium.org/luci@v0.0.0-20240309015107-7cdc2e660f33/gae/service/datastore/properties_test.go

// Copyright 2015 The LUCI Authors.
//
// 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 datastore

import (
	"fmt"
	"math"
	"sort"
	"testing"
	"time"

	"go.chromium.org/luci/gae/service/blobstore"

	. "github.com/smartystreets/goconvey/convey"
)

type mybool bool
type mystring string
type myfloat float32

func TestProperties(t *testing.T) {
	t.Parallel()

	Convey("Test Property", t, func() {
		Convey("Construction", func() {
			Convey("empty", func() {
				pv := Property{}
				So(pv.Value(), ShouldBeNil)
				So(pv.IndexSetting(), ShouldEqual, ShouldIndex)
				So(pv.Type().String(), ShouldEqual, "PTNull")
			})
			Convey("set", func() {
				pv := MkPropertyNI(100)
				So(pv.Value(), ShouldHaveSameTypeAs, int64(100))
				So(pv.Value(), ShouldEqual, 100)
				So(pv.IndexSetting(), ShouldEqual, NoIndex)
				So(pv.Type().String(), ShouldEqual, "PTInt")

				So(pv.SetValue(nil, ShouldIndex), ShouldBeNil)
				So(pv.Value(), ShouldBeNil)
				So(pv.IndexSetting(), ShouldEqual, ShouldIndex)
				So(pv.Type().String(), ShouldEqual, "PTNull")
			})
			Convey("derived types", func() {
				Convey("int", func() {
					pv := MkProperty(19)
					So(pv.Value(), ShouldHaveSameTypeAs, int64(19))
					So(pv.Value(), ShouldEqual, 19)
					So(pv.IndexSetting(), ShouldEqual, ShouldIndex)
					So(pv.Type().String(), ShouldEqual, "PTInt")
				})
				Convey("int32", func() {
					pv := MkProperty(int32(32))
					So(pv.Value(), ShouldHaveSameTypeAs, int64(32))
					So(pv.Value(), ShouldEqual, 32)
					So(pv.IndexSetting(), ShouldEqual, ShouldIndex)
					So(pv.Type().String(), ShouldEqual, "PTInt")
				})
				Convey("uint32", func() {
					pv := MkProperty(uint32(32))
					So(pv.Value(), ShouldHaveSameTypeAs, int64(32))
					So(pv.Value(), ShouldEqual, 32)
					So(pv.IndexSetting(), ShouldEqual, ShouldIndex)
					So(pv.Type().String(), ShouldEqual, "PTInt")
				})
				Convey("byte", func() {
					pv := MkProperty(byte(32))
					So(pv.Value(), ShouldHaveSameTypeAs, int64(32))
					So(pv.Value(), ShouldEqual, 32)
					So(pv.IndexSetting(), ShouldEqual, ShouldIndex)
					So(pv.Type().String(), ShouldEqual, "PTInt")
				})
				Convey("bool (true)", func() {
					pv := MkProperty(mybool(true))
					So(pv.Value(), ShouldBeTrue)
					So(pv.IndexSetting(), ShouldEqual, ShouldIndex)
					So(pv.Type().String(), ShouldEqual, "PTBool")
				})
				Convey("string", func() {
					pv := MkProperty(mystring("sup"))
					So(pv.Value(), ShouldEqual, "sup")
					So(pv.IndexSetting(), ShouldEqual, ShouldIndex)
					So(pv.Type().String(), ShouldEqual, "PTString")
				})
				Convey("blobstore.Key is distinquished", func() {
					pv := MkProperty(blobstore.Key("sup"))
					So(pv.Value(), ShouldEqual, blobstore.Key("sup"))
					So(pv.IndexSetting(), ShouldEqual, ShouldIndex)
					So(pv.Type().String(), ShouldEqual, "PTBlobKey")
				})
				Convey("datastore Key is distinguished", func() {
					k := MkKeyContext("appid", "ns").MakeKey("kind", "1")
					pv := MkProperty(k)
					So(pv.Value(), ShouldHaveSameTypeAs, k)
					So(pv.Value().(*Key).Equal(k), ShouldBeTrue)
					So(pv.IndexSetting(), ShouldEqual, ShouldIndex)
					So(pv.Type().String(), ShouldEqual, "PTKey")

					pv = MkProperty((*Key)(nil))
					So(pv.Value(), ShouldBeNil)
					So(pv.IndexSetting(), ShouldEqual, ShouldIndex)
					So(pv.Type().String(), ShouldEqual, "PTNull")
				})
				Convey("float", func() {
					pv := Property{}
					So(pv.SetValue(myfloat(19.7), ShouldIndex), ShouldBeNil)
					So(pv.Value(), ShouldHaveSameTypeAs, float64(19.7))
					So(pv.Value(), ShouldEqual, float32(19.7))
					So(pv.IndexSetting(), ShouldEqual, ShouldIndex)
					So(pv.Type().String(), ShouldEqual, "PTFloat")
				})
				Convey("property map", func() {
					pv := Property{}
					So(pv.SetValue(PropertyMap{
						"key": Property{
							indexSetting: true,
							propType:     PTString,
							value:        stringByteSequence("val"),
						},
						"nested": Property{
							indexSetting: false,
							propType:     PTPropertyMap,
							value: PropertyMap{
								"key": Property{
									indexSetting: false,
									propType:     PTInt,
									value:        1,
								},
							},
						},
					}, NoIndex), ShouldBeNil)
					So(pv.Value(), ShouldResemble, PropertyMap{
						"key": Property{
							indexSetting: true,
							propType:     PTString,
							value:        stringByteSequence("val"),
						},
						"nested": Property{
							indexSetting: false,
							propType:     PTPropertyMap,
							value: PropertyMap{
								"key": Property{
									indexSetting: false,
									propType:     PTInt,
									value:        1,
								},
							},
						},
					})
					So(pv.IndexSetting(), ShouldEqual, NoIndex)
					So(pv.Type().String(), ShouldEqual, "PTPropertyMap")
				})
			})
			Convey("bad type", func() {
				pv := Property{}
				err := pv.SetValue(complex(100, 29), ShouldIndex)
				So(err.Error(), ShouldContainSubstring, "has bad type complex")
				So(pv.Value(), ShouldBeNil)
				So(pv.IndexSetting(), ShouldEqual, ShouldIndex)
				So(pv.Type().String(), ShouldEqual, "PTNull")
			})
			Convey("invalid GeoPoint", func() {
				pv := Property{}
				err := pv.SetValue(GeoPoint{-1000, 0}, ShouldIndex)
				So(err.Error(), ShouldContainSubstring, "invalid GeoPoint value")
				So(pv.Value(), ShouldBeNil)
				So(pv.IndexSetting(), ShouldEqual, ShouldIndex)
				So(pv.Type().String(), ShouldEqual, "PTNull")
			})
			Convey("invalid time", func() {
				pv := Property{}
				loc, err := time.LoadLocation("America/Los_Angeles")
				So(err, ShouldBeNil)
				t := time.Date(1970, 1, 1, 0, 0, 0, 0, loc)

				err = pv.SetValue(t, ShouldIndex)
				So(err.Error(), ShouldContainSubstring, "time value has wrong Location")

				err = pv.SetValue(time.Unix(math.MaxInt64, 0).UTC(), ShouldIndex)
				So(err.Error(), ShouldContainSubstring, "time value out of range")
				So(pv.Value(), ShouldBeNil)
				So(pv.IndexSetting(), ShouldEqual, ShouldIndex)
				So(pv.Type().String(), ShouldEqual, "PTNull")
			})
			Convey("time gets rounded", func() {
				pv := Property{}
				now := time.Now().In(time.UTC)
				now = now.Round(time.Microsecond).Add(time.Nanosecond * 313)
				So(pv.SetValue(now, ShouldIndex), ShouldBeNil)
				So(pv.Value(), ShouldHappenBefore, now)
				So(pv.IndexSetting(), ShouldEqual, ShouldIndex)
				So(pv.Type().String(), ShouldEqual, "PTTime")
			})
			Convey("zero time", func() {
				now := time.Time{}
				So(now.IsZero(), ShouldBeTrue)

				pv := Property{}
				So(pv.SetValue(now, ShouldIndex), ShouldBeNil)
				So(pv.Value(), ShouldResemble, now)
				v, err := pv.Project(PTInt)
				So(err, ShouldBeNil)
				So(v, ShouldEqual, 0)

				So(pv.SetValue(0, ShouldIndex), ShouldBeNil)
				So(pv.Value(), ShouldEqual, 0)
				v, err = pv.Project(PTTime)
				So(err, ShouldBeNil)
				So(v.(time.Time).IsZero(), ShouldBeTrue)
			})
			Convey("[]byte allows IndexSetting", func() {
				pv := Property{}
				So(pv.SetValue([]byte("hello"), ShouldIndex), ShouldBeNil)
				So(pv.Value(), ShouldResemble, []byte("hello"))
				So(pv.IndexSetting(), ShouldEqual, ShouldIndex)
				So(pv.Type().String(), ShouldEqual, "PTBytes")
			})
		})

		Convey("Comparison", func() {
			Convey(`A []byte property should equal a string property with the same value.`, func() {
				a := MkProperty([]byte("ohaithere"))
				b := MkProperty("ohaithere")
				So(a.Equal(&b), ShouldBeTrue)
			})
		})
	})
}

func TestDSPropertyMapImpl(t *testing.T) {
	t.Parallel()

	Convey("Test PropertyMap", t, func() {
		Convey("load/save err conditions", func() {
			Convey("empty", func() {
				pm := PropertyMap{}
				err := pm.Load(PropertyMap{"hello": Property{}})
				So(err, ShouldBeNil)
				So(pm, ShouldResemble, PropertyMap{"hello": Property{}})

				npm, _ := pm.Save(false)
				So(npm, ShouldResemble, pm)
			})
			Convey("meta", func() {
				Convey("working", func() {
					pm := PropertyMap{"": MkProperty("trap!")}
					_, ok := pm.GetMeta("foo")
					So(ok, ShouldBeFalse)

					So(pm.SetMeta("foo", 100), ShouldBeTrue)

					v, ok := pm.GetMeta("foo")
					So(ok, ShouldBeTrue)
					So(v, ShouldEqual, 100)

					So(GetMetaDefault(pm, "foo", 100), ShouldEqual, 100)

					So(GetMetaDefault(pm, "bar", 100), ShouldEqual, 100)

					npm, err := pm.Save(false)
					So(err, ShouldBeNil)
					So(len(npm), ShouldEqual, 0)
				})

				Convey("too many values picks the first one", func() {
					pm := PropertyMap{
						"$thing": PropertySlice{MkProperty(100), MkProperty(200)},
					}
					v, ok := pm.GetMeta("thing")
					So(ok, ShouldBeTrue)
					So(v, ShouldEqual, 100)
				})

				Convey("errors", func() {

					Convey("weird value", func() {
						pm := PropertyMap{}
						So(pm.SetMeta("sup", complex(100, 20)), ShouldBeFalse)
					})
				})
			})
		})
		Convey("disable indexing on entire map", func() {
			pm := PropertyMap{
				"single": MkProperty("foo"),
				"slice":  PropertySlice{MkProperty(100), MkProperty(200)},
			}
			pm.TurnOffIdx()
			So(pm["single"].Slice()[0].indexSetting, ShouldEqual, NoIndex)
			So(pm["slice"].Slice()[0].indexSetting, ShouldEqual, NoIndex)
			So(pm["slice"].Slice()[1].indexSetting, ShouldEqual, NoIndex)
		})
	})
}

func TestByteSequences(t *testing.T) {
	t.Parallel()

	conversions := []struct {
		desc string
		conv func(v string) (byteSequence, any)
	}{
		{"string", func(v string) (byteSequence, any) { return stringByteSequence(v), v }},
		{"[]byte", func(v string) (byteSequence, any) { return bytesByteSequence(v), []byte(v) }},
	}

	testCases := map[string][]struct {
		assertion func(any, ...any) string
		cmpS      string
	}{
		"": {
			{ShouldEqual, ""},
			{ShouldBeLessThan, "foo"},
		},
		"bar": {
			{ShouldEqual, "bar"},
			{ShouldBeGreaterThan, "ba"},
		},
		"ba": {
			{ShouldBeLessThan, "bar"},
			{ShouldBeLessThan, "z"},
		},
		"foo": {
			{ShouldBeGreaterThan, ""},
		},
		"bz": {
			{ShouldBeGreaterThan, "bar"},
		},
		"qux": {
			{ShouldBeGreaterThan, "bar"},
		},
	}

	keys := make([]string, 0, len(testCases))
	for k := range testCases {
		keys = append(keys, k)
	}
	sort.Strings(keys)

	Convey(`When testing byte sequences`, t, func() {
		for _, s := range keys {
			for _, c := range conversions {
				Convey(fmt.Sprintf(`A %s sequence with test data %q`, c.desc, s), func() {
					bs, effectiveValue := c.conv(s)

					Convey(`Basic stuff works.`, func() {
						So(bs.len(), ShouldEqual, len(s))
						for i, c := range s {
							So(bs.get(i), ShouldEqual, c)
						}
						So(bs.value(), ShouldResemble, effectiveValue)
						So(bs.string(), ShouldEqual, s)
						So(bs.bytes(), ShouldResemble, []byte(s))
					})

					// Test comparison with other byteSequence types.
					for _, tc := range testCases[s] {
						for _, c := range conversions {
							Convey(fmt.Sprintf(`Compares properly with %s %q`, c.desc, tc.cmpS), func() {
								cmpBS, _ := c.conv(tc.cmpS)
								So(cmpByteSequence(bs, cmpBS), tc.assertion, 0)
							})
						}
					}
				})
			}
		}
	})
}