← Back to branch summary

~rogpeppe/juju-core/themue-058-debug-log-api

« back to all changes in this revision

Viewing changes to state/state_test.go

  • Committer: Frank Mueller
  • Date: 2014-01-07 13:59:00 UTC
  • mfrom: (2152.1.32 juju-core)
  • Revision ID: frank.mueller@canonical.com-20140107135900-t3akd2tp3s5fsujf
merged trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
state/state_test.go
110
110
 
111
111
func (s *StateSuite) TestPing(c *gc.C) {
112
112
        c.Assert(s.State.Ping(), gc.IsNil)
113
 
        testing.MgoRestart()
 
113
        testing.MgoServer.Restart()
114
114
        c.Assert(s.State.Ping(), gc.NotNil)
115
115
}
116
116
 
320
320
        c.Assert(err, gc.IsNil)
321
321
        oneJob := []state.MachineJob{state.JobHostUnits}
322
322
        extraCons := constraints.MustParse("cpu-cores=4")
323
 
        params := state.AddMachineParams{
 
323
        m, err := s.State.AddOneMachine(state.MachineTemplate{
324
324
                Series:      "quantal",
325
325
                Constraints: extraCons,
326
326
                Jobs:        oneJob,
327
 
        }
328
 
        m, err := s.State.AddMachineWithConstraints(&params)
 
327
        })
329
328
        c.Assert(err, gc.IsNil)
330
329
        c.Assert(m.Id(), gc.Equals, "0")
331
330
        c.Assert(m.Series(), gc.Equals, "quantal")
345
344
func (s *StateSuite) TestAddContainerToNewMachine(c *gc.C) {
346
345
        oneJob := []state.MachineJob{state.JobHostUnits}
347
346
 
348
 
        params := state.AddMachineParams{
349
 
                ContainerType: instance.LXC,
350
 
                Series:        "quantal",
351
 
                Jobs:          oneJob,
352
 
        }
353
 
        m, err := s.State.AddMachineWithConstraints(&params)
 
347
        template := state.MachineTemplate{
 
348
                Series: "quantal",
 
349
                Jobs:   oneJob,
 
350
        }
 
351
        parentTemplate := state.MachineTemplate{
 
352
                Series: "raring",
 
353
                Jobs:   oneJob,
 
354
        }
 
355
        m, err := s.State.AddMachineInsideNewMachine(template, parentTemplate, instance.LXC)
354
356
        c.Assert(err, gc.IsNil)
355
357
        c.Assert(m.Id(), gc.Equals, "0/lxc/0")
356
358
        c.Assert(m.Series(), gc.Equals, "quantal")
363
365
        m, err = s.State.Machine("0")
364
366
        c.Assert(err, gc.IsNil)
365
367
        s.assertMachineContainers(c, m, []string{"0/lxc/0"})
 
368
        c.Assert(m.Series(), gc.Equals, "raring")
 
369
 
366
370
        m, err = s.State.Machine("0/lxc/0")
367
371
        c.Assert(err, gc.IsNil)
368
372
        s.assertMachineContainers(c, m, nil)
 
373
        c.Assert(m.Jobs(), gc.DeepEquals, oneJob)
369
374
}
370
375
 
371
376
func (s *StateSuite) TestAddContainerToExistingMachine(c *gc.C) {
376
381
        c.Assert(err, gc.IsNil)
377
382
 
378
383
        // Add first container.
379
 
        params := state.AddMachineParams{
380
 
                ParentId:      "1",
381
 
                ContainerType: instance.LXC,
382
 
                Series:        "quantal",
383
 
                Jobs:          []state.MachineJob{state.JobHostUnits},
384
 
        }
385
 
        m, err := s.State.AddMachineWithConstraints(&params)
 
384
        m, err := s.State.AddMachineInsideMachine(state.MachineTemplate{
 
385
                Series: "quantal",
 
386
                Jobs:   []state.MachineJob{state.JobHostUnits},
 
387
        }, "1", instance.LXC)
386
388
        c.Assert(err, gc.IsNil)
387
389
        c.Assert(m.Id(), gc.Equals, "1/lxc/0")
388
390
        c.Assert(m.Series(), gc.Equals, "quantal")
400
402
        s.assertMachineContainers(c, m, nil)
401
403
 
402
404
        // Add second container.
403
 
        m, err = s.State.AddMachineWithConstraints(&params)
 
405
        m, err = s.State.AddMachineInsideMachine(state.MachineTemplate{
 
406
                Series: "quantal",
 
407
                Jobs:   []state.MachineJob{state.JobHostUnits},
 
408
        }, "1", instance.LXC)
404
409
        c.Assert(err, gc.IsNil)
405
410
        c.Assert(m.Id(), gc.Equals, "1/lxc/1")
406
411
        c.Assert(m.Series(), gc.Equals, "quantal")
416
421
        err = host.SetSupportedContainers([]instance.ContainerType{instance.KVM})
417
422
        c.Assert(err, gc.IsNil)
418
423
 
419
 
        params := state.AddMachineParams{
420
 
                ParentId:      "0",
421
 
                ContainerType: instance.KVM,
422
 
                Series:        "quantal",
423
 
                Jobs:          []state.MachineJob{state.JobHostUnits},
424
 
        }
425
 
        m, err := s.State.AddMachineWithConstraints(&params)
 
424
        m, err := s.State.AddMachineInsideMachine(state.MachineTemplate{
 
425
                Series: "quantal",
 
426
                Jobs:   []state.MachineJob{state.JobHostUnits},
 
427
        }, "0", instance.KVM)
426
428
        c.Assert(err, gc.IsNil)
427
429
        c.Assert(m.Id(), gc.Equals, "0/kvm/0")
428
430
        s.assertMachineContainers(c, host, []string{"0/kvm/0"})
435
437
        err = host.SetSupportedContainers([]instance.ContainerType{instance.KVM})
436
438
        c.Assert(err, gc.IsNil)
437
439
 
438
 
        params := state.AddMachineParams{
439
 
                ParentId:      "0",
440
 
                ContainerType: instance.LXC,
441
 
                Series:        "quantal",
442
 
                Jobs:          []state.MachineJob{state.JobHostUnits},
443
 
        }
444
 
        _, err = s.State.AddMachineWithConstraints(&params)
445
 
        c.Assert(err, gc.ErrorMatches, "cannot add a new container: machine 0 cannot host lxc containers")
 
440
        _, err = s.State.AddMachineInsideMachine(state.MachineTemplate{
 
441
                Series: "quantal",
 
442
                Jobs:   []state.MachineJob{state.JobHostUnits},
 
443
        }, "0", instance.LXC)
 
444
        c.Assert(err, gc.ErrorMatches, "cannot add a new machine: machine 0 cannot host lxc containers")
446
445
        s.assertMachineContainers(c, host, nil)
447
446
}
448
447
 
453
452
        err = host.SupportsNoContainers()
454
453
        c.Assert(err, gc.IsNil)
455
454
 
456
 
        params := state.AddMachineParams{
457
 
                ParentId:      "0",
458
 
                ContainerType: instance.LXC,
459
 
                Series:        "quantal",
460
 
                Jobs:          []state.MachineJob{state.JobHostUnits},
461
 
        }
462
 
        _, err = s.State.AddMachineWithConstraints(&params)
463
 
        c.Assert(err, gc.ErrorMatches, "cannot add a new container: machine 0 cannot host lxc containers")
 
455
        _, err = s.State.AddMachineInsideMachine(state.MachineTemplate{
 
456
                Series: "quantal",
 
457
                Jobs:   []state.MachineJob{state.JobHostUnits},
 
458
        }, "0", instance.LXC)
 
459
        c.Assert(err, gc.ErrorMatches, "cannot add a new machine: machine 0 cannot host lxc containers")
464
460
        s.assertMachineContainers(c, host, nil)
465
461
}
466
462
 
467
 
func (s *StateSuite) TestAddContainerWithConstraints(c *gc.C) {
468
 
        oneJob := []state.MachineJob{state.JobHostUnits}
469
 
        cons := constraints.MustParse("mem=4G")
470
 
 
471
 
        params := state.AddMachineParams{
472
 
                ParentId:      "",
473
 
                ContainerType: instance.LXC,
474
 
                Series:        "quantal",
475
 
                Constraints:   cons,
476
 
                Jobs:          oneJob,
477
 
        }
478
 
        params.InstanceId = "id"
479
 
        m, err := s.State.AddMachineWithConstraints(&params)
480
 
        c.Assert(err, gc.ErrorMatches, "cannot specify an instance id when adding a new machine")
481
 
        params.InstanceId = ""
482
 
        params.Nonce = "nonce"
483
 
        m, err = s.State.AddMachineWithConstraints(&params)
484
 
        c.Assert(err, gc.ErrorMatches, "cannot specify a nonce when adding a new machine")
485
 
        params.Nonce = ""
486
 
        m, err = s.State.AddMachineWithConstraints(&params)
487
 
        c.Assert(err, gc.IsNil)
488
 
        c.Assert(m.Id(), gc.Equals, "0/lxc/0")
489
 
        c.Assert(m.Series(), gc.Equals, "quantal")
490
 
        c.Assert(m.ContainerType(), gc.Equals, instance.LXC)
491
 
        c.Assert(m.Jobs(), gc.DeepEquals, oneJob)
492
 
        mcons, err := m.Constraints()
493
 
        c.Assert(err, gc.IsNil)
494
 
        c.Assert(cons, gc.DeepEquals, mcons)
 
463
func (s *StateSuite) TestInvalidAddMachineParams(c *gc.C) {
 
464
        instIdTemplate := state.MachineTemplate{
 
465
                Series:     "quantal",
 
466
                Jobs:       []state.MachineJob{state.JobHostUnits},
 
467
                InstanceId: "i-foo",
 
468
        }
 
469
        normalTemplate := state.MachineTemplate{
 
470
                Series: "quantal",
 
471
                Jobs:   []state.MachineJob{state.JobHostUnits},
 
472
        }
 
473
        _, err := s.State.AddMachineInsideMachine(instIdTemplate, "0", instance.LXC)
 
474
        c.Check(err, gc.ErrorMatches, "cannot add a new machine: cannot specify instance id for a new container")
 
475
 
 
476
        _, err = s.State.AddMachineInsideNewMachine(instIdTemplate, normalTemplate, instance.LXC)
 
477
        c.Check(err, gc.ErrorMatches, "cannot add a new machine: cannot specify instance id for a new container")
 
478
 
 
479
        _, err = s.State.AddMachineInsideNewMachine(normalTemplate, instIdTemplate, instance.LXC)
 
480
        c.Check(err, gc.ErrorMatches, "cannot add a new machine: cannot specify instance id for a new container")
 
481
 
 
482
        _, err = s.State.AddOneMachine(instIdTemplate)
 
483
        c.Check(err, gc.ErrorMatches, "cannot add a new machine: cannot add a machine with an instance id and no nonce")
 
484
 
 
485
        _, err = s.State.AddOneMachine(state.MachineTemplate{
 
486
                Series:     "quantal",
 
487
                Jobs:       []state.MachineJob{state.JobHostUnits, state.JobHostUnits},
 
488
                InstanceId: "i-foo",
 
489
        })
 
490
        c.Check(err, gc.ErrorMatches, fmt.Sprintf("cannot add a new machine: duplicate job: %s", state.JobHostUnits))
 
491
 
 
492
        noSeriesTemplate := state.MachineTemplate{
 
493
                Jobs: []state.MachineJob{state.JobHostUnits, state.JobHostUnits},
 
494
        }
 
495
        _, err = s.State.AddOneMachine(noSeriesTemplate)
 
496
        c.Check(err, gc.ErrorMatches, "cannot add a new machine: no series specified")
 
497
 
 
498
        _, err = s.State.AddMachineInsideNewMachine(noSeriesTemplate, normalTemplate, instance.LXC)
 
499
        c.Check(err, gc.ErrorMatches, "cannot add a new machine: no series specified")
 
500
 
 
501
        _, err = s.State.AddMachineInsideNewMachine(normalTemplate, noSeriesTemplate, instance.LXC)
 
502
        c.Check(err, gc.ErrorMatches, "cannot add a new machine: no series specified")
 
503
 
 
504
        _, err = s.State.AddMachineInsideMachine(noSeriesTemplate, "0", instance.LXC)
 
505
        c.Check(err, gc.ErrorMatches, "cannot add a new machine: no series specified")
495
506
}
496
507
 
497
508
func (s *StateSuite) TestAddContainerErrors(c *gc.C) {
498
 
        oneJob := []state.MachineJob{state.JobHostUnits}
499
 
 
500
 
        params := state.AddMachineParams{
501
 
                ParentId:      "10",
502
 
                ContainerType: instance.LXC,
503
 
                Series:        "quantal",
504
 
                Jobs:          oneJob,
 
509
        template := state.MachineTemplate{
 
510
                Series: "quantal",
 
511
                Jobs:   []state.MachineJob{state.JobHostUnits},
505
512
        }
506
 
        _, err := s.State.AddMachineWithConstraints(&params)
507
 
        c.Assert(err, gc.ErrorMatches, "cannot add a new container: machine 10 not found")
508
 
        params.ContainerType = ""
509
 
        _, err = s.State.AddMachineWithConstraints(&params)
510
 
        c.Assert(err, gc.ErrorMatches, "cannot add a new container: no container type specified")
 
513
        _, err := s.State.AddMachineInsideMachine(template, "10", instance.LXC)
 
514
        c.Assert(err, gc.ErrorMatches, "cannot add a new machine: machine 10 not found")
 
515
        _, err = s.State.AddMachineInsideMachine(template, "10", "")
 
516
        c.Assert(err, gc.ErrorMatches, "cannot add a new machine: no container type specified")
511
517
}
512
518
 
513
519
func (s *StateSuite) TestInjectMachineErrors(c *gc.C) {
514
 
        injectMachine := func(series, instanceId, nonce string, jobs ...state.MachineJob) error {
515
 
                params := &state.AddMachineParams{
516
 
                        InstanceId: instance.Id(instanceId),
 
520
        injectMachine := func(series string, instanceId instance.Id, nonce string, jobs ...state.MachineJob) error {
 
521
                _, err := s.State.AddOneMachine(state.MachineTemplate{
517
522
                        Series:     series,
 
523
                        Jobs:       jobs,
 
524
                        InstanceId: instanceId,
518
525
                        Nonce:      nonce,
519
 
                        Jobs:       jobs,
520
 
                }
521
 
                _, err := s.State.InjectMachine(params)
 
526
                })
522
527
                return err
523
528
        }
524
529
        err := injectMachine("", "i-minvalid", state.BootstrapNonce, state.JobHostUnits)
525
530
        c.Assert(err, gc.ErrorMatches, "cannot add a new machine: no series specified")
526
531
        err = injectMachine("quantal", "", state.BootstrapNonce, state.JobHostUnits)
527
 
        c.Assert(err, gc.ErrorMatches, "cannot inject a machine without an instance id")
 
532
        c.Assert(err, gc.ErrorMatches, "cannot add a new machine: cannot specify a nonce without an instance id")
528
533
        err = injectMachine("quantal", "i-minvalid", "", state.JobHostUnits)
529
 
        c.Assert(err, gc.ErrorMatches, "cannot inject a machine without a nonce")
 
534
        c.Assert(err, gc.ErrorMatches, "cannot add a new machine: cannot add a machine with an instance id and no nonce")
530
535
        err = injectMachine("quantal", state.BootstrapNonce, "i-mlazy")
531
536
        c.Assert(err, gc.ErrorMatches, "cannot add a new machine: no jobs specified")
532
537
}
537
542
        mem := uint64(1024)
538
543
        disk := uint64(1024)
539
544
        tags := []string{"foo", "bar"}
540
 
        params := &state.AddMachineParams{
 
545
        template := state.MachineTemplate{
541
546
                Series:      "quantal",
 
547
                Jobs:        []state.MachineJob{state.JobHostUnits, state.JobManageEnviron},
542
548
                Constraints: cons,
543
 
                InstanceId:  instance.Id("i-mindustrious"),
 
549
                InstanceId:  "i-mindustrious",
544
550
                Nonce:       state.BootstrapNonce,
545
551
                HardwareCharacteristics: instance.HardwareCharacteristics{
546
552
                        Arch:     &arch,
548
554
                        RootDisk: &disk,
549
555
                        Tags:     &tags,
550
556
                },
551
 
                Jobs: []state.MachineJob{state.JobHostUnits, state.JobManageEnviron},
552
557
        }
553
 
        m, err := s.State.InjectMachine(params)
 
558
        m, err := s.State.AddOneMachine(template)
554
559
        c.Assert(err, gc.IsNil)
555
 
        c.Assert(m.Jobs(), gc.DeepEquals, params.Jobs)
 
560
        c.Assert(m.Jobs(), gc.DeepEquals, template.Jobs)
556
561
        instanceId, err := m.InstanceId()
557
562
        c.Assert(err, gc.IsNil)
558
 
        c.Assert(instanceId, gc.Equals, params.InstanceId)
 
563
        c.Assert(instanceId, gc.Equals, template.InstanceId)
559
564
        mcons, err := m.Constraints()
560
565
        c.Assert(err, gc.IsNil)
561
566
        c.Assert(cons, gc.DeepEquals, mcons)
562
567
        characteristics, err := m.HardwareCharacteristics()
563
568
        c.Assert(err, gc.IsNil)
564
 
        c.Assert(*characteristics, gc.DeepEquals, params.HardwareCharacteristics)
 
569
        c.Assert(*characteristics, gc.DeepEquals, template.HardwareCharacteristics)
565
570
 
566
571
        // Make sure the bootstrap nonce value is set.
567
 
        c.Assert(m.CheckProvisioned(params.Nonce), gc.Equals, true)
 
572
        c.Assert(m.CheckProvisioned(template.Nonce), gc.Equals, true)
568
573
}
569
574
 
570
575
func (s *StateSuite) TestAddContainerToInjectedMachine(c *gc.C) {
571
576
        oneJob := []state.MachineJob{state.JobHostUnits}
572
 
        params := state.AddMachineParams{
 
577
        template := state.MachineTemplate{
573
578
                Series:     "quantal",
574
 
                InstanceId: instance.Id("i-mindustrious"),
 
579
                InstanceId: "i-mindustrious",
575
580
                Nonce:      state.BootstrapNonce,
576
581
                Jobs:       []state.MachineJob{state.JobHostUnits, state.JobManageEnviron},
577
582
        }
578
 
        m0, err := s.State.InjectMachine(&params)
 
583
        m0, err := s.State.AddOneMachine(template)
579
584
        c.Assert(err, gc.IsNil)
580
585
 
581
586
        // Add first container.
582
 
        params = state.AddMachineParams{
583
 
                ParentId:      "0",
584
 
                ContainerType: instance.LXC,
585
 
                Series:        "quantal",
586
 
                Jobs:          []state.MachineJob{state.JobHostUnits},
 
587
        template = state.MachineTemplate{
 
588
                Series: "quantal",
 
589
                Jobs:   []state.MachineJob{state.JobHostUnits},
587
590
        }
588
 
        m, err := s.State.AddMachineWithConstraints(&params)
 
591
        m, err := s.State.AddMachineInsideMachine(template, "0", instance.LXC)
589
592
        c.Assert(err, gc.IsNil)
590
593
        c.Assert(m.Id(), gc.Equals, "0/lxc/0")
591
594
        c.Assert(m.Series(), gc.Equals, "quantal")
597
600
        s.assertMachineContainers(c, m0, []string{"0/lxc/0"})
598
601
 
599
602
        // Add second container.
600
 
        m, err = s.State.AddMachineWithConstraints(&params)
 
603
        m, err = s.State.AddMachineInsideMachine(template, "0", instance.LXC)
601
604
        c.Assert(err, gc.IsNil)
602
605
        c.Assert(m.Id(), gc.Equals, "0/lxc/1")
603
606
        c.Assert(m.Series(), gc.Equals, "quantal")
1172
1175
        wc.AssertNoChange()
1173
1176
 
1174
1177
        // Add a machine: reported.
1175
 
        params := state.AddMachineParams{
 
1178
        template := state.MachineTemplate{
1176
1179
                Series: "quantal",
1177
1180
                Jobs:   []state.MachineJob{state.JobHostUnits},
1178
1181
        }
1179
 
        machine, err := s.State.AddMachineWithConstraints(&params)
 
1182
        machines, err := s.State.AddMachines(template)
1180
1183
        c.Assert(err, gc.IsNil)
 
1184
        c.Assert(machines, gc.HasLen, 1)
 
1185
        machine := machines[0]
1181
1186
        wc.AssertChange("0")
1182
1187
        wc.AssertNoChange()
1183
1188
 
1184
1189
        // Add a container: not reported.
1185
 
        params.ParentId = machine.Id()
1186
 
        params.ContainerType = instance.LXC
1187
 
        m, err := s.State.AddMachineWithConstraints(&params)
 
1190
        m, err := s.State.AddMachineInsideMachine(template, machine.Id(), instance.LXC)
1188
1191
        c.Assert(err, gc.IsNil)
1189
1192
        wc.AssertNoChange()
1190
1193
 
1206
1209
 
1207
1210
func (s *StateSuite) TestWatchContainerLifecycle(c *gc.C) {
1208
1211
        // Add a host machine.
1209
 
        params := state.AddMachineParams{
 
1212
        template := state.MachineTemplate{
1210
1213
                Series: "quantal",
1211
1214
                Jobs:   []state.MachineJob{state.JobHostUnits},
1212
1215
        }
1213
 
        machine, err := s.State.AddMachineWithConstraints(&params)
 
1216
        machine, err := s.State.AddOneMachine(template)
1214
1217
        c.Assert(err, gc.IsNil)
1215
1218
 
1216
 
        otherMachine, err := s.State.AddMachineWithConstraints(&params)
 
1219
        otherMachine, err := s.State.AddOneMachine(template)
1217
1220
        c.Assert(err, gc.IsNil)
1218
1221
 
1219
1222
        // Initial event is empty when no containers.
1231
1234
        wcAll.AssertNoChange()
1232
1235
 
1233
1236
        // Add a container of the required type: reported.
1234
 
        params.ParentId = machine.Id()
1235
 
        params.ContainerType = instance.LXC
1236
 
        m, err := s.State.AddMachineWithConstraints(&params)
 
1237
        m, err := s.State.AddMachineInsideMachine(template, machine.Id(), instance.LXC)
1237
1238
        c.Assert(err, gc.IsNil)
1238
1239
        wc.AssertChange("0/lxc/0")
1239
1240
        wc.AssertNoChange()
1241
1242
        wcAll.AssertNoChange()
1242
1243
 
1243
1244
        // Add a container of a different type: not reported.
1244
 
        params.ContainerType = instance.KVM
1245
 
        m1, err := s.State.AddMachineWithConstraints(&params)
 
1245
        m1, err := s.State.AddMachineInsideMachine(template, machine.Id(), instance.KVM)
1246
1246
        c.Assert(err, gc.IsNil)
1247
1247
        wc.AssertNoChange()
1248
1248
        // But reported by the all watcher.
1250
1250
        wcAll.AssertNoChange()
1251
1251
 
1252
1252
        // Add a nested container of the right type: not reported.
1253
 
        params.ParentId = m.Id()
1254
 
        params.ContainerType = instance.LXC
 
1253
        mchild, err := s.State.AddMachineInsideMachine(template, m.Id(), instance.LXC)
1255
1254
        c.Assert(err, gc.IsNil)
1256
1255
        wc.AssertNoChange()
1257
1256
        wcAll.AssertNoChange()
1258
1257
 
1259
1258
        // Add a container of a different machine: not reported.
1260
 
        params.ParentId = otherMachine.Id()
1261
 
        params.ContainerType = instance.LXC
1262
 
        m2, err := s.State.AddMachineWithConstraints(&params)
 
1259
        m2, err := s.State.AddMachineInsideMachine(template, otherMachine.Id(), instance.LXC)
1263
1260
        c.Assert(err, gc.IsNil)
1264
1261
        wc.AssertNoChange()
1265
1262
        statetesting.AssertStop(c, w)
1277
1274
        wcAll.AssertChange("0/kvm/0", "0/lxc/0")
1278
1275
        wcAll.AssertNoChange()
1279
1276
 
 
1277
        // Make the container Dying: cannot because of nested container.
 
1278
        err = m.Destroy()
 
1279
        c.Assert(err, gc.ErrorMatches, `machine .* is hosting containers ".*"`)
 
1280
 
 
1281
        err = mchild.EnsureDead()
 
1282
        c.Assert(err, gc.IsNil)
 
1283
        err = mchild.Remove()
 
1284
        c.Assert(err, gc.IsNil)
 
1285
 
1280
1286
        // Make the container Dying: reported.
1281
1287
        err = m.Destroy()
1282
1288
        c.Assert(err, gc.IsNil)
1503
1509
        m1, err := s.State.AddMachine("quantal", state.JobHostUnits)
1504
1510
        c.Assert(err, gc.IsNil)
1505
1511
        m2, err := s.State.Machine(m1.Id())
1506
 
        c.Assert(m1, gc.DeepEquals, m2)
 
1512
        c.Assert(m1, jc.DeepEquals, m2)
1507
1513
 
1508
1514
        charm1 := s.AddTestingCharm(c, "wordpress")
1509
1515
        charm2, err := s.State.Charm(charm1.URL())
1510
1516
        c.Assert(err, gc.IsNil)
1511
 
        c.Assert(charm1, gc.DeepEquals, charm2)
 
1517
        c.Assert(charm1, jc.DeepEquals, charm2)
1512
1518
 
1513
1519
        wordpress1 := s.AddTestingService(c, "wordpress", charm1)
1514
1520
        wordpress2, err := s.State.Service("wordpress")
1515
1521
        c.Assert(err, gc.IsNil)
1516
 
        c.Assert(wordpress1, gc.DeepEquals, wordpress2)
 
1522
        c.Assert(wordpress1, jc.DeepEquals, wordpress2)
1517
1523
 
1518
1524
        unit1, err := wordpress1.AddUnit()
1519
1525
        c.Assert(err, gc.IsNil)
1520
1526
        unit2, err := s.State.Unit("wordpress/0")
1521
1527
        c.Assert(err, gc.IsNil)
1522
 
        c.Assert(unit1, gc.DeepEquals, unit2)
 
1528
        c.Assert(unit1, jc.DeepEquals, unit2)
1523
1529
 
1524
1530
        s.AddTestingService(c, "mysql", s.AddTestingCharm(c, "mysql"))
1525
1531
        c.Assert(err, gc.IsNil)
1528
1534
        relation1, err := s.State.AddRelation(eps...)
1529
1535
        c.Assert(err, gc.IsNil)
1530
1536
        relation2, err := s.State.EndpointsRelation(eps...)
1531
 
        c.Assert(relation1, gc.DeepEquals, relation2)
 
1537
        c.Assert(relation1, jc.DeepEquals, relation2)
1532
1538
        relation3, err := s.State.Relation(relation1.Id())
1533
 
        c.Assert(relation1, gc.DeepEquals, relation3)
 
1539
        c.Assert(relation1, jc.DeepEquals, relation3)
1534
1540
}
1535
1541
 
1536
1542
func tryOpenState(info *state.Info) error {