LogDog: Project READ access for user endpoints.

appengine/logdog/coordinator/endpoints/services/terminateStream_test.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package services
 
 import (
         "errors"
         "testing"
         "time"
@@ skipping 12 matching lines @@
         . "github.com/luci/luci-go/common/testing/assertions"
         . "github.com/smartystreets/goconvey/convey"
 )
 
 func TestTerminateStream(t *testing.T) {
         t.Parallel()
 
         Convey(`With a testing configuration`, t, func() {
                 c, env := ct.Install()
 
+                // Set our archival delays. The project delay is smaller than the service
+                // delay, so it should be used.
                 env.ModServiceConfig(c, func(cfg *svcconfig.Coordinator) {
                         cfg.ArchiveTopic = "projects/test/topics/archive"
                         cfg.ArchiveSettleDelay = google.NewDuration(10 * time.Second)
                         cfg.ArchiveDelayMax = google.NewDuration(24 * time.Hour)
                 })
+                env.ModProjectConfig("proj-foo", func(pcfg *svcconfig.ProjectConfig) {
+                        pcfg.MaxStreamAge = google.NewDuration(time.Hour)
+                })
 
                 svr := New()
 
                 tls := ct.MakeStream(c, "proj-foo", "testing/+/foo/bar")
 
                 req := logdog.TerminateStreamRequest{
                         Project:       string(tls.Project),
                         Id:            string(tls.Stream.ID),
                         Secret:        tls.Prefix.Secret,
                         TerminalIndex: 1337,
@@ skipping 38 matching lines @@
                                         })
                                         So(tls.State.TerminalIndex, ShouldEqual, 1337)
                                         So(tls.State.Terminated(), ShouldBeTrue)
                                         So(tls.State.ArchivalState(), ShouldEqual, coordinator.ArchiveTasked)
                                         So(env.ArchivalPublisher.Hashes(), ShouldResemble, []string{string(tls.Stream.ID)})
 
                                         // Assert that all archive tasks are scheduled ArchiveSettleDelay in
                                         // the future.
                                         for _, t := range env.ArchivalPublisher.Tasks() {
                                                 So(t.SettleDelay.Duration(), ShouldEqual, 10*time.Second)
-                                                So(t.CompletePeriod.Duration(), ShouldEqual, 24*time.Hour)
+                                                So(t.CompletePeriod.Duration(), ShouldEqual, time.Hour)
                                         }
 
                                         Convey(`Will cancel the expiration archive Tumble task.`, func() {
                                                 // We will test this by reverting the stream to be not terminated
                                                 // so that if the Tumble task gets fired, it will try and schedule
                                                 // another archival task.
                                                 env.ArchivalPublisher.Clear()
 
                                                 tls.State.TerminalIndex = -1
                                                 So(tls.Put(c), ShouldBeNil)
@@ skipping 35 matching lines @@
 
                                                 // Reload state and confirm.
                                                 So(tls.Get(c), ShouldBeNil)
 
                                                 So(tls.State.TerminalIndex, ShouldEqual, 1337)
                                                 So(tls.State.Terminated(), ShouldBeTrue)
                                                 So(tls.State.ArchivalState(), ShouldEqual, coordinator.ArchiveTasked)
                                         })
                                 })
 
+                                Convey(`Will schedule the correct archival delay`, func() {
+
+                                        Convey(`When there is no project config delay.`, func() {
+                                                env.ModProjectConfig("proj-foo", func(pcfg *svcconfig.ProjectConfig) {
+                                                        pcfg.MaxStreamAge = nil
+                                                })
+
+                                                _, err := svr.TerminateStream(c, &req)
+                                                So(err, ShouldBeRPCOK)
+
+                                                So(env.ArchivalPublisher.Hashes(), ShouldResemble, []string{string(tls.Stream.ID)})
+                                                So(len(env.ArchivalPublisher.Tasks()), ShouldEqual, 1)
+                                                So(env.ArchivalPublisher.Tasks()[0].CompletePeriod.Duration(), ShouldEqual, 24*time.Hour)
+                                        })
+
+                                        Convey(`When there is no service or project config delay.`, func() {
+                                                env.ModServiceConfig(c, func(cfg *svcconfig.Coordinator) {
+                                                        cfg.ArchiveDelayMax = nil
+                                                })
+                                                env.ModProjectConfig("proj-foo", func(pcfg *svcconfig.ProjectConfig) {
+                                                        pcfg.MaxStreamAge = nil
+                                                })
+
+                                                _, err := svr.TerminateStream(c, &req)
+                                                So(err, ShouldBeRPCOK)
+
+                                                So(env.ArchivalPublisher.Hashes(), ShouldResemble, []string{string(tls.Stream.ID)})
+                                                So(len(env.ArchivalPublisher.Tasks()), ShouldEqual, 1)
+                                                So(env.ArchivalPublisher.Tasks()[0].CompletePeriod.Duration(), ShouldEqual, 0)
+                                        })
+                                })
+
                                 Convey(`Will return an internal server error if Put() fails.`, func() {
                                         c, fb := featureBreaker.FilterRDS(c, nil)
                                         fb.BreakFeatures(errors.New("test error"), "PutMulti")
                                         _, err := svr.TerminateStream(c, &req)
                                         So(err, ShouldBeRPCInternal)
                                 })
 
                                 Convey(`Will return an internal server error if Get() fails.`, func() {
                                         c, fb := featureBreaker.FilterRDS(c, nil)
                                         fb.BreakFeatures(errors.New("test error"), "GetMulti")
@@ skipping 14 matching lines @@
                                 So(err, ShouldBeRPCInvalidArgument, "Invalid ID")
                         })
 
                         Convey(`Will fail if the stream is not registered.`, func() {
                                 _, err := svr.TerminateStream(c, &req)
                                 So(err, ShouldBeRPCNotFound, "is not registered")
                         })
                 })
         })
 }