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,
},
})
}
