func (s *LogTailerSuite) TestNoTail(c *gc.C) { expected := logTemplate{Message: "want"} s.writeLogs(c, 2, expected) // Write a log entry that's only in the oplog. doc := s.logTemplateToDoc(logTemplate{Message: "dont want"}, coretesting.ZeroTime()) err := s.writeLogToOplog(doc) c.Assert(err, jc.ErrorIsNil) tailer, err := state.NewLogTailer(s.otherState, &state.LogTailerParams{ NoTail: true, }) c.Assert(err, jc.ErrorIsNil) // Not strictly necessary, just in case NoTail doesn't work in the test. defer tailer.Stop() // Logs only in the oplog shouldn't be reported and the tailer // should stop itself once the log collection has been read. s.assertTailer(c, tailer, 2, expected) select { case _, ok := <-tailer.Logs(): if ok { c.Fatal("shouldn't be any further logs") } case <-time.After(coretesting.LongWait): c.Fatal("timed out waiting for logs channel to close") } select { case <-tailer.Dying(): // Success. case <-time.After(coretesting.LongWait): c.Fatal("tailer didn't stop itself") } }
func (s *LogsSuite) TestDbLogger(c *gc.C) { logger := state.NewDbLogger(s.State, names.NewMachineTag("22"), jujuversion.Current) defer logger.Close() t0 := coretesting.ZeroTime().Truncate(time.Millisecond) // MongoDB only stores timestamps with ms precision. logger.Log(t0, "some.where", "foo.go:99", loggo.INFO, "all is well") t1 := t0.Add(time.Second) logger.Log(t1, "else.where", "bar.go:42", loggo.ERROR, "oh noes") var docs []bson.M err := s.logsColl.Find(nil).Sort("t").All(&docs) c.Assert(err, jc.ErrorIsNil) c.Assert(docs, gc.HasLen, 2) c.Assert(docs[0]["t"], gc.Equals, t0.UnixNano()) c.Assert(docs[0]["e"], gc.Equals, s.State.ModelUUID()) c.Assert(docs[0]["n"], gc.Equals, "machine-22") c.Assert(docs[0]["m"], gc.Equals, "some.where") c.Assert(docs[0]["l"], gc.Equals, "foo.go:99") c.Assert(docs[0]["v"], gc.Equals, int(loggo.INFO)) c.Assert(docs[0]["x"], gc.Equals, "all is well") c.Assert(docs[1]["t"], gc.Equals, t1.UnixNano()) c.Assert(docs[1]["e"], gc.Equals, s.State.ModelUUID()) c.Assert(docs[1]["n"], gc.Equals, "machine-22") c.Assert(docs[1]["m"], gc.Equals, "else.where") c.Assert(docs[1]["l"], gc.Equals, "bar.go:42") c.Assert(docs[1]["v"], gc.Equals, int(loggo.ERROR)) c.Assert(docs[1]["x"], gc.Equals, "oh noes") }
func (s *metadataSuite) TestBuildMetadata(c *gc.C) { archive, err := os.Create(filepath.Join(c.MkDir(), "juju-backup.tgz")) c.Assert(err, jc.ErrorIsNil) _, err = archive.Write([]byte("<compressed data>")) c.Assert(err, jc.ErrorIsNil) fi, err := archive.Stat() c.Assert(err, jc.ErrorIsNil) finished := backups.FileTimestamp(fi).Unix() meta, err := backups.BuildMetadata(archive) c.Assert(err, jc.ErrorIsNil) c.Check(meta.ID(), gc.Equals, "") c.Check(meta.Checksum(), gc.Equals, "2jmj7l5rSw0yVb/vlWAYkK/YBwk=") c.Check(meta.ChecksumFormat(), gc.Equals, "SHA-1, base64 encoded") c.Check(meta.Size(), gc.Equals, int64(17)) c.Check(meta.Stored(), gc.IsNil) c.Check(meta.Started.Unix(), gc.Equals, int64(testing.ZeroTime().Unix())) c.Check(meta.Finished.Unix(), gc.Equals, finished) c.Check(meta.Notes, gc.Equals, "") c.Check(meta.Origin.Model, gc.Equals, backups.UnknownString) c.Check(meta.Origin.Machine, gc.Equals, backups.UnknownString) c.Check(meta.Origin.Hostname, gc.Equals, backups.UnknownString) c.Check(meta.Origin.Version.String(), gc.Equals, backups.UnknownVersion.String()) }
func newFixture(period time.Duration) workerFixture { return workerFixture{ revisionUpdater: newMockRevisionUpdater(), clock: testing.NewClock(coretesting.ZeroTime()), period: period, } }
func (s *MachineStatusSuite) checkGetSetStatus(c *gc.C) { now := testing.ZeroTime() sInfo := status.StatusInfo{ Status: status.Started, Message: "blah", Data: map[string]interface{}{ "$foo.bar.baz": map[string]interface{}{ "pew.pew": "zap", }, }, Since: &now, } err := s.machine.SetStatus(sInfo) c.Check(err, jc.ErrorIsNil) machine, err := s.State.Machine(s.machine.Id()) c.Assert(err, jc.ErrorIsNil) statusInfo, err := machine.Status() c.Check(err, jc.ErrorIsNil) c.Check(statusInfo.Status, gc.Equals, status.Started) c.Check(statusInfo.Message, gc.Equals, "blah") c.Check(statusInfo.Data, jc.DeepEquals, map[string]interface{}{ "$foo.bar.baz": map[string]interface{}{ "pew.pew": "zap", }, }) c.Check(statusInfo.Since, gc.NotNil) }
func (s *SkewSuite) TestBracketedWrite(c *gc.C) { now := coretesting.ZeroTime() c.Logf("now: %s", now) oneSecondAgo := now.Add(-time.Second) twoSecondsAgo := now.Add(-2 * time.Second) threeSecondsAgo := now.Add(-3 * time.Second) fiveSecondsAgo := now.Add(-5 * time.Second) oneSecondLater := now.Add(time.Second) // Where T is the current local time: // between T-5 and T-1, we read T-2 from the remote clock. skew := lease.Skew{ LastWrite: twoSecondsAgo, Beginning: fiveSecondsAgo, End: oneSecondAgo, } // If the remote wrote a long time ago -- say, 20 minutes ago it thought // it was two seconds before now -- its clock could be arbitrarily far // ahead of ours. But we know that when we started reading, 5 seconds ago, // it might not have seen a time later than 2 seconds in the past; so // right now, five seconds after that, it might not have seen a time later // than three seconds in the future. c.Check(skew.Earliest(now), gc.DeepEquals, threeSecondsAgo) // If the remote wrote at the very last moment -- exactly one second ago, // it thought it was 2 seconds in the past -- it could have a clock one // second behind ours. If so, the *latest* time at which it might still // have thought it was before now is one second in the future. c.Check(skew.Latest(now), gc.DeepEquals, oneSecondLater) }
func (s *SkewSuite) TestApparentPastWrite(c *gc.C) { now := coretesting.ZeroTime() c.Logf("now: %s", now) oneSecondAgo := now.Add(-time.Second) threeSecondsAgo := now.Add(-3 * time.Second) nineSecondsAgo := now.Add(-9 * time.Second) sixSecondsLater := now.Add(6 * time.Second) eightSecondsLater := now.Add(8 * time.Second) // Where T is the current local time: // between T-3 and T-1, we read T-9 from the remote clock. skew := lease.Skew{ LastWrite: nineSecondsAgo, Beginning: threeSecondsAgo, End: oneSecondAgo, } // If the remote wrote a long time ago -- say, 20 minutes ago it thought it // was 9 seconds ago -- its clock could be arbitrarily far ahead of ours. // But we know that when we started reading, 3 seconds ago, it might not // have seen a time later than 9 seconds ago; so right now, three seconds // after that, it might not have seen a time later than 6 seconds ago. c.Check(skew.Earliest(now), gc.DeepEquals, sixSecondsLater) // If the remote wrote at the very last moment -- exactly one second ago, // it thought it was nine seconds ago -- it could have a clock a full 8 // seconds behind ours. If so, the *latest* time at which it *might* still // think it's before now is 8 seconds in the future. c.Check(skew.Latest(now), gc.DeepEquals, eightSecondsLater) }
func (s *ServiceStatusSuite) TestSetStatusSince(c *gc.C) { now := testing.ZeroTime() sInfo := status.StatusInfo{ Status: status.Maintenance, Message: "", Since: &now, } err := s.service.SetStatus(sInfo) c.Assert(err, jc.ErrorIsNil) statusInfo, err := s.service.Status() c.Assert(err, jc.ErrorIsNil) firstTime := statusInfo.Since c.Assert(firstTime, gc.NotNil) c.Assert(timeBeforeOrEqual(now, *firstTime), jc.IsTrue) // Setting the same status a second time also updates the timestamp. now = now.Add(1 * time.Second) sInfo = status.StatusInfo{ Status: status.Maintenance, Message: "", Since: &now, } err = s.service.SetStatus(sInfo) c.Assert(err, jc.ErrorIsNil) statusInfo, err = s.service.Status() c.Assert(err, jc.ErrorIsNil) c.Assert(timeBeforeOrEqual(*firstTime, *statusInfo.Since), jc.IsTrue) }
func (s *ServiceStatusSuite) checkGetSetStatus(c *gc.C) { now := testing.ZeroTime() sInfo := status.StatusInfo{ Status: status.Active, Message: "healthy", Data: map[string]interface{}{ "$ping": map[string]interface{}{ "foo.bar": 123, }, }, Since: &now, } err := s.service.SetStatus(sInfo) c.Check(err, jc.ErrorIsNil) service, err := s.State.Application(s.service.Name()) c.Assert(err, jc.ErrorIsNil) statusInfo, err := service.Status() c.Check(err, jc.ErrorIsNil) c.Check(statusInfo.Status, gc.Equals, status.Active) c.Check(statusInfo.Message, gc.Equals, "healthy") c.Check(statusInfo.Data, jc.DeepEquals, map[string]interface{}{ "$ping": map[string]interface{}{ "foo.bar": 123, }, }) c.Check(statusInfo.Since, gc.NotNil) }
func (s *ResourcePersistenceSuite) TestSetCharmStoreResourceOkay(c *gc.C) { lastPolled := coretesting.NonZeroTime().UTC() applicationname := "a-application" res, doc := newPersistenceResource(c, applicationname, "spam") expected := doc // a copy expected.DocID += "#charmstore" expected.Username = "" expected.Timestamp = coretesting.ZeroTime() expected.StoragePath = "" expected.LastPolled = lastPolled p := NewResourcePersistence(s.base) ignoredErr := errors.New("<never reached>") s.stub.SetErrors(nil, nil, nil, ignoredErr) err := p.SetCharmStoreResource(res.ID, res.ApplicationID, res.Resource.Resource, lastPolled) c.Assert(err, jc.ErrorIsNil) s.stub.CheckCallNames(c, "Run", "ApplicationExistsOps", "RunTransaction", ) s.stub.CheckCall(c, 2, "RunTransaction", []txn.Op{{ C: "resources", Id: "resource#a-application/spam#charmstore", Assert: txn.DocMissing, Insert: &expected, }, { C: "application", Id: "a-application", Assert: txn.DocExists, }}) }
func (s *ModelStatusSuite) checkGetSetStatus(c *gc.C) { now := testing.ZeroTime() sInfo := status.StatusInfo{ Status: status.Available, Message: "blah", Data: map[string]interface{}{ "$foo.bar.baz": map[string]interface{}{ "pew.pew": "zap", }}, Since: &now, } err := s.model.SetStatus(sInfo) c.Check(err, jc.ErrorIsNil) model, err := s.State.GetModel(s.model.ModelTag()) c.Assert(err, jc.ErrorIsNil) statusInfo, err := model.Status() c.Check(err, jc.ErrorIsNil) c.Check(statusInfo.Status, gc.Equals, status.Available) c.Check(statusInfo.Message, gc.Equals, "blah") c.Check(statusInfo.Data, jc.DeepEquals, map[string]interface{}{ "$foo.bar.baz": map[string]interface{}{ "pew.pew": "zap", }, }) c.Check(statusInfo.Since, gc.NotNil) }
func (s *FilesystemStatusSuite) checkGetSetStatus(c *gc.C) { now := testing.ZeroTime() sInfo := status.StatusInfo{ Status: status.Attaching, Message: "blah", Data: map[string]interface{}{ "$foo.bar.baz": map[string]interface{}{ "pew.pew": "zap", }, }, Since: &now, } err := s.filesystem.SetStatus(sInfo) c.Check(err, jc.ErrorIsNil) filesystem, err := s.State.Filesystem(s.filesystem.FilesystemTag()) c.Assert(err, jc.ErrorIsNil) statusInfo, err := filesystem.Status() c.Check(err, jc.ErrorIsNil) c.Check(statusInfo.Status, gc.Equals, status.Attaching) c.Check(statusInfo.Message, gc.Equals, "blah") c.Check(statusInfo.Data, jc.DeepEquals, map[string]interface{}{ "$foo.bar.baz": map[string]interface{}{ "pew.pew": "zap", }, }) c.Check(statusInfo.Since, gc.NotNil) }
func (s *VolumeStatusSuite) checkGetSetStatus(c *gc.C, volumeStatus status.Status) { now := testing.ZeroTime() sInfo := status.StatusInfo{ Status: volumeStatus, Message: "blah", Data: map[string]interface{}{ "$foo.bar.baz": map[string]interface{}{ "pew.pew": "zap", }, }, Since: &now, } err := s.volume.SetStatus(sInfo) c.Check(err, jc.ErrorIsNil) volume, err := s.State.Volume(s.volume.VolumeTag()) c.Assert(err, jc.ErrorIsNil) statusInfo, err := volume.Status() c.Check(err, jc.ErrorIsNil) c.Check(statusInfo.Status, gc.Equals, volumeStatus) c.Check(statusInfo.Message, gc.Equals, "blah") c.Check(statusInfo.Data, jc.DeepEquals, map[string]interface{}{ "$foo.bar.baz": map[string]interface{}{ "pew.pew": "zap", }, }) c.Check(statusInfo.Since, gc.NotNil) }
func (s *MigrationImportSuite) TestModelUsers(c *gc.C) { // To be sure with this test, we create three env users, and remove // the owner. err := s.State.RemoveUserAccess(s.Owner, s.modelTag) c.Assert(err, jc.ErrorIsNil) lastConnection := s.State.NowToTheSecond() bravo := s.newModelUser(c, "bravo@external", false, lastConnection) charlie := s.newModelUser(c, "charlie@external", true, lastConnection) delta := s.newModelUser(c, "delta@external", true, coretesting.ZeroTime()) newModel, newSt := s.importModel(c) // Check the import values of the users. for _, user := range []permission.UserAccess{bravo, charlie, delta} { newUser, err := newSt.UserAccess(user.UserTag, newModel.Tag()) c.Assert(err, jc.ErrorIsNil) s.AssertUserEqual(c, newUser, user) } // Also make sure that there aren't any more. allUsers, err := newModel.Users() c.Assert(err, jc.ErrorIsNil) c.Assert(allUsers, gc.HasLen, 3) }
func (s *StatusUnitAgentSuite) checkGetSetStatus(c *gc.C) { now := testing.ZeroTime() sInfo := status.StatusInfo{ Status: status.Idle, Message: "something", Data: map[string]interface{}{ "$foo": "bar", "baz.qux": "ping", "pong": map[string]interface{}{ "$unset": "txn-revno", }, }, Since: &now, } err := s.agent.SetStatus(sInfo) c.Check(err, jc.ErrorIsNil) unit, err := s.State.Unit(s.unit.Name()) c.Assert(err, jc.ErrorIsNil) agent := unit.Agent() statusInfo, err := agent.Status() c.Check(err, jc.ErrorIsNil) c.Check(statusInfo.Status, gc.Equals, status.Idle) c.Check(statusInfo.Message, gc.Equals, "something") c.Check(statusInfo.Data, jc.DeepEquals, map[string]interface{}{ "$foo": "bar", "baz.qux": "ping", "pong": map[string]interface{}{ "$unset": "txn-revno", }, }) c.Check(statusInfo.Since, gc.NotNil) }
func (s *StatusUnitAgentSuite) TestGetSetErrorStatus(c *gc.C) { now := testing.ZeroTime() sInfo := status.StatusInfo{ Status: status.Error, Message: "test-hook failed", Data: map[string]interface{}{ "foo": "bar", }, Since: &now, } err := s.agent.SetStatus(sInfo) c.Assert(err, jc.ErrorIsNil) // Agent error is reported as unit error. statusInfo, err := s.unit.Status() c.Check(err, jc.ErrorIsNil) c.Check(statusInfo.Status, gc.Equals, status.Error) c.Check(statusInfo.Message, gc.Equals, "test-hook failed") c.Check(statusInfo.Data, gc.DeepEquals, map[string]interface{}{ "foo": "bar", }) // For agents, error is reported as idle. statusInfo, err = s.agent.Status() c.Check(err, jc.ErrorIsNil) c.Check(statusInfo.Status, gc.Equals, status.Idle) c.Check(statusInfo.Message, gc.Equals, "") c.Check(statusInfo.Data, gc.HasLen, 0) }
func (s *internalUserSuite) TestCreateInitialUserOps(c *gc.C) { tag := names.NewUserTag("AdMiN") ops := createInitialUserOps(s.state.ControllerUUID(), tag, "abc", "salt", testing.ZeroTime()) c.Assert(ops, gc.HasLen, 3) op := ops[0] c.Assert(op.Id, gc.Equals, "admin") doc := op.Insert.(*userDoc) c.Assert(doc.DocID, gc.Equals, "admin") c.Assert(doc.Name, gc.Equals, "AdMiN") c.Assert(doc.PasswordSalt, gc.Equals, "salt") // controller user permissions op = ops[1] permdoc := op.Insert.(*permissionDoc) c.Assert(permdoc.Access, gc.Equals, string(permission.SuperuserAccess)) c.Assert(permdoc.ID, gc.Equals, permissionID(controllerKey(s.state.ControllerUUID()), userGlobalKey(strings.ToLower(tag.Id())))) c.Assert(permdoc.SubjectGlobalKey, gc.Equals, userGlobalKey(strings.ToLower(tag.Id()))) c.Assert(permdoc.ObjectGlobalKey, gc.Equals, controllerKey(s.state.ControllerUUID())) // controller user op = ops[2] cudoc := op.Insert.(*userAccessDoc) c.Assert(cudoc.ID, gc.Equals, "admin") c.Assert(cudoc.ObjectUUID, gc.Equals, s.state.ControllerUUID()) c.Assert(cudoc.UserName, gc.Equals, "AdMiN") c.Assert(cudoc.DisplayName, gc.Equals, "AdMiN") c.Assert(cudoc.CreatedBy, gc.Equals, "AdMiN") }
func (s *SkewSuite) TestApparentFutureWrite(c *gc.C) { now := coretesting.ZeroTime() c.Logf("now: %s", now) oneSecondAgo := now.Add(-time.Second) threeSecondsAgo := now.Add(-3 * time.Second) tenSecondsAgo := now.Add(-10 * time.Second) twelveSecondsAgo := now.Add(-12 * time.Second) nineSecondsLater := now.Add(9 * time.Second) // Where T is the current local time: // between T-3 and T-1, we read T+9 from the remote clock. skew := lease.Skew{ LastWrite: nineSecondsLater, Beginning: threeSecondsAgo, End: oneSecondAgo, } // If the remote wrote a long time ago -- say, 20 minutes ago it thought // it was nine seconds after now -- its clock could be arbitrarily far // ahead of ours. But we know that when we started reading, 3 seconds ago, // it might not have seen a time later than 9 seconds in the future; so // right now, three seconds after that, it might not have seen a time later // than twelve seconds in the future. c.Check(skew.Earliest(now), gc.DeepEquals, twelveSecondsAgo) // If the remote wrote at the very last moment -- exactly one second ago, // it thought it was 9 seconds in the future -- it could have a clock a // full 10 seconds ahead of ours. If so, the *latest* time at which it // might still have thought it was before now is ten seconds in the past. c.Check(skew.Latest(now), gc.DeepEquals, tenSecondsAgo) }
func checkMetadata(c *gc.C, fromDb, metadata *imagestorage.Metadata) { c.Assert(fromDb.Created.IsZero(), jc.IsFalse) // We don't want Now() here, we want NonZeroTime().Add(...). Before // that can happen, we need to look at AddImage for its Created // timestamp. c.Assert(fromDb.Created.Before(time.Now()), jc.IsTrue) fromDb.Created = testing.ZeroTime() c.Assert(metadata, gc.DeepEquals, fromDb) }
func (s *SkewSuite) TestZero(c *gc.C) { now := coretesting.ZeroTime() // The zero Skew should act as unskewed. skew := lease.Skew{} c.Check(skew.Earliest(now), gc.Equals, now) c.Check(skew.Latest(now), gc.Equals, now) }
// writeLogToOplog writes out a log record to the a (probably fake) // oplog collection. func (s *LogTailerSuite) writeLogToOplog(doc interface{}) error { return s.oplogColl.Insert(bson.D{ {"ts", bson.MongoTimestamp(coretesting.ZeroTime().Unix() << 32)}, // an approximation which will do {"h", rand.Int63()}, // again, a suitable fake {"op", "i"}, // this will always be an insert {"ns", "logs.logs"}, {"o", doc}, }) }
func (s *VolumeStatusSuite) TestSetStatusPendingUnprovisioned(c *gc.C) { now := testing.ZeroTime() sInfo := status.StatusInfo{ Status: status.Pending, Message: "still", Since: &now, } err := s.volume.SetStatus(sInfo) c.Check(err, jc.ErrorIsNil) }
func (s *MachineStatusSuite) TestSetStatusPendingProvisioned(c *gc.C) { now := testing.ZeroTime() sInfo := status.StatusInfo{ Status: status.Pending, Message: "", Since: &now, } err := s.machine.SetStatus(sInfo) c.Check(err, gc.ErrorMatches, `cannot set status "pending"`) }
func (s *ResourcesMongoSuite) TestResource2DocCharmstoreFull(c *gc.C) { content := "some data\n..." fp, err := charmresource.GenerateFingerprint(strings.NewReader(content)) c.Assert(err, jc.ErrorIsNil) now := coretesting.ZeroTime() applicationID := "a-application" docID := applicationResourceID("spam") res := resource.Resource{ Resource: charmresource.Resource{ Meta: charmresource.Meta{ Name: "spam", Type: charmresource.TypeFile, Path: "spam.tgz", Description: "you need this!", }, Origin: charmresource.OriginStore, Revision: 5, Fingerprint: fp, Size: int64(len(content)), }, ID: "a-application/spam", PendingID: "some-unique-ID", ApplicationID: applicationID, Username: "******", Timestamp: now, } doc := resource2doc(docID, storedResource{ Resource: res, storagePath: "application-a-application/resources/spam", }) c.Check(doc, jc.DeepEquals, &resourceDoc{ DocID: docID, ID: res.ID, PendingID: "some-unique-ID", ApplicationID: applicationID, Name: "spam", Type: "file", Path: "spam.tgz", Description: "you need this!", Origin: "store", Revision: 5, Fingerprint: fp.Bytes(), Size: int64(len(content)), Username: "******", Timestamp: now, StoragePath: "application-a-application/resources/spam", }) }
func (s *ResourcePersistenceSuite) TestStageResourceBadResource(c *gc.C) { res, _ := newPersistenceResource(c, "a-application", "spam") res.Resource.Timestamp = coretesting.ZeroTime() p := NewResourcePersistence(s.base) _, err := p.StageResource(res.Resource, res.storagePath) c.Check(err, jc.Satisfies, errors.IsNotValid) c.Check(err, gc.ErrorMatches, `bad resource.*`) s.stub.CheckNoCalls(c) }
func (s *MachineStatusSuite) TestSetUnknownStatus(c *gc.C) { now := testing.ZeroTime() sInfo := status.StatusInfo{ Status: status.Status("vliegkat"), Message: "orville", Since: &now, } err := s.machine.SetStatus(sInfo) c.Assert(err, gc.ErrorMatches, `cannot set invalid status "vliegkat"`) s.checkInitialStatus(c) }
func (s *MachineStatusSuite) TestSetDownStatus(c *gc.C) { now := testing.ZeroTime() sInfo := status.StatusInfo{ Status: status.Down, Message: "", Since: &now, } err := s.machine.SetStatus(sInfo) c.Check(err, gc.ErrorMatches, `cannot set status "down"`) s.checkInitialStatus(c) }
func (s *MachineStatusSuite) TestSetErrorStatusWithoutInfo(c *gc.C) { now := testing.ZeroTime() sInfo := status.StatusInfo{ Status: status.Error, Message: "", Since: &now, } err := s.machine.SetStatus(sInfo) c.Check(err, gc.ErrorMatches, `cannot set status "error" without info`) s.checkInitialStatus(c) }
func (s *MachineStatusSuite) TestSetStatusPendingUnprovisioned(c *gc.C) { machine, err := s.State.AddMachine("quantal", state.JobHostUnits) c.Assert(err, jc.ErrorIsNil) now := testing.ZeroTime() sInfo := status.StatusInfo{ Status: status.Pending, Message: "", Since: &now, } err = machine.SetStatus(sInfo) c.Check(err, jc.ErrorIsNil) }
func (s *ResourcePersistenceSuite) TestNewResourcePendingResourceOpsNotFound(c *gc.C) { pendingID := "some-unique-ID-001" stored, expected := newPersistenceResource(c, "a-application", "spam") stored.PendingID = pendingID doc := expected // a copy doc.DocID = pendingResourceID(stored.ID, pendingID) doc.PendingID = pendingID s.base.ReturnOne = doc notFound := errors.NewNotFound(nil, "") s.stub.SetErrors(nil, notFound) p := NewResourcePersistence(s.base) // TODO(macgreagoir) We need to keep using time.Now() for now, while we // have NewResolvePendingResourceOps returning LastPolled based on // timeNow(). lp:1558657 lastPolled := time.Now().UTC().Round(time.Second) ops, err := p.NewResolvePendingResourceOps(stored.ID, stored.PendingID) c.Assert(err, jc.ErrorIsNil) s.stub.CheckCallNames(c, "One", "One") s.stub.CheckCall(c, 0, "One", "resources", "resource#a-application/spam#pending-some-unique-ID-001", &doc) csresourceDoc := expected csresourceDoc.DocID = "resource#a-application/spam#charmstore" csresourceDoc.Username = "" csresourceDoc.Timestamp = coretesting.ZeroTime() csresourceDoc.StoragePath = "" csresourceDoc.LastPolled = lastPolled res := ops[2].Insert.(*resourceDoc) res.LastPolled = res.LastPolled.Round(time.Second) c.Check(ops, jc.DeepEquals, []txn.Op{ { C: "resources", Id: doc.DocID, Assert: txn.DocExists, Remove: true, }, { C: "resources", Id: expected.DocID, Assert: txn.DocMissing, Insert: &expected, }, { C: "resources", Id: csresourceDoc.DocID, Assert: txn.DocMissing, Insert: &csresourceDoc, }, }) }