LogDog: Update to archival V2.

appengine/logdog/coordinator/endpoints/logs/query_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 logs
 
 import (
         "fmt"
         "sort"
         "testing"
@@ skipping 135 matching lines @@
                                 "name":   string(name),
                         }
 
                         // Set an empty tag for each name segment.
                         for _, p := range name.Segments() {
                                 desc.Tags[p] = ""
                         }
 
                         ls := ct.TestLogStream(c, desc)
 
+                        now := tc.Now().UTC()
                         psegs := prefix.Segments()
                         if psegs[0] == "meta" {
                                 for _, p := range psegs[1:] {
                                         switch p {
                                         case "purged":
                                                 ls.Purged = true
 
                                         case "terminated":
-                                                ls.State = coordinator.LSTerminated
                                                 ls.TerminalIndex = 1337
+                                                ls.TerminatedTime = now
 
                                         case "archived":
+                                                ls.State = coordinator.LSArchived
+
+                                                ls.TerminalIndex = 1337
+                                                ls.TerminatedTime = now
+
                                                 ls.ArchiveStreamURL = "http://example.com"
-                                                ls.State = coordinator.LSArchived
+                                                ls.ArchivedTime = now
 
                                         case "datagram":
                                                 ls.StreamType = logpb.StreamType_DATAGRAM
 
                                         case "binary":
                                                 ls.StreamType = logpb.StreamType_BINARY
                                         }
                                 }
                         }
 
-                        if err := ls.Put(ds.Get(c)); err != nil {
+                        if err := ds.Get(c).Put(ls); err != nil {
                                 panic(fmt.Errorf("failed to put log stream %d: %v", i, err))
                         }
 
                         descs[string(v)] = desc
                         streams[string(v)] = ls
                         if !ls.Purged {
                                 streamPaths = append(streamPaths, string(v))
                         }
                         purgedStreamPaths = append(purgedStreamPaths, string(v))
                         tc.Add(time.Second)
@@ skipping 72 matching lines @@
                                         So(err, ShouldBeRPCOK)
                                         So(resp, shouldHaveLogPaths, "testing/+/baz")
 
                                         So(resp.Streams, ShouldHaveLength, 1)
                                         So(resp.Streams[0].State, ShouldResemble, loadLogStreamState(stream))
                                         So(resp.Streams[0].Desc, ShouldResemble, desc)
                                         So(resp.Streams[0].DescProto, ShouldBeNil)
                                 })
 
                                 Convey(`When not requesting protobufs, and with a corrupt descriptor, returns InternalServer error.`, func() {
-                                        // We can't use "stream.Put" here because it validates the protobuf!
+                                        stream.SetDSValidate(false)
                                         stream.Descriptor = []byte{0x00} // Invalid protobuf, zero tag.
                                         So(di.Put(stream), ShouldBeNil)
                                         di.Testable().CatchupIndexes()
 
                                         _, err := s.Query(c, &req)
                                         So(err, ShouldBeRPCInternal)
                                 })
 
                                 Convey(`When requesting protobufs, returns the raw protobuf descriptor.`, func() {
                                         req.Proto = true
@@ skipping 220 matching lines @@
 
                         Convey(`When an invalid tag is specified, returns BadRequest error`, func() {
                                 req.Tags["+++not a valid tag+++"] = ""
 
                                 _, err := s.Query(c, &req)
                                 So(err, ShouldBeRPCInvalidArgument, "invalid tag constraint")
                         })
                 })
         })
 }