func (s *EnvUserSuite) TestAddEnvironmentUser(c *gc.C) {
now := state.NowToTheSecond()
user := s.Factory.MakeUser(c, &factory.UserParams{Name: "validusername", NoEnvUser: true})
createdBy := s.Factory.MakeUser(c, &factory.UserParams{Name: "createdby"})
envUser, err := s.State.AddEnvironmentUser(state.EnvUserSpec{
User: user.UserTag(), CreatedBy: createdBy.UserTag()})
c.Assert(err, jc.ErrorIsNil)
c.Assert(envUser.ID(), gc.Equals, fmt.Sprintf("%s:validusername@local", s.envTag.Id()))
c.Assert(envUser.EnvironmentTag(), gc.Equals, s.envTag)
c.Assert(envUser.UserName(), gc.Equals, "validusername@local")
c.Assert(envUser.DisplayName(), gc.Equals, user.DisplayName())
c.Assert(envUser.ReadOnly(), jc.IsFalse)
c.Assert(envUser.CreatedBy(), gc.Equals, "createdby@local")
c.Assert(envUser.DateCreated().Equal(now) || envUser.DateCreated().After(now), jc.IsTrue)
when, err := envUser.LastConnection()
c.Assert(err, jc.Satisfies, state.IsNeverConnectedError)
c.Assert(when.IsZero(), jc.IsTrue)
envUser, err = s.State.EnvironmentUser(user.UserTag())
c.Assert(err, jc.ErrorIsNil)
c.Assert(envUser.ID(), gc.Equals, fmt.Sprintf("%s:validusername@local", s.envTag.Id()))
c.Assert(envUser.EnvironmentTag(), gc.Equals, s.envTag)
c.Assert(envUser.UserName(), gc.Equals, "validusername@local")
c.Assert(envUser.DisplayName(), gc.Equals, user.DisplayName())
c.Assert(envUser.ReadOnly(), jc.IsFalse)
c.Assert(envUser.CreatedBy(), gc.Equals, "createdby@local")
c.Assert(envUser.DateCreated().Equal(now) || envUser.DateCreated().After(now), jc.IsTrue)
when, err = envUser.LastConnection()
c.Assert(err, jc.Satisfies, state.IsNeverConnectedError)
c.Assert(when.IsZero(), jc.IsTrue)
}
func (s *MetricSuite) TestAddMetricDeadUnit(c *gc.C) {
assertUnitDead(c, s.unit)
now := state.NowToTheSecond()
m := state.Metric{"pings", "5", now}
_, err := s.unit.AddMetrics(utils.MustNewUUID().String(), now, "", []state.Metric{m})
c.Assert(err, gc.ErrorMatches, `metered/0 not found`)
}
func (s *MetricSuite) TestAddMetric(c *gc.C) {
now := state.NowToTheSecond()
envUUID := s.State.EnvironUUID()
m := state.Metric{"pings", "5", now}
metricBatch, err := s.unit.AddMetrics(utils.MustNewUUID().String(), now, "", []state.Metric{m})
c.Assert(err, jc.ErrorIsNil)
c.Assert(metricBatch.Unit(), gc.Equals, "metered/0")
c.Assert(metricBatch.EnvUUID(), gc.Equals, envUUID)
c.Assert(metricBatch.CharmURL(), gc.Equals, "cs:quantal/metered")
c.Assert(metricBatch.Sent(), jc.IsFalse)
c.Assert(metricBatch.Created(), gc.Equals, now)
c.Assert(metricBatch.Metrics(), gc.HasLen, 1)
metric := metricBatch.Metrics()[0]
c.Assert(metric.Key, gc.Equals, "pings")
c.Assert(metric.Value, gc.Equals, "5")
c.Assert(metric.Time.Equal(now), jc.IsTrue)
saved, err := s.State.MetricBatch(metricBatch.UUID())
c.Assert(err, jc.ErrorIsNil)
c.Assert(saved.Unit(), gc.Equals, "metered/0")
c.Assert(metricBatch.CharmURL(), gc.Equals, "cs:quantal/metered")
c.Assert(saved.Sent(), jc.IsFalse)
c.Assert(saved.Metrics(), gc.HasLen, 1)
metric = saved.Metrics()[0]
c.Assert(metric.Key, gc.Equals, "pings")
c.Assert(metric.Value, gc.Equals, "5")
c.Assert(metric.Time.Equal(now), jc.IsTrue)
}
func (s *EnvUserSuite) TestAddEnvironmentUser(c *gc.C) {
now := state.NowToTheSecond()
user := s.factory.MakeUser(c, &factory.UserParams{Name: "validusername", NoEnvUser: true})
createdBy := s.factory.MakeUser(c, &factory.UserParams{Name: "createdby"})
envUser, err := s.State.AddEnvironmentUser(user.UserTag(), createdBy.UserTag())
c.Assert(err, gc.IsNil)
c.Assert(envUser.ID(), gc.Equals, fmt.Sprintf("%s:validusername@local", s.envTag.Id()))
c.Assert(envUser.EnvironmentTag(), gc.Equals, s.envTag)
c.Assert(envUser.UserName(), gc.Equals, "validusername@local")
c.Assert(envUser.DisplayName(), gc.Equals, user.DisplayName())
c.Assert(envUser.CreatedBy(), gc.Equals, "createdby@local")
c.Assert(envUser.DateCreated().Equal(now) || envUser.DateCreated().After(now), jc.IsTrue)
c.Assert(envUser.LastConnection(), gc.IsNil)
envUser, err = s.State.EnvironmentUser(user.UserTag())
c.Assert(err, gc.IsNil)
c.Assert(envUser.ID(), gc.Equals, fmt.Sprintf("%s:validusername@local", s.envTag.Id()))
c.Assert(envUser.EnvironmentTag(), gc.Equals, s.envTag)
c.Assert(envUser.UserName(), gc.Equals, "validusername@local")
c.Assert(envUser.DisplayName(), gc.Equals, user.DisplayName())
c.Assert(envUser.CreatedBy(), gc.Equals, "createdby@local")
c.Assert(envUser.DateCreated().Equal(now) || envUser.DateCreated().After(now), jc.IsTrue)
c.Assert(envUser.LastConnection(), gc.IsNil)
}
func (s *MetricLocalCharmSuite) TestUnitMetricBatchesReturnsJustLocal(c *gc.C) {
now := state.NowToTheSecond()
m := state.Metric{"pings", "5", now}
_, err := s.State.AddMetrics(
state.BatchParam{
UUID: utils.MustNewUUID().String(),
Created: now,
CharmURL: s.meteredCharm.URL().String(),
Metrics: []state.Metric{m},
Unit: s.unit.UnitTag(),
},
)
c.Assert(err, jc.ErrorIsNil)
csMeteredCharm := s.Factory.MakeCharm(c, &factory.CharmParams{Name: "metered", URL: "cs:quantal/metered"})
service := s.Factory.MakeService(c, &factory.ServiceParams{Name: "csmetered", Charm: csMeteredCharm})
unit := s.Factory.MakeUnit(c, &factory.UnitParams{Service: service, SetCharmURL: true})
_, err = s.State.AddMetrics(
state.BatchParam{
UUID: utils.MustNewUUID().String(),
Created: now,
CharmURL: csMeteredCharm.URL().String(),
Metrics: []state.Metric{m},
Unit: unit.UnitTag(),
},
)
c.Assert(err, jc.ErrorIsNil)
metricBatches, err := s.State.MetricBatchesForUnit("metered/0")
c.Assert(metricBatches, gc.HasLen, 1)
metricBatches, err = s.State.MetricBatchesForUnit("csmetered/0")
c.Assert(metricBatches, gc.HasLen, 0)
}
func (s *MetricSuite) TestAddMetricDuplicateUUID(c *gc.C) {
now := state.NowToTheSecond()
mUUID := utils.MustNewUUID().String()
_, err := s.State.AddMetrics(
state.BatchParam{
UUID: mUUID,
Created: now,
CharmURL: s.meteredCharm.URL().String(),
Metrics: []state.Metric{{"pings", "5", now}},
Unit: s.unit.UnitTag(),
},
)
c.Assert(err, jc.ErrorIsNil)
_, err = s.State.AddMetrics(
state.BatchParam{
UUID: mUUID,
Created: now,
CharmURL: s.meteredCharm.URL().String(),
Metrics: []state.Metric{{"pings", "10", now}},
Unit: s.unit.UnitTag(),
},
)
c.Assert(err, gc.ErrorMatches, "metrics batch .* already exists")
}
func (s *MetricSuite) TestAddMetric(c *gc.C) {
unit := s.assertAddUnit(c)
now := state.NowToTheSecond()
m := state.NewMetric("item", "5", now, []byte("creds"))
metricBatch, err := unit.AddMetrics([]*state.Metric{m})
c.Assert(err, gc.IsNil)
c.Assert(metricBatch.Unit(), gc.Equals, "wordpress/0")
c.Assert(metricBatch.CharmURL(), gc.Equals, "local:quantal/quantal-wordpress-3")
c.Assert(metricBatch.Sent(), gc.Equals, false)
c.Assert(metricBatch.Metrics(), gc.HasLen, 1)
metric := metricBatch.Metrics()[0]
c.Assert(metric.Key(), gc.Equals, "item")
c.Assert(metric.Value(), gc.Equals, "5")
c.Assert(metric.Time().Equal(now), jc.IsTrue)
c.Assert(metric.Credentials(), gc.DeepEquals, []byte("creds"))
saved, err := s.State.MetricBatch(metricBatch.UUID())
c.Assert(err, gc.IsNil)
c.Assert(saved.Unit(), gc.Equals, "wordpress/0")
c.Assert(metricBatch.CharmURL(), gc.Equals, "local:quantal/quantal-wordpress-3")
c.Assert(saved.Sent(), gc.Equals, false)
c.Assert(saved.Metrics(), gc.HasLen, 1)
metric = saved.Metrics()[0]
c.Assert(metric.Key(), gc.Equals, "item")
c.Assert(metric.Value(), gc.Equals, "5")
c.Assert(metric.Time().Equal(now), jc.IsTrue)
c.Assert(metric.Credentials(), gc.DeepEquals, []byte("creds"))
}
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 := 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, time.Time{})
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 *MetricSuite) TestMetricsAcrossEnvironments(c *gc.C) {
now := state.NowToTheSecond().Add(-48 * time.Hour)
m := state.Metric{"pings", "5", now}
m1, err := s.State.AddMetrics(
state.BatchParam{
UUID: utils.MustNewUUID().String(),
Created: now,
CharmURL: s.meteredCharm.URL().String(),
Metrics: []state.Metric{m},
Unit: s.unit.UnitTag(),
},
)
c.Assert(err, jc.ErrorIsNil)
st := s.Factory.MakeEnvironment(c, nil)
defer st.Close()
f := factory.NewFactory(st)
meteredCharm := f.MakeCharm(c, &factory.CharmParams{Name: "metered", URL: "cs:quantal/metered"})
service := f.MakeService(c, &factory.ServiceParams{Charm: meteredCharm})
unit := f.MakeUnit(c, &factory.UnitParams{Service: service, SetCharmURL: true})
m2, err := s.State.AddMetrics(
state.BatchParam{
UUID: utils.MustNewUUID().String(),
Created: now,
CharmURL: s.meteredCharm.URL().String(),
Metrics: []state.Metric{m},
Unit: unit.UnitTag(),
},
)
c.Assert(err, jc.ErrorIsNil)
batches, err := s.State.MetricBatches()
c.Assert(err, jc.ErrorIsNil)
c.Assert(batches, gc.HasLen, 2)
unsent, err := s.State.CountOfUnsentMetrics()
c.Assert(err, jc.ErrorIsNil)
c.Assert(unsent, gc.Equals, 2)
toSend, err := s.State.MetricsToSend(10)
c.Assert(err, jc.ErrorIsNil)
c.Assert(toSend, gc.HasLen, 2)
err = m1.SetSent(time.Now().Add(-25 * time.Hour))
c.Assert(err, jc.ErrorIsNil)
err = m2.SetSent(time.Now().Add(-25 * time.Hour))
c.Assert(err, jc.ErrorIsNil)
sent, err := s.State.CountOfSentMetrics()
c.Assert(err, jc.ErrorIsNil)
c.Assert(sent, gc.Equals, 2)
err = s.State.CleanupOldMetrics()
c.Assert(err, jc.ErrorIsNil)
batches, err = s.State.MetricBatches()
c.Assert(err, jc.ErrorIsNil)
c.Assert(batches, gc.HasLen, 0)
}
func (s *MetricSuite) TestAddMetricDeadUnit(c *gc.C) {
unit := s.assertAddUnit(c)
assertUnitDead(c, unit)
now := state.NowToTheSecond()
m := state.NewMetric("item", "5", now, []byte{})
_, err := unit.AddMetrics([]*state.Metric{m})
c.Assert(err, gc.ErrorMatches, `wordpress/0 not found`)
}
func (s *MetricSuite) TestAddMetricNonExitentUnit(c *gc.C) {
unit := s.assertAddUnit(c)
assertUnitRemoved(c, unit)
now := state.NowToTheSecond()
m := state.Metric{"item", "5", now, []byte{}}
_, err := unit.AddMetrics(now, []state.Metric{m})
c.Assert(err, gc.ErrorMatches, `wordpress/0 not found`)
}
func (s *MetricSuite) TestAddMetricDuplicateUUID(c *gc.C) {
now := state.NowToTheSecond()
mUUID := utils.MustNewUUID().String()
_, err := s.unit.AddMetrics(mUUID, now, "", []state.Metric{{"pings", "5", now}})
c.Assert(err, jc.ErrorIsNil)
_, err = s.unit.AddMetrics(mUUID, now, "", []state.Metric{{"pings", "10", now}})
c.Assert(err, gc.ErrorMatches, "metrics batch .* already exists")
}
func (s *MetricSuite) TestMetricsToSend(c *gc.C) {
now := state.NowToTheSecond()
m := []state.Metric{{Key: "pings", Value: "123", Time: now}}
s.Factory.MakeMetric(c, &factory.MetricParams{Unit: s.unit, Sent: false, Time: &now, Metrics: m})
s.Factory.MakeMetric(c, &factory.MetricParams{Unit: s.unit, Sent: false, Time: &now, Metrics: m})
s.Factory.MakeMetric(c, &factory.MetricParams{Unit: s.unit, Sent: true, Time: &now, Metrics: m})
result, err := s.State.MetricsToSend(5)
c.Assert(err, jc.ErrorIsNil)
c.Assert(result, gc.HasLen, 2)
}
func (s *MetricSuite) TestAddNoMetrics(c *gc.C) {
now := state.NowToTheSecond()
_, err := s.State.AddMetrics(state.BatchParam{
UUID: utils.MustNewUUID().String(),
CharmURL: s.meteredCharm.URL().String(),
Created: now,
Metrics: []state.Metric{},
Unit: s.unit.UnitTag(),
})
c.Assert(err, gc.ErrorMatches, "cannot add a batch of 0 metrics")
}
func (s *MetricSuite) TestMetricCredentials(c *gc.C) {
now := state.NowToTheSecond()
m := state.Metric{"pings", "5", now}
err := s.service.SetMetricCredentials([]byte("hello there"))
c.Assert(err, gc.IsNil)
_, err = s.unit.AddMetrics(utils.MustNewUUID().String(), now, "", []state.Metric{m})
c.Assert(err, jc.ErrorIsNil)
metricBatches, err := s.State.MetricBatches()
c.Assert(err, jc.ErrorIsNil)
c.Assert(metricBatches, gc.HasLen, 1)
c.Assert(metricBatches[0].Credentials(), gc.DeepEquals, []byte("hello there"))
}
func (s *EnvUserSuite) TestUpdateLastConnection(c *gc.C) {
now := state.NowToTheSecond()
createdBy := s.factory.MakeUser(c, &factory.UserParams{Name: "createdby"})
user := s.factory.MakeUser(c, &factory.UserParams{Name: "validusername", Creator: createdBy.Name()})
envUser, err := s.State.EnvironmentUser(user.UserTag())
c.Assert(err, gc.IsNil)
err = envUser.UpdateLastConnection()
c.Assert(err, gc.IsNil)
// It is possible that the update is done over a second boundary, so we need
// to check for after now as well as equal.
c.Assert(envUser.LastConnection().After(now) ||
envUser.LastConnection().Equal(now), jc.IsTrue)
}
func (s *MetricSuite) TestMetricBatches(c *gc.C) {
now := state.NowToTheSecond()
m := state.Metric{"pings", "5", now}
_, err := s.unit.AddMetrics(utils.MustNewUUID().String(), now, "", []state.Metric{m})
c.Assert(err, jc.ErrorIsNil)
metricBatches, err := s.State.MetricBatches()
c.Assert(err, jc.ErrorIsNil)
c.Assert(metricBatches, gc.HasLen, 1)
c.Assert(metricBatches[0].Unit(), gc.Equals, "metered/0")
c.Assert(metricBatches[0].CharmURL(), gc.Equals, "cs:quantal/metered")
c.Assert(metricBatches[0].Sent(), jc.IsFalse)
c.Assert(metricBatches[0].Metrics(), gc.HasLen, 1)
}
func (s *MetricSuite) TestSetMetricSent(c *gc.C) {
now := state.NowToTheSecond()
m := state.Metric{"pings", "5", now}
added, err := s.unit.AddMetrics(utils.MustNewUUID().String(), now, "", []state.Metric{m})
c.Assert(err, jc.ErrorIsNil)
saved, err := s.State.MetricBatch(added.UUID())
c.Assert(err, jc.ErrorIsNil)
err = saved.SetSent()
c.Assert(err, jc.ErrorIsNil)
c.Assert(saved.Sent(), jc.IsTrue)
saved, err = s.State.MetricBatch(added.UUID())
c.Assert(err, jc.ErrorIsNil)
c.Assert(saved.Sent(), jc.IsTrue)
}
func (s *ModelUserSuite) TestUpdateLastConnection(c *gc.C) {
now := state.NowToTheSecond()
createdBy := s.Factory.MakeUser(c, &factory.UserParams{Name: "createdby"})
user := s.Factory.MakeUser(c, &factory.UserParams{Name: "validusername", Creator: createdBy.Tag()})
modelUser, err := s.State.ModelUser(user.UserTag())
c.Assert(err, jc.ErrorIsNil)
err = modelUser.UpdateLastConnection()
c.Assert(err, jc.ErrorIsNil)
when, err := modelUser.LastConnection()
c.Assert(err, jc.ErrorIsNil)
// It is possible that the update is done over a second boundary, so we need
// to check for after now as well as equal.
c.Assert(when.After(now) || when.Equal(now), jc.IsTrue)
}
func (s *MetricSuite) TestSetMetricSent(c *gc.C) {
unit := s.assertAddUnit(c)
now := state.NowToTheSecond()
m := state.NewMetric("item", "5", now, []byte{})
added, err := unit.AddMetrics([]*state.Metric{m})
c.Assert(err, gc.IsNil)
saved, err := s.State.MetricBatch(added.UUID())
c.Assert(err, gc.IsNil)
err = saved.SetSent()
c.Assert(err, gc.IsNil)
c.Assert(saved.Sent(), jc.IsTrue)
saved, err = s.State.MetricBatch(added.UUID())
c.Assert(err, gc.IsNil)
c.Assert(saved.Sent(), jc.IsTrue)
}
func (s *ModelSuite) TestModelDestroy(c *gc.C) {
env, err := s.State.Model()
c.Assert(err, jc.ErrorIsNil)
now := state.NowToTheSecond()
s.PatchValue(&state.NowToTheSecond, func() time.Time {
return now
})
err = env.Destroy()
c.Assert(err, jc.ErrorIsNil)
err = env.Refresh()
c.Assert(err, jc.ErrorIsNil)
c.Assert(env.Life(), gc.Equals, state.Dying)
}
func (s *MetricSuite) TestAddMetricDeadUnit(c *gc.C) {
ensureUnitDead(c, s.unit)
now := state.NowToTheSecond()
m := state.Metric{"pings", "5", now}
_, err := s.State.AddMetrics(
state.BatchParam{
UUID: utils.MustNewUUID().String(),
Created: now,
CharmURL: s.meteredCharm.URL().String(),
Metrics: []state.Metric{m},
Unit: s.unit.UnitTag(),
},
)
c.Assert(err, gc.ErrorMatches, `metered/0 not found`)
}
func (s *MetricSuite) TestAddMetricNonExistentUnit(c *gc.C) {
removeUnit(c, s.unit)
now := state.NowToTheSecond()
m := state.Metric{"pings", "5", now}
unitTag := names.NewUnitTag("test/0")
_, err := s.State.AddMetrics(
state.BatchParam{
UUID: utils.MustNewUUID().String(),
Created: now,
CharmURL: s.meteredCharm.URL().String(),
Metrics: []state.Metric{m},
Unit: unitTag,
},
)
c.Assert(err, gc.ErrorMatches, ".*not found")
}
func (s *EnvironSuite) TestEnvironmentDestroy(c *gc.C) {
env, err := s.State.Environment()
c.Assert(err, jc.ErrorIsNil)
now := state.NowToTheSecond()
s.PatchValue(&state.NowToTheSecond, func() time.Time {
return now
})
err = env.Destroy()
c.Assert(err, jc.ErrorIsNil)
err = env.Refresh()
c.Assert(err, jc.ErrorIsNil)
c.Assert(env.Life(), gc.Equals, state.Dying)
c.Assert(env.TimeOfDying().UTC(), gc.Equals, now.UTC())
c.Assert(env.TimeOfDeath().IsZero(), jc.IsTrue)
}
func (s *MetricLocalCharmSuite) TestUnitMetricBatches(c *gc.C) {
now := state.NowToTheSecond()
m := state.Metric{"pings", "5", now}
m2 := state.Metric{"pings", "10", now}
_, err := s.State.AddMetrics(
state.BatchParam{
UUID: utils.MustNewUUID().String(),
Created: now,
CharmURL: s.meteredCharm.URL().String(),
Metrics: []state.Metric{m},
Unit: s.unit.UnitTag(),
},
)
c.Assert(err, jc.ErrorIsNil)
newUnit, err := s.service.AddUnit()
c.Assert(err, jc.ErrorIsNil)
_, err = s.State.AddMetrics(
state.BatchParam{
UUID: utils.MustNewUUID().String(),
Created: now,
CharmURL: s.meteredCharm.URL().String(),
Metrics: []state.Metric{m2},
Unit: newUnit.UnitTag(),
},
)
c.Assert(err, jc.ErrorIsNil)
metricBatches, err := s.State.MetricBatchesForUnit("metered/0")
c.Assert(err, jc.ErrorIsNil)
c.Assert(metricBatches, gc.HasLen, 1)
c.Assert(metricBatches[0].Unit(), gc.Equals, "metered/0")
c.Assert(metricBatches[0].CharmURL(), gc.Equals, "local:quantal/metered")
c.Assert(metricBatches[0].Sent(), jc.IsFalse)
c.Assert(metricBatches[0].Metrics(), gc.HasLen, 1)
c.Assert(metricBatches[0].Metrics()[0].Value, gc.Equals, "5")
metricBatches, err = s.State.MetricBatchesForUnit("metered/1")
c.Assert(err, jc.ErrorIsNil)
c.Assert(metricBatches, gc.HasLen, 1)
c.Assert(metricBatches[0].Unit(), gc.Equals, "metered/1")
c.Assert(metricBatches[0].CharmURL(), gc.Equals, "local:quantal/metered")
c.Assert(metricBatches[0].Sent(), jc.IsFalse)
c.Assert(metricBatches[0].Metrics(), gc.HasLen, 1)
c.Assert(metricBatches[0].Metrics()[0].Value, gc.Equals, "10")
}
func (s *MigrationExportSuite) TestModelUsers(c *gc.C) {
// Make sure we have some last connection times for the admin user,
// and create a few other users.
lastConnection := state.NowToTheSecond()
owner, err := s.State.UserAccess(s.Owner, s.State.ModelTag())
c.Assert(err, jc.ErrorIsNil)
err = state.UpdateModelUserLastConnection(s.State, owner, lastConnection)
c.Assert(err, jc.ErrorIsNil)
bobTag := names.NewUserTag("bob@external")
bob, err := s.State.AddModelUser(s.State.ModelUUID(), state.UserAccessSpec{
User: bobTag,
CreatedBy: s.Owner,
Access: permission.ReadAccess,
})
c.Assert(err, jc.ErrorIsNil)
err = state.UpdateModelUserLastConnection(s.State, bob, lastConnection)
c.Assert(err, jc.ErrorIsNil)
model, err := s.State.Export()
c.Assert(err, jc.ErrorIsNil)
users := model.Users()
c.Assert(users, gc.HasLen, 2)
exportedBob := users[0]
// admin is "test-admin", and results are sorted
exportedAdmin := users[1]
c.Assert(exportedAdmin.Name(), gc.Equals, s.Owner)
c.Assert(exportedAdmin.DisplayName(), gc.Equals, owner.DisplayName)
c.Assert(exportedAdmin.CreatedBy(), gc.Equals, s.Owner)
c.Assert(exportedAdmin.DateCreated(), gc.Equals, owner.DateCreated)
c.Assert(exportedAdmin.LastConnection(), gc.Equals, lastConnection)
c.Assert(exportedAdmin.Access(), gc.Equals, "admin")
c.Assert(exportedBob.Name(), gc.Equals, bobTag)
c.Assert(exportedBob.DisplayName(), gc.Equals, "")
c.Assert(exportedBob.CreatedBy(), gc.Equals, s.Owner)
c.Assert(exportedBob.DateCreated(), gc.Equals, bob.DateCreated)
c.Assert(exportedBob.LastConnection(), gc.Equals, lastConnection)
c.Assert(exportedBob.Access(), gc.Equals, "read")
}
func (s *ModelUserSuite) TestUpdateLastConnectionTwoModelUsers(c *gc.C) {
now := state.NowToTheSecond()
// Create a user and add them to the inital model.
createdBy := s.Factory.MakeUser(c, &factory.UserParams{Name: "createdby"})
user := s.Factory.MakeUser(c, &factory.UserParams{Name: "validusername", Creator: createdBy.Tag()})
modelUser, err := s.State.UserAccess(user.UserTag(), s.State.ModelTag())
c.Assert(err, jc.ErrorIsNil)
// Create a second model and add the same user to this.
st2 := s.Factory.MakeModel(c, nil)
defer st2.Close()
modelUser2, err := st2.AddModelUser(
st2.ModelUUID(),
state.UserAccessSpec{
User: user.UserTag(),
CreatedBy: createdBy.UserTag(),
Access: permission.ReadAccess,
})
c.Assert(err, jc.ErrorIsNil)
// Now we have two model users with the same username. Ensure we get
// separate last connections.
// Connect modelUser and get last connection.
err = s.State.UpdateLastModelConnection(user.UserTag())
c.Assert(err, jc.ErrorIsNil)
when, err := s.State.LastModelConnection(modelUser.UserTag)
c.Assert(err, jc.ErrorIsNil)
c.Assert(when.After(now) || when.Equal(now), jc.IsTrue)
// Try to get last connection for modelUser2. As they have never connected,
// we expect to get an error.
_, err = st2.LastModelConnection(modelUser2.UserTag)
c.Assert(err, gc.ErrorMatches, `never connected: "validusername@local"`)
// Connect modelUser2 and get last connection.
err = s.State.UpdateLastModelConnection(modelUser2.UserTag)
c.Assert(err, jc.ErrorIsNil)
when, err = s.State.LastModelConnection(modelUser2.UserTag)
c.Assert(err, jc.ErrorIsNil)
c.Assert(when.After(now) || when.Equal(now), jc.IsTrue)
}
func (s *UnitAgentSuite) TestSetAgentStatusSince(c *gc.C) {
agent := s.unit.Agent().(*state.UnitAgent)
now := state.NowToTheSecond()
err := agent.SetStatus(state.StatusIdle, "", nil)
c.Assert(err, jc.ErrorIsNil)
statusInfo, err := agent.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.
err = agent.SetStatus(state.StatusIdle, "", nil)
c.Assert(err, jc.ErrorIsNil)
statusInfo, err = agent.Status()
c.Assert(err, jc.ErrorIsNil)
c.Assert(timeBeforeOrEqual(*firstTime, *statusInfo.Since), jc.IsTrue)
}
func (s *MetricSuite) TestMetricCredentials(c *gc.C) {
now := state.NowToTheSecond()
m := state.Metric{"pings", "5", now}
err := s.service.SetMetricCredentials([]byte("hello there"))
c.Assert(err, gc.IsNil)
_, err = s.State.AddMetrics(
state.BatchParam{
UUID: utils.MustNewUUID().String(),
Created: now,
CharmURL: s.meteredCharm.URL().String(),
Metrics: []state.Metric{m},
Unit: s.unit.UnitTag(),
},
)
c.Assert(err, jc.ErrorIsNil)
metricBatches, err := s.State.MetricBatches()
c.Assert(err, jc.ErrorIsNil)
c.Assert(metricBatches, gc.HasLen, 1)
c.Assert(metricBatches[0].Credentials(), gc.DeepEquals, []byte("hello there"))
}
func (s *ModelUserSuite) TestAddModelUser(c *gc.C) {
now := state.NowToTheSecond()
user := s.Factory.MakeUser(c,
&factory.UserParams{
Name: "validusername",
NoModelUser: true,
})
createdBy := s.Factory.MakeUser(c, &factory.UserParams{Name: "createdby"})
modelUser, err := s.State.AddModelUser(
s.State.ModelUUID(),
state.UserAccessSpec{
User: user.UserTag(),
CreatedBy: createdBy.UserTag(),
Access: permission.WriteAccess,
})
c.Assert(err, jc.ErrorIsNil)
c.Assert(modelUser.UserID, gc.Equals, fmt.Sprintf("%s:validusername@local", s.modelTag.Id()))
c.Assert(modelUser.Object, gc.Equals, s.modelTag)
c.Assert(modelUser.UserName, gc.Equals, "validusername@local")
c.Assert(modelUser.DisplayName, gc.Equals, user.DisplayName())
c.Assert(modelUser.Access, gc.Equals, permission.WriteAccess)
c.Assert(modelUser.CreatedBy.Id(), gc.Equals, "createdby@local")
c.Assert(modelUser.DateCreated.Equal(now) || modelUser.DateCreated.After(now), jc.IsTrue)
when, err := s.State.LastModelConnection(modelUser.UserTag)
c.Assert(err, jc.Satisfies, state.IsNeverConnectedError)
c.Assert(when.IsZero(), jc.IsTrue)
modelUser, err = s.State.UserAccess(user.UserTag(), s.State.ModelTag())
c.Assert(err, jc.ErrorIsNil)
c.Assert(modelUser.UserID, gc.Equals, fmt.Sprintf("%s:validusername@local", s.modelTag.Id()))
c.Assert(modelUser.Object, gc.Equals, s.modelTag)
c.Assert(modelUser.UserName, gc.Equals, "validusername@local")
c.Assert(modelUser.DisplayName, gc.Equals, user.DisplayName())
c.Assert(modelUser.Access, gc.Equals, permission.WriteAccess)
c.Assert(modelUser.CreatedBy.Id(), gc.Equals, "createdby@local")
c.Assert(modelUser.DateCreated.Equal(now) || modelUser.DateCreated.After(now), jc.IsTrue)
when, err = s.State.LastModelConnection(modelUser.UserTag)
c.Assert(err, jc.Satisfies, state.IsNeverConnectedError)
c.Assert(when.IsZero(), jc.IsTrue)
}