LogDog: Add project namespace to service endpoint.

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 (
         "bytes"
         "errors"
         "testing"
@@ skipping 23 matching lines @@
 
         Convey(`With a testing configuration`, t, func() {
                 tt := &tumble.Testing{}
                 c := tt.Context()
                 tc := clock.Get(c).(testclock.TestClock)
 
                 // Add Tumble delayed mutation index.
                 tt.EnableDelayedMutations(c)
                 ds.Get(c).Testable().Consistent(true)
 
+                fs := authtest.FakeState{}
+                c = auth.WithState(c, &fs)
+
                 var tap ct.ArchivalPublisher
                 svcStub := ct.Services{
                         AP: func() (coordinator.ArchivalPublisher, error) {
                                 return &tap, nil
                         },
                 }
                 svcStub.InitConfig()
                 svcStub.ServiceConfig.Coordinator.ServiceAuthGroup = "test-services"
                 svcStub.ServiceConfig.Coordinator.ArchiveDelayMax = google.NewDuration(time.Hour)
                 c = coordinator.WithServices(c, &svcStub)
 
                 svr := New()
 
-                fs := authtest.FakeState{}
-                c = auth.WithState(c, &fs)
-
                 Convey(`Returns Forbidden error if not a service.`, func() {
                         _, err := svr.RegisterStream(c, &logdog.RegisterStreamRequest{})
                         So(err, ShouldBeRPCPermissionDenied)
                 })
 
                 Convey(`When logged in as a service`, func() {
                         fs.IdentityGroups = []string{"test-services"}
 
                         desc := ct.TestLogStreamDescriptor(c, "foo/bar")
-                        secret := bytes.Repeat([]byte{0xAA}, types.StreamSecretLength)
+                        secret := bytes.Repeat([]byte{0xAA}, types.PrefixSecretLength)
 
                         Convey(`A stream registration request for "testing/+/foo/bar"`, func() {
                                 req := logdog.RegisterStreamRequest{
                                         Path:         "testing/+/foo/bar",
                                         Secret:       secret,
                                         ProtoVersion: logpb.Version,
                                         Desc:         desc,
                                 }
 
                                 expResp := &logdog.RegisterStreamResponse{
@@ skipping 109 matching lines @@
 
                                         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 secret length")
+                                                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, "Missing log stream descriptor.")
                                         })
 
                                         Convey(`Will not register if the descriptor's Prefix doesn't match.`, func() {
                                                 req.Desc.Prefix = "different"
@@ skipping 12 matching lines @@
                                                 So(req.Desc.Validate(true), ShouldNotBeNil)
 
                                                 _, err := svr.RegisterStream(c, &req)
                                                 So(err, ShouldBeRPCInvalidArgument, "Invalid log stream descriptor")
                                         })
                                 })
                         })
                 })
         })
 }