go.chromium.org/luci@v0.0.0-20240309015107-7cdc2e660f33/cipd/appengine/impl/metadata/legacy_test.go

// Copyright 2018 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 metadata

import (
	"context"
	"errors"
	"fmt"
	"testing"
	"time"

	"google.golang.org/protobuf/proto"
	"google.golang.org/protobuf/types/known/timestamppb"

	"go.chromium.org/luci/gae/impl/memory"
	"go.chromium.org/luci/gae/service/datastore"

	api "go.chromium.org/luci/cipd/api/cipd/v1"

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

	. "go.chromium.org/luci/common/testing/assertions"
)

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

	Convey("With legacy entities", t, func() {
		impl := legacyStorageImpl{}

		ctx := memory.Use(context.Background())
		ts := time.Unix(1525136124, 0).UTC()

		root := rootKey(ctx)
		So(datastore.Put(ctx, []*packageACL{
			// ACLs for "a".
			{
				ID:         "OWNER:a",
				Parent:     root,
				Users:      []string{"user:a-owner@example.com"},
				Groups:     []string{"a-owner"},
				ModifiedBy: "user:a-owner-mod@example.com",
				ModifiedTS: ts,
			},
			{
				ID:         "WRITER:a",
				Parent:     root,
				Users:      []string{"user:a-writer@example.com"},
				Groups:     []string{"a-writer"},
				ModifiedBy: "user:a-writer-mod@example.com",
				ModifiedTS: ts.Add(5 * time.Second),
			},
			{
				ID:         "READER:a",
				Parent:     root,
				Users:      []string{"user:a-reader@example.com"},
				Groups:     []string{"a-reader"},
				ModifiedBy: "user:a-reader-mod@example.com",
				ModifiedTS: ts,
			},

			// Empty ACLs for "a/b".
			{
				ID:         "OWNER:a/b",
				Parent:     root,
				ModifiedBy: "user:b-owner-mod@example.com",
				ModifiedTS: ts,
				// no Users or Groups here
			},

			// ACLs for "a/b/c/d".
			{
				ID:         "OWNER:a/b/c/d",
				Parent:     root,
				Users:      []string{"user:d-owner@example.com", "bad:ident"},
				Groups:     []string{"d-owner"},
				ModifiedBy: "user:d-owner-mod@example.com",
				ModifiedTS: ts,
			},
		}), ShouldBeNil)

		rootMeta := rootMetadata()

		// Expected metadata per prefix.
		expected := map[string]*api.PrefixMetadata{
			"a": {
				Prefix:      "a",
				Fingerprint: "BK-o5e-PimWmXtF3zdzvjiyAqSU",
				UpdateTime:  timestamppb.New(ts.Add(5 * time.Second)), // WRITER:a mod time
				UpdateUser:  "user:a-writer-mod@example.com",
				Acls: []*api.PrefixMetadata_ACL{
					{Role: api.Role_OWNER, Principals: []string{"user:a-owner@example.com", "group:a-owner"}},
					{Role: api.Role_WRITER, Principals: []string{"user:a-writer@example.com", "group:a-writer"}},
					{Role: api.Role_READER, Principals: []string{"user:a-reader@example.com", "group:a-reader"}},
				},
			},
			"a/b": {
				Prefix:      "a/b",
				Fingerprint: "RyIXeT0HBpfv5Lj8FLqMzCu60ZI",
				UpdateTime:  timestamppb.New(ts),
				UpdateUser:  "user:b-owner-mod@example.com",
			},
			"a/b/c/d": {
				Prefix:      "a/b/c/d",
				Fingerprint: "4B97z37yN22RnBHS336ROctEC2w",
				UpdateTime:  timestamppb.New(ts),
				UpdateUser:  "user:d-owner-mod@example.com",
				Acls: []*api.PrefixMetadata_ACL{
					// Note: bad:ident is skipped here.
					{Role: api.Role_OWNER, Principals: []string{"user:d-owner@example.com", "group:d-owner"}},
				},
			},
		}

		Convey("GetMetadata returns root metadata which has fingerprint", func() {
			md, err := impl.GetMetadata(ctx, "")
			So(err, ShouldBeNil)
			So(md, ShouldResembleProto, []*api.PrefixMetadata{rootMeta})
			So(rootMeta, ShouldResembleProto, &api.PrefixMetadata{
				Acls: []*api.PrefixMetadata_ACL{
					{
						Role:       api.Role_OWNER,
						Principals: []string{"group:administrators"},
					},
				},
				Fingerprint: "G7Hov8WrEwWHx1dQd7SMsKJERUI",
			})
		})

		Convey("GetMetadata handles one prefix", func() {
			md, err := impl.GetMetadata(ctx, "a")
			So(err, ShouldBeNil)
			So(md, ShouldResembleProto, []*api.PrefixMetadata{
				rootMeta,
				expected["a"],
			})
		})

		Convey("GetMetadata handles many prefixes", func() {
			// Returns only existing metadata, silently skipping undefined.
			md, err := impl.GetMetadata(ctx, "a/b/c/d/e/")
			So(err, ShouldBeNil)
			So(md, ShouldResembleProto, []*api.PrefixMetadata{
				rootMeta,
				expected["a"],
				expected["a/b"],
				expected["a/b/c/d"],
			})
		})

		Convey("GetMetadata handles root metadata", func() {
			md, err := impl.GetMetadata(ctx, "")
			So(err, ShouldBeNil)
			So(md, ShouldResembleProto, []*api.PrefixMetadata{rootMeta})
		})

		Convey("GetMetadata fails on bad prefix", func() {
			_, err := impl.GetMetadata(ctx, "???")
			So(err, ShouldErrLike, "invalid package prefix")
		})

		Convey("UpdateMetadata noop call with existing metadata", func() {
			updated, err := impl.UpdateMetadata(ctx, "a", func(_ context.Context, md *api.PrefixMetadata) error {
				So(md, ShouldResembleProto, expected["a"])
				return nil
			})
			So(err, ShouldBeNil)
			So(updated, ShouldResembleProto, expected["a"])
		})

		Convey("UpdateMetadata refuses to update root metadata", func() {
			_, err := impl.UpdateMetadata(ctx, "", func(_ context.Context, md *api.PrefixMetadata) error {
				panic("must not be called")
			})
			So(err, ShouldErrLike, "the root metadata is not modifiable")
		})

		Convey("UpdateMetadata updates existing metadata", func() {
			modTime := ts.Add(10 * time.Second)

			newMD := proto.Clone(expected["a"]).(*api.PrefixMetadata)
			newMD.UpdateTime = timestamppb.New(modTime)
			newMD.UpdateUser = "user:updater@example.com"
			newMD.Acls[0].Principals = []string{
				"group:new-owning-group",
				"user:new-owner@example.com",
				"group:another-group",
			}

			updated, err := impl.UpdateMetadata(ctx, "a", func(_ context.Context, md *api.PrefixMetadata) error {
				So(md, ShouldResembleProto, expected["a"])
				*md = *newMD
				return nil
			})
			So(err, ShouldBeNil)

			// The returned metadata is different from newMD: order of principals is
			// not preserved, and the fingerprint is populated.
			newMD.Acls[0].Principals = []string{
				"user:new-owner@example.com",
				"group:new-owning-group",
				"group:another-group",
			}
			newMD.Fingerprint = "MCRIAGe9tfXGxAZ-mTQbjQiJAlA" // new FP
			So(updated, ShouldResembleProto, newMD)

			// GetMetadata sees the new metadata.
			md, err := impl.GetMetadata(ctx, "a")
			So(err, ShouldBeNil)
			So(md, ShouldResembleProto, []*api.PrefixMetadata{rootMeta, newMD})

			// Only touched "OWNER:..." legacy entity, since only owners changed.
			legacy := prefixACLs(ctx, "a", nil)
			So(datastore.Get(ctx, legacy), ShouldBeNil)
			So(legacy, ShouldResemble, []*packageACL{
				{
					ID:         "OWNER:a",
					Parent:     root,
					Users:      []string{"user:new-owner@example.com"},
					Groups:     []string{"new-owning-group", "another-group"},
					ModifiedBy: "user:updater@example.com",
					ModifiedTS: modTime,
					Rev:        1,
				},
				// Untouched.
				{
					ID:         "WRITER:a",
					Parent:     root,
					Users:      []string{"user:a-writer@example.com"},
					Groups:     []string{"a-writer"},
					ModifiedBy: "user:a-writer-mod@example.com",
					ModifiedTS: ts.Add(5 * time.Second),
				},
				// Untouched.
				{
					ID:         "READER:a",
					Parent:     root,
					Users:      []string{"user:a-reader@example.com"},
					Groups:     []string{"a-reader"},
					ModifiedBy: "user:a-reader-mod@example.com",
					ModifiedTS: ts,
				},
			})
		})

		Convey("UpdateMetadata noop call with missing metadata", func() {
			updated, err := impl.UpdateMetadata(ctx, "z", func(_ context.Context, md *api.PrefixMetadata) error {
				So(md, ShouldResembleProto, &api.PrefixMetadata{Prefix: "z"})
				return nil
			})
			So(err, ShouldBeNil)
			So(updated, ShouldBeNil)

			// Still missing.
			md, err := impl.GetMetadata(ctx, "z")
			So(err, ShouldBeNil)
			So(md, ShouldResembleProto, []*api.PrefixMetadata{rootMeta})
		})

		Convey("UpdateMetadata creates new metadata", func() {
			updated, err := impl.UpdateMetadata(ctx, "z", func(_ context.Context, md *api.PrefixMetadata) error {
				So(md, ShouldResembleProto, &api.PrefixMetadata{Prefix: "z"})
				md.UpdateTime = timestamppb.New(ts)
				md.UpdateUser = "user:updater@example.com"
				md.Acls = []*api.PrefixMetadata_ACL{
					{
						Role: api.Role_READER,
					},
					{
						Role:       api.Role_WRITER,
						Principals: []string{"group:a", "user:a@example.com"},
					},
					{
						Role:       api.Role_OWNER,
						Principals: []string{"group:b"},
					},
				}
				return nil
			})
			So(err, ShouldBeNil)

			// Changes compared to what was stored in the callback:
			//  * Acls are ordered by Role now.
			//  * READER is missing, the principals list was empty.
			//  * Principals are sorted by "users first, then groups".
			expected := &api.PrefixMetadata{
				Prefix:      "z",
				Fingerprint: "ppDqWKGcl8Pu1hMiXQ1hac0vAH0",
				UpdateTime:  timestamppb.New(ts),
				UpdateUser:  "user:updater@example.com",
				Acls: []*api.PrefixMetadata_ACL{
					{
						Role:       api.Role_OWNER,
						Principals: []string{"group:b"},
					},
					{
						Role:       api.Role_WRITER,
						Principals: []string{"user:a@example.com", "group:a"},
					},
				},
			}
			So(updated, ShouldResembleProto, expected)

			// Stored indeed.
			md, err := impl.GetMetadata(ctx, "z")
			So(err, ShouldBeNil)
			So(md, ShouldResembleProto, []*api.PrefixMetadata{rootMeta, expected})
		})

		Convey("UpdateMetadata call with failing callback", func() {
			cbErr := errors.New("blah")
			updated, err := impl.UpdateMetadata(ctx, "z", func(_ context.Context, md *api.PrefixMetadata) error {
				md.UpdateUser = "user:must-be-ignored@example.com"
				return cbErr
			})
			So(err, ShouldEqual, cbErr) // exact same error object
			So(updated, ShouldBeNil)

			// Still missing.
			md, err := impl.GetMetadata(ctx, "z")
			So(err, ShouldBeNil)
			So(md, ShouldResembleProto, []*api.PrefixMetadata{rootMeta})
		})
	})
}

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

	Convey("With datastore", t, func() {
		ctx := memory.Use(context.Background())
		ts := time.Unix(1525136124, 0).UTC()

		impl := legacyStorageImpl{}

		add := func(role, pfx, group string) {
			So(datastore.Put(ctx, &packageACL{
				ID:         role + ":" + pfx,
				Parent:     rootKey(ctx),
				ModifiedTS: ts,
				Groups:     []string{group},
			}), ShouldBeNil)
		}

		type visited struct {
			prefix string
			md     []string // pfx:role:principal, sorted
		}

		visit := func(pfx string) (res []visited) {
			err := impl.VisitMetadata(ctx, pfx, func(p string, md []*api.PrefixMetadata) (bool, error) {
				extract := []string{}
				for _, m := range md {
					for _, acl := range m.Acls {
						for _, p := range acl.Principals {
							extract = append(extract, fmt.Sprintf("%s:%s:%s", m.Prefix, acl.Role, p))
						}
					}
				}
				res = append(res, visited{p, extract})
				return true, nil
			})
			So(err, ShouldBeNil)
			return
		}

		add("OWNER", "a", "o-a")
		add("READER", "a", "r-a")

		add("OWNER", "a/b/c", "o-abc")
		add("READER", "a/b/c", "r-abc")
		add("WRITER", "a/b/c", "w-abc")

		add("READER", "a/b/c/d", "r-abcd")

		add("OWNER", "ab", "o-ab")
		add("READER", "ab", "r-ab")

		Convey("Root listing", func() {
			So(visit(""), ShouldResemble, []visited{
				{
					"", []string{
						":OWNER:group:administrators",
					},
				},
				{
					"a", []string{
						":OWNER:group:administrators",
						"a:OWNER:group:o-a",
						"a:READER:group:r-a",
					},
				},
				{
					"a/b/c", []string{
						":OWNER:group:administrators",
						"a:OWNER:group:o-a",
						"a:READER:group:r-a",
						"a/b/c:OWNER:group:o-abc",
						"a/b/c:WRITER:group:w-abc",
						"a/b/c:READER:group:r-abc",
					},
				},
				{
					"a/b/c/d", []string{
						":OWNER:group:administrators",
						"a:OWNER:group:o-a",
						"a:READER:group:r-a",
						"a/b/c:OWNER:group:o-abc",
						"a/b/c:WRITER:group:w-abc",
						"a/b/c:READER:group:r-abc",
						"a/b/c/d:READER:group:r-abcd",
					},
				},
				{
					"ab", []string{
						":OWNER:group:administrators",
						"ab:OWNER:group:o-ab",
						"ab:READER:group:r-ab",
					},
				},
			})
		})

		Convey("Prefix listing", func() {
			So(visit("a"), ShouldResemble, []visited{
				{
					"a", []string{
						":OWNER:group:administrators",
						"a:OWNER:group:o-a",
						"a:READER:group:r-a",
					},
				},
				{
					"a/b/c", []string{
						":OWNER:group:administrators",
						"a:OWNER:group:o-a",
						"a:READER:group:r-a",
						"a/b/c:OWNER:group:o-abc",
						"a/b/c:WRITER:group:w-abc",
						"a/b/c:READER:group:r-abc",
					},
				},
				{
					"a/b/c/d", []string{
						":OWNER:group:administrators",
						"a:OWNER:group:o-a",
						"a:READER:group:r-a",
						"a/b/c:OWNER:group:o-abc",
						"a/b/c:WRITER:group:w-abc",
						"a/b/c:READER:group:r-abc",
						"a/b/c/d:READER:group:r-abcd",
					},
				},
			})
		})

		Convey("Missing prefix listing", func() {
			So(visit("z/z/z"), ShouldResemble, []visited{
				{
					"z/z/z", []string{":OWNER:group:administrators"},
				},
			})
		})

		Convey("Callback return value is respected, stopping right away", func() {
			seen := []string{}
			err := impl.VisitMetadata(ctx, "a", func(p string, md []*api.PrefixMetadata) (bool, error) {
				seen = append(seen, p)
				return false, nil
			})
			So(err, ShouldBeNil)
			So(seen, ShouldResemble, []string{"a"})
		})

		Convey("Callback return value is respected, stopping later", func() {
			seen := []string{}
			err := impl.VisitMetadata(ctx, "a", func(p string, md []*api.PrefixMetadata) (bool, error) {
				seen = append(seen, p)
				return p != "a/b/c", nil
			})
			So(err, ShouldBeNil)
			So(seen, ShouldResemble, []string{"a", "a/b/c"}) // no a/b/c/d
		})
	})
}

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

	cases := []struct {
		id     string
		role   string
		prefix string
		err    string
	}{
		{"OWNER:a/b/c", "OWNER", "a/b/c", ""},
		{"OWNER", "", "", "not <role>:<prefix> pair"},
		{"UNKNOWN:a/b/c", "", "", "unrecognized role"},
		{"OWNER:///", "", "", "invalid package prefix"},
		{"OWNER:", "", "", "invalid package prefix"},
	}

	for _, c := range cases {
		Convey(fmt.Sprintf("works for %q", c.id), t, func() {
			role, pfx, err := (&packageACL{ID: c.id}).parseKey()
			So(role, ShouldEqual, c.role)
			So(pfx, ShouldEqual, c.prefix)
			if c.err == "" {
				So(err, ShouldBeNil)
			} else {
				So(err, ShouldErrLike, c.err)
			}
		})
	}
}

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

	Convey("With datastore", t, func() {
		ctx := memory.Use(context.Background())

		add := func(role, pfx string) {
			So(datastore.Put(ctx, &packageACL{
				ID:     role + ":" + pfx,
				Parent: rootKey(ctx),
				Groups: []string{"blah"}, //  to make sure bodies are fetched too
			}), ShouldBeNil)
		}

		list := func(role, pfx string) (out []string) {
			acls, err := listACLsByPrefix(ctx, role, pfx)
			So(err, ShouldBeNil)
			for _, acl := range acls {
				So(acl.Groups, ShouldResemble, []string{"blah"})
				out = append(out, acl.ID)
			}
			return
		}

		add("OWNER", "a")
		add("OWNER", "a/b/c")
		add("OWNER", "ab")
		add("READER", "a")
		add("READER", "a/b/c")
		add("READER", "a/b/c/d")
		add("READER", "ab")

		Convey("Root listing", func() {
			So(list("OWNER", ""), ShouldResemble, []string{
				"OWNER:a", "OWNER:a/b/c", "OWNER:ab",
			})
			So(list("READER", ""), ShouldResemble, []string{
				"READER:a", "READER:a/b/c", "READER:a/b/c/d", "READER:ab",
			})
			So(list("WRITER", ""), ShouldResemble, []string(nil))
		})

		Convey("Non-root listing", func() {
			So(list("OWNER", "a"), ShouldResemble, []string{"OWNER:a/b/c"})
			So(list("READER", "a"), ShouldResemble, []string{"READER:a/b/c", "READER:a/b/c/d"})
			So(list("WRITER", "a"), ShouldResemble, []string(nil))
		})

		Convey("Non-existing prefix listing", func() {
			So(list("OWNER", "z"), ShouldResemble, []string(nil))
		})
	})
}

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

	Convey("With metadataGraph", t, func() {
		ctx := memory.Use(context.Background())
		ts := time.Unix(1525136124, 0).UTC()

		gr := metadataGraph{}
		gr.init(&api.PrefixMetadata{
			Acls: []*api.PrefixMetadata_ACL{
				{
					Role:       api.Role_OWNER,
					Principals: []string{"group:root"},
				},
			},
		})

		insert := func(role, prefix, group string) {
			gr.insert(ctx, []*packageACL{
				{
					ID:         role + ":" + prefix,
					Parent:     rootKey(ctx),
					Groups:     []string{group},
					ModifiedTS: ts, // to mark as non-empty
				},
			})
		}

		type visited struct {
			prefix string
			md     []string // pfx:role:principal, sorted
		}

		freezeAndVisit := func(node string) (v []visited) {
			n := gr.node(node)
			gr.freeze(ctx)

			err := n.traverse(nil, func(n *metadataNode, md []*api.PrefixMetadata) (bool, error) {
				extract := []string{}
				for _, m := range md {
					for _, acl := range m.Acls {
						for _, p := range acl.Principals {
							extract = append(extract, fmt.Sprintf("%s:%s:%s", m.Prefix, acl.Role, p))
						}
					}
				}
				v = append(v, visited{n.prefix, extract})
				return true, nil
			})
			So(err, ShouldBeNil)
			return
		}

		insert("OWNER", "a/b/c/d", "owner-abc")
		insert("OWNER", "a", "owner-a")
		insert("OWNER", "b", "owner-b")
		insert("READER", "a", "reader-a")
		insert("READER", "a/b", "reader-ab")
		insert("READER", "a/bc", "reader-abc")
		insert("BOGUS", "a/b", "bogus-ab")

		Convey("Traverse from the root", func() {
			So(freezeAndVisit(""), ShouldResemble, []visited{
				{"", []string{":OWNER:group:root"}},
				{
					"a", []string{
						":OWNER:group:root",
						"a:OWNER:group:owner-a",
						"a:READER:group:reader-a",
					},
				},
				{
					"a/b", []string{
						":OWNER:group:root",
						"a:OWNER:group:owner-a",
						"a:READER:group:reader-a",
						"a/b:READER:group:reader-ab",
					},
				},
				{
					"a/b/c", []string{
						":OWNER:group:root",
						"a:OWNER:group:owner-a",
						"a:READER:group:reader-a",
						"a/b:READER:group:reader-ab",
					},
				},
				{
					"a/b/c/d", []string{
						":OWNER:group:root",
						"a:OWNER:group:owner-a",
						"a:READER:group:reader-a",
						"a/b:READER:group:reader-ab",
						"a/b/c/d:OWNER:group:owner-abc",
					},
				},
				{
					"a/bc", []string{
						":OWNER:group:root",
						"a:OWNER:group:owner-a",
						"a:READER:group:reader-a",
						"a/bc:READER:group:reader-abc",
					},
				},
				{
					"b", []string{
						":OWNER:group:root",
						"b:OWNER:group:owner-b",
					},
				},
			})
		})

		Convey("Traverse from some prefix", func() {
			So(freezeAndVisit("a/b"), ShouldResemble, []visited{
				{
					"a/b", []string{
						":OWNER:group:root",
						"a:OWNER:group:owner-a",
						"a:READER:group:reader-a",
						"a/b:READER:group:reader-ab",
					},
				},
				{
					"a/b/c", []string{
						":OWNER:group:root",
						"a:OWNER:group:owner-a",
						"a:READER:group:reader-a",
						"a/b:READER:group:reader-ab",
					},
				},
				{
					"a/b/c/d", []string{
						":OWNER:group:root",
						"a:OWNER:group:owner-a",
						"a:READER:group:reader-a",
						"a/b:READER:group:reader-ab",
						"a/b/c/d:OWNER:group:owner-abc",
					},
				},
			})
		})

		Convey("Traverse from some deep prefix", func() {
			So(freezeAndVisit("a/b/c/d/e"), ShouldResemble, []visited{
				{
					"a/b/c/d/e", []string{
						":OWNER:group:root",
						"a:OWNER:group:owner-a",
						"a:READER:group:reader-a",
						"a/b:READER:group:reader-ab",
						"a/b/c/d:OWNER:group:owner-abc",
					},
				},
			})
		})

		Convey("Traverse from some non-existing prefix", func() {
			So(freezeAndVisit("z/z/z"), ShouldResemble, []visited{
				{
					"z/z/z", []string{":OWNER:group:root"},
				},
			})
		})
	})
}