← Back to branch summary

~juju-qa/ubuntu/xenial/juju/2.0-rc2

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/worker/provisioner/provisioner_test.go

  • Committer: Nicholas Skaggs
  • Date: 2016-09-30 14:39:30 UTC
  • mfrom: (1.8.1)
  • Revision ID: nicholas.skaggs@canonical.com-20160930143930-vwwhrefh6ftckccy
import upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/juju/worker/provisioner/provisioner_test.go
107
107
 
108
108
func (s *CommonProvisionerSuite) SetUpSuite(c *gc.C) {
109
109
        s.JujuConnSuite.SetUpSuite(c)
110
 
        s.defaultConstraints = constraints.MustParse("arch=amd64 mem=4G cpu-cores=1 root-disk=8G")
 
110
        s.defaultConstraints = constraints.MustParse("arch=amd64 mem=4G cores=1 root-disk=8G")
111
111
}
112
112
 
113
113
func (s *CommonProvisionerSuite) SetUpTest(c *gc.C) {
117
117
        imagetesting.PatchOfficialDataSources(&s.CleanupSuite, "")
118
118
        // We want an image to start test instances
119
119
        err := s.State.CloudImageMetadataStorage.SaveMetadata([]cloudimagemetadata.Metadata{{
120
 
                cloudimagemetadata.MetadataAttributes{
 
120
                MetadataAttributes: cloudimagemetadata.MetadataAttributes{
121
121
                        Region:          "region",
122
122
                        Series:          "trusty",
123
123
                        Arch:            "amd64",
126
126
                        Source:          "test",
127
127
                        Stream:          "released",
128
128
                },
129
 
                10,
130
 
                "-999",
 
129
                Priority: 10,
 
130
                ImageId:  "-999",
131
131
        }})
132
132
        c.Assert(err, jc.ErrorIsNil)
133
133
 
453
453
        // Create a machine with non-standard constraints.
454
454
        m, err := s.addMachine()
455
455
        c.Assert(err, jc.ErrorIsNil)
456
 
        cons := constraints.MustParse("mem=8G arch=amd64 cpu-cores=2 root-disk=10G")
 
456
        cons := constraints.MustParse("mem=8G arch=amd64 cores=2 root-disk=10G")
457
457
        err = m.SetConstraints(cons)
458
458
        c.Assert(err, jc.ErrorIsNil)
459
459
 
527
527
                // And check the machine status is set to error.
528
528
                statusInfo, err := m.Status()
529
529
                c.Assert(err, jc.ErrorIsNil)
530
 
                if statusInfo.Status == status.StatusPending {
 
530
                if statusInfo.Status == status.Pending {
531
531
                        time.Sleep(coretesting.ShortWait)
532
532
                        continue
533
533
                }
534
 
                c.Assert(statusInfo.Status, gc.Equals, status.StatusError)
 
534
                c.Assert(statusInfo.Status, gc.Equals, status.Error)
535
535
                c.Assert(statusInfo.Message, gc.Equals, "no matching tools available")
536
536
                break
537
537
        }
574
574
                // And check the machine status is set to error.
575
575
                statusInfo, err := m.Status()
576
576
                c.Assert(err, jc.ErrorIsNil)
577
 
                if statusInfo.Status == status.StatusPending {
 
577
                if statusInfo.Status == status.Pending {
578
578
                        time.Sleep(coretesting.ShortWait)
579
579
                        continue
580
580
                }
581
 
                c.Assert(statusInfo.Status, gc.Equals, status.StatusError)
 
581
                c.Assert(statusInfo.Status, gc.Equals, status.Error)
582
582
                // check that the status matches the error message
583
583
                c.Assert(statusInfo.Message, gc.Equals, destroyError.Error())
584
584
                return
635
635
        stop(c, p)
636
636
        statusInfo, err := m.Status()
637
637
        c.Assert(err, jc.ErrorIsNil)
638
 
        c.Assert(statusInfo.Status, gc.Equals, status.StatusPending)
 
638
        c.Assert(statusInfo.Status, gc.Equals, status.Pending)
639
639
        s.checkNoOperations(c)
640
640
}
641
641
 
744
744
var machineClassificationTests = []machineClassificationTest{{
745
745
        description:    "Dead machine is dead",
746
746
        life:           params.Dead,
747
 
        status:         status.StatusStarted,
 
747
        status:         status.Started,
748
748
        classification: provisioner.Dead,
749
749
}, {
750
750
        description:    "Dying machine can carry on dying",
751
751
        life:           params.Dying,
752
 
        status:         status.StatusStarted,
 
752
        status:         status.Started,
753
753
        classification: provisioner.None,
754
754
}, {
755
755
        description:    "Dying unprovisioned machine is ensured dead",
756
756
        life:           params.Dying,
757
 
        status:         status.StatusStarted,
 
757
        status:         status.Started,
758
758
        classification: provisioner.Dead,
759
759
        idErr:          params.CodeNotProvisioned,
760
760
}, {
761
761
        description:    "Can't load provisioned dying machine",
762
762
        life:           params.Dying,
763
 
        status:         status.StatusStarted,
 
763
        status:         status.Started,
764
764
        classification: provisioner.None,
765
765
        idErr:          params.CodeNotFound,
766
766
        expectErrCode:  params.CodeNotFound,
768
768
}, {
769
769
        description:    "Alive machine is not provisioned - pending",
770
770
        life:           params.Alive,
771
 
        status:         status.StatusPending,
 
771
        status:         status.Pending,
772
772
        classification: provisioner.Pending,
773
773
        idErr:          params.CodeNotProvisioned,
774
774
        expectErrFmt:   "found machine pending provisioning id:%s.*",
775
775
}, {
776
776
        description:    "Alive, pending machine not found",
777
777
        life:           params.Alive,
778
 
        status:         status.StatusPending,
 
778
        status:         status.Pending,
779
779
        classification: provisioner.None,
780
780
        idErr:          params.CodeNotFound,
781
781
        expectErrCode:  params.CodeNotFound,
789
789
}, {
790
790
        description:    "Dying machine fails to ensure dead",
791
791
        life:           params.Dying,
792
 
        status:         status.StatusStarted,
 
792
        status:         status.Started,
793
793
        classification: provisioner.None,
794
794
        idErr:          params.CodeNotProvisioned,
795
795
        expectErrCode:  params.CodeNotFound,
800
800
var machineClassificationTestsRequireMaintenance = machineClassificationTest{
801
801
        description:    "Machine needs maintaining",
802
802
        life:           params.Alive,
803
 
        status:         status.StatusStarted,
 
803
        status:         status.Started,
804
804
        classification: provisioner.Maintain,
805
805
}
806
806
 
807
807
var machineClassificationTestsNoMaintenance = machineClassificationTest{
808
808
        description:    "Machine doesn't need maintaining",
809
809
        life:           params.Alive,
810
 
        status:         status.StatusStarted,
 
810
        status:         status.Started,
811
811
        classification: provisioner.None,
812
812
}
813
813
 
911
911
        for time.Since(t0) < coretesting.LongWait {
912
912
                statusInfo, err := machine.Status()
913
913
                c.Assert(err, jc.ErrorIsNil)
914
 
                if statusInfo.Status == status.StatusPending {
 
914
                if statusInfo.Status == status.Pending {
915
915
                        time.Sleep(coretesting.ShortWait)
916
916
                        continue
917
917
                }
918
 
                c.Assert(statusInfo.Status, gc.Equals, status.StatusError)
 
918
                c.Assert(statusInfo.Status, gc.Equals, status.Error)
919
919
                c.Assert(statusInfo.Message, gc.Equals, expectedErrorStatus)
920
920
                break
921
921
        }
1272
1272
                        case <-time.After(coretesting.ShortWait):
1273
1273
                                now := time.Now()
1274
1274
                                sInfo := status.StatusInfo{
1275
 
                                        Status:  status.StatusError,
 
1275
                                        Status:  status.Error,
1276
1276
                                        Message: "info",
1277
1277
                                        Data:    map[string]interface{}{"transient": true},
1278
1278
                                        Since:   &now,
1288
1288
        // Machine 4 is never provisioned.
1289
1289
        statusInfo, err := m4.Status()
1290
1290
        c.Assert(err, jc.ErrorIsNil)
1291
 
        c.Assert(statusInfo.Status, gc.Equals, status.StatusError)
 
1291
        c.Assert(statusInfo.Status, gc.Equals, status.Error)
1292
1292
        _, err = m4.InstanceId()
1293
1293
        c.Assert(err, jc.Satisfies, errors.IsNotProvisioned)
1294
1294
}