LogDog: Implement RegisterPrefix RPC.

appengine/logdog/coordinator/endpoints/services/registerStream_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 22 matching lines @@
 
                 // Set our archival delays. The project delay is smaller than the service
                 // delay, so it should be used.
                 env.ModServiceConfig(c, func(cfg *svcconfig.Config) {
                         cfg.Coordinator.ArchiveDelayMax = google.NewDuration(24 * time.Hour)
                 })
                 env.ModProjectConfig(c, "proj-foo", func(pcfg *svcconfig.ProjectConfig) {
                         pcfg.MaxStreamAge = google.NewDuration(time.Hour)
                 })
 
+                // By default, the testing user is a service.
+                env.JoinGroup("services")
+
                 svr := New()
 
                 Convey(`Returns Forbidden error if not a service.`, func() {
+                        env.LeaveAllGroups()
+
                         _, err := svr.RegisterStream(c, &logdog.RegisterStreamRequest{})
                         So(err, ShouldBeRPCPermissionDenied)
                 })
 
-                Convey(`When logged in as a service`, func() {
-                        env.JoinGroup("services")
-
+                Convey(`When registering a testing log sream, "testing/+/foo/bar"`, func() {
                         tls := ct.MakeStream(c, "proj-foo", "testing/+/foo/bar")
 
-                        Convey(`A stream registration request for "testing/+/foo/bar"`, func() {
-                                req := logdog.RegisterStreamRequest{
-                                        Project:      string(tls.Project),
-                                        Secret:       tls.Prefix.Secret,
-                                        ProtoVersion: logpb.Version,
-                                        Desc:         tls.DescBytes(),
-                                }
+                        req := logdog.RegisterStreamRequest{
+                                Project:      string(tls.Project),
+                                Secret:       tls.Prefix.Secret,
+                                ProtoVersion: logpb.Version,
+                                Desc:         tls.DescBytes(),
+                        }
+
+                        Convey(`Returns FailedPrecondition when the Prefix is not registered.`, func() {
+                                _, err := svr.RegisterStream(c, &req)
+                                So(err, ShouldBeRPCFailedPrecondition)
+                        })
+
+                        Convey(`When the Prefix is registered`, func() {
+                                tls.WithProjectNamespace(c, func(c context.Context) {
+                                        if err := ds.Get(c).Put(tls.Prefix); err != nil {
+                                                panic(err)
+                                        }
+                                })
 
                                 expResp := &logdog.RegisterStreamResponse{
                                         Id: string(tls.Stream.ID),
                                         State: &logdog.LogStreamState{
                                                 Secret:        tls.Prefix.Secret,
                                                 ProtoVersion:  logpb.Version,
                                                 TerminalIndex: -1,
                                         },
                                 }
 
@@ skipping 66 matching lines @@
                                                         env.Clock.Set(created.Add(time.Hour)) // 1 hour after initial registration.
                                                         env.DrainTumbleAll(c)
 
                                                         So(env.ArchivalPublisher.Hashes(), ShouldResemble, []string{string(tls.Stream.ID)})
                                                 })
                                         })
 
                                         Convey(`Will not re-register if secrets don't match.`, func() {
                                                 req.Secret[0] = 0xAB
                                                 _, err := svr.RegisterStream(c, &req)
-                                                So(err, ShouldBeRPCAlreadyExists, "Log prefix is already registered")
+                                                So(err, ShouldBeRPCInvalidArgument, "invalid secret")
                                         })
                                 })
 
                                 Convey(`Will schedule the correct archival expiration delay`, func() {
                                         Convey(`When there is no project config delay.`, func() {
                                                 env.ModProjectConfig(c, "proj-foo", func(pcfg *svcconfig.ProjectConfig) {
                                                         pcfg.MaxStreamAge = nil
                                                 })
 
                                                 _, err := svr.RegisterStream(c, &req)
@@ skipping 52 matching lines @@
                                                 _, err := svr.RegisterStream(c, &req)
                                                 So(err, ShouldBeRPCInvalidArgument, "Unrecognized protobuf version")
                                         })
 
                                         Convey(`Will not register a stream with an unknown protobuf version.`, func() {
                                                 req.ProtoVersion = "unknown"
                                                 _, err := svr.RegisterStream(c, &req)
                                                 So(err, ShouldBeRPCInvalidArgument, "Unrecognized protobuf version")
                                         })
 
-                                        Convey(`Will not register a wrong-sized secret.`, func() {
-                                                req.Secret = nil
-                                                _, err := svr.RegisterStream(c, &req)
-                                                So(err, ShouldBeRPCInvalidArgument, "Invalid prefix secret")
-                                        })
-
                                         Convey(`Will not register with an empty descriptor.`, func() {
                                                 req.Desc = nil
 
                                                 _, err := svr.RegisterStream(c, &req)
                                                 So(err, ShouldBeRPCInvalidArgument, "Invalid log stream descriptor")
                                         })
 
                                         Convey(`Will not register if the descriptor doesn't validate.`, func() {
                                                 tls.Desc.ContentType = ""
                                                 So(tls.Desc.Validate(true), ShouldNotBeNil)
@@ skipping 23 matching lines @@
                                                 fb.BreakFeatures(errors.New("test error"), "PutMulti")
 
                                                 _, err := rsm.RollForward(c)
                                                 So(err, ShouldBeRPCInternal)
                                         })
                                 })
                         })
                 })
         })
 }