~rogpeppe/juju-core/256-more-status

« back to all changes in this revision

Viewing changes to state/unit_test.go

statecmd: don't use juju.Conn unnecessarily

There's an associated cost when the API uses juju.Conn,
so we want to avoid it when reasonable.
This change moves some operations from juju into
state because they don't require juju.Conn's associated
Environ.

R=fwereade, dimitern
CC=
https://codereview.appspot.com/7945044

Show diffs side-by-side

added added

removed removed

Lines of Context:
183
183
        c.Assert(err, ErrorMatches, `unit "wordpress/0" is dead`)
184
184
}
185
185
 
 
186
func (s *UnitSuite) TestDestroyPrincipalUnits(c *C) {
 
187
        for i := 0; i < 4; i++ {
 
188
                _, err := s.service.AddUnit()
 
189
                c.Assert(err, IsNil)
 
190
        }
 
191
 
 
192
        // Destroy 2 of them; check they become Dying.
 
193
        err := s.State.DestroyUnits("wordpress/0", "wordpress/1")
 
194
        c.Assert(err, IsNil)
 
195
        s.assertUnitLife(c, "wordpress/0", state.Dying)
 
196
        s.assertUnitLife(c, "wordpress/1", state.Dying)
 
197
 
 
198
        // Try to destroy an Alive one and a Dying one; check
 
199
        // it destroys the Alive one and ignores the Dying one.
 
200
        err = s.State.DestroyUnits("wordpress/2", "wordpress/0")
 
201
        c.Assert(err, IsNil)
 
202
        s.assertUnitLife(c, "wordpress/2", state.Dying)
 
203
 
 
204
        // Try to destroy an Alive one along with a nonexistent one; check that
 
205
        // the valid instruction is followed but the invalid one is warned about.
 
206
        err = s.State.DestroyUnits("boojum/123", "wordpress/3")
 
207
        c.Assert(err, ErrorMatches, `some units were not destroyed: unit "boojum/123" does not exist`)
 
208
        s.assertUnitLife(c, "wordpress/3", state.Dying)
 
209
 
 
210
        // Make one Dead, and destroy an Alive one alongside it; check no errors.
 
211
        wp0, err := s.State.Unit("wordpress/0")
 
212
        c.Assert(err, IsNil)
 
213
        err = wp0.EnsureDead()
 
214
        c.Assert(err, IsNil)
 
215
        err = s.State.DestroyUnits("wordpress/0", "wordpress/4")
 
216
        c.Assert(err, IsNil)
 
217
        s.assertUnitLife(c, "wordpress/0", state.Dead)
 
218
        s.assertUnitLife(c, "wordpress/4", state.Dying)
 
219
}
 
220
 
 
221
func (s *UnitSuite) TestDestroySubordinateUnits(c *C) {
 
222
        lgsch := s.AddTestingCharm(c, "logging")
 
223
        _, err := s.State.AddService("logging", lgsch)
 
224
        c.Assert(err, IsNil)
 
225
        eps, err := s.State.InferEndpoints([]string{"logging", "wordpress"})
 
226
        c.Assert(err, IsNil)
 
227
        rel, err := s.State.AddRelation(eps...)
 
228
        c.Assert(err, IsNil)
 
229
        ru, err := rel.Unit(s.unit)
 
230
        c.Assert(err, IsNil)
 
231
        err = ru.EnterScope(nil)
 
232
        c.Assert(err, IsNil)
 
233
 
 
234
        // Try to destroy the subordinate alone; check it fails.
 
235
        err = s.State.DestroyUnits("logging/0")
 
236
        c.Assert(err, ErrorMatches, `no units were destroyed: unit "logging/0" is a subordinate`)
 
237
        s.assertUnitLife(c, "logging/0", state.Alive)
 
238
 
 
239
        // Try to destroy the principal and the subordinate together; check it warns
 
240
        // about the subordinate, but destroys the one it can. (The principal unit
 
241
        // agent will be resposible for destroying the subordinate.)
 
242
        err = s.State.DestroyUnits("wordpress/0", "logging/0")
 
243
        c.Assert(err, ErrorMatches, `some units were not destroyed: unit "logging/0" is a subordinate`)
 
244
        s.assertUnitLife(c, "wordpress/0", state.Dying)
 
245
        s.assertUnitLife(c, "logging/0", state.Alive)
 
246
}
 
247
 
 
248
func (s *ConnSuite) assertUnitLife(c *C, name string, life state.Life) {
 
249
        unit, err := s.State.Unit(name)
 
250
        c.Assert(err, IsNil)
 
251
        c.Assert(unit.Refresh(), IsNil)
 
252
        c.Assert(unit.Life(), Equals, life)
 
253
}
 
254
 
186
255
func (s *UnitSuite) TestEntityName(c *C) {
187
256
        c.Assert(s.unit.EntityName(), Equals, "unit-wordpress-0")
188
257
}