[scheduler]: ACLs phase 3 - require ACLs specs for each Job/Trigger.

scheduler/appengine/engine/engine_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,
@@ skipping 69 matching lines @@
                 e, _ := newTestEngine()
 
                 // Doing nothing.
                 So(e.UpdateProjectJobs(c, "abc", []catalog.Definition{}), ShouldBeNil)
                 So(allJobs(c), ShouldResemble, []Job{})
 
                 // Adding a new job (ticks every 5 sec).
                 So(e.UpdateProjectJobs(c, "abc", []catalog.Definition{
                         {
                                 JobID:    "abc/1",
-                                Revision: "rev1",
-                                Schedule: "*/5 * * * * * *",
-                        }}), ShouldBeNil)
-                So(allJobs(c), ShouldResemble, []Job{
-                        {
-                                JobID:     "abc/1",
-                                ProjectID: "abc",
-                                Revision:  "rev1",
-                                Enabled:   true,
-                                Schedule:  "*/5 * * * * * *",
-                                State: JobState{
-                                        State:     "SCHEDULED",
-                                        TickNonce: 6278013164014963328,
-                                        TickTime:  epoch.Add(5 * time.Second),
-                                },
-                        },
-                })
-
-                // TODO(tandrii): delete and update above definition after no-ACL -> ACL transition.
-                // Simulate ACL version roll without change of project config.
-                So(e.UpdateProjectJobs(c, "abc", []catalog.Definition{
-                        {
-                                JobID:    "abc/1",
                                 Revision: "rev1",
                                 Schedule: "*/5 * * * * * *",
                                 Acls:     acl.GrantsByRole{Readers: []string{"group:r"}, Owners: []string{"groups:o"}},
                         }}), ShouldBeNil)
                 So(allJobs(c), ShouldResemble, []Job{
                         {
                                 JobID:     "abc/1",
                                 ProjectID: "abc",
                                 Revision:  "rev1",
                                 Enabled:   true,
@@ skipping 442 matching lines @@
                 So(err, ShouldBeNil)
 
                 So(newer, ShouldBeLessThan, older)
         })
 }
 
 func TestQueries(t *testing.T) {
         Convey("with mock data", t, func() {
                 c := newTestContext(epoch)
                 e, _ := newTestEngine()
-                // TODO(tandrii): remove aclDefault once all Jobs have ACLs.
-                aclDefault := acl.GrantsByRole{}
+                aclPublic := acl.GrantsByRole{Readers: []string{"group:all"}, Owners: []string{"group:administrators"}}
                 aclSome := acl.GrantsByRole{Readers: []string{"group:some"}}
                 aclOne := acl.GrantsByRole{Owners: []string{"one@example.com"}}
                 aclAdmin := acl.GrantsByRole{Readers: []string{"group:administrators"}, Owners: []string{"group:administrators"}}
 
                 ctxAnon := auth.WithState(c, &authtest.FakeState{
-                        Identity: "anonymous:anonymous",
+                        Identity:       "anonymous:anonymous",
+                        IdentityGroups: []string{"all"},
                 })
                 ctxOne := auth.WithState(c, &authtest.FakeState{
                         Identity:       "user:one@example.com",
                         IdentityGroups: []string{"all"},
                 })
                 ctxSome := auth.WithState(c, &authtest.FakeState{
                         Identity:       "user:some@example.com",
-                        IdentityGroups: []string{"some"},
+                        IdentityGroups: []string{"all", "some"},
                 })
                 ctxAdmin := auth.WithState(c, &authtest.FakeState{
                         Identity:       "user:admin@example.com",
-                        IdentityGroups: []string{"administrators"},
+                        IdentityGroups: []string{"administrators", "all"},
                 })
 
                 So(ds.Put(c,
                         &Job{JobID: "abc/1", ProjectID: "abc", Enabled: true, Acls: aclOne},
                         &Job{JobID: "abc/2", ProjectID: "abc", Enabled: true, Acls: aclSome},
-                        &Job{JobID: "abc/3", ProjectID: "abc", Enabled: true, Acls: aclDefault},
-                        &Job{JobID: "def/1", ProjectID: "def", Enabled: true, Acls: aclDefault},
-                        &Job{JobID: "def/2", ProjectID: "def", Enabled: false, Acls: aclDefault},
+                        &Job{JobID: "abc/3", ProjectID: "abc", Enabled: true, Acls: aclPublic},
+                        &Job{JobID: "def/1", ProjectID: "def", Enabled: true, Acls: aclPublic},
+                        &Job{JobID: "def/2", ProjectID: "def", Enabled: false, Acls: aclPublic},
                         &Job{JobID: "secret/1", ProjectID: "secret", Enabled: true, Acls: aclAdmin},
                 ), ShouldBeNil)
 
                 job1 := ds.NewKey(c, "Job", "abc/1", 0, nil)
                 job2 := ds.NewKey(c, "Job", "abc/2", 0, nil)
                 job3 := ds.NewKey(c, "Job", "abc/3", 0, nil)
                 So(ds.Put(c,
                         &Invocation{ID: 1, JobKey: job1, InvocationNonce: 123},
                         &Invocation{ID: 2, JobKey: job1, InvocationNonce: 123},
                         &Invocation{ID: 3, JobKey: job1},
@@ skipping 646 matching lines @@
 
 func ensureOneTask(c context.Context, q string) *tq.Task {
         tqt := tq.GetTestable(c)
         tasks := tqt.GetScheduledTasks()[q]
         So(len(tasks), ShouldEqual, 1)
         for _, t := range tasks {
                 return t
         }
         return nil
 }