← Back to branch summary

~themue/juju-core/053-env-more-script-friendly

« back to all changes in this revision

Viewing changes to state/megawatcher_internal_test.go

Merge trunk and resolve conflicts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
state/megawatcher_internal_test.go
6
6
        "labix.org/v2/mgo"
7
7
        . "launchpad.net/gocheck"
8
8
        "launchpad.net/juju-core/charm"
 
9
        "launchpad.net/juju-core/constraints"
9
10
        "launchpad.net/juju-core/state/api/params"
10
11
        "launchpad.net/juju-core/state/multiwatcher"
11
12
        "launchpad.net/juju-core/state/watcher"
65
66
        add(&params.MachineInfo{
66
67
                Id:         "0",
67
68
                InstanceId: "i-machine-0",
68
 
                Status:     params.MachinePending,
 
69
                Status:     params.StatusPending,
69
70
        })
70
71
 
71
72
        wordpress, err := s.State.AddService("wordpress", AddTestingCharm(c, s.State, "wordpress"))
72
73
        c.Assert(err, IsNil)
73
74
        err = wordpress.SetExposed()
74
75
        c.Assert(err, IsNil)
 
76
        err = wordpress.SetConstraints(constraints.MustParse("mem=100M"))
 
77
        c.Assert(err, IsNil)
75
78
        add(&params.ServiceInfo{
76
 
                Name:     "wordpress",
77
 
                Exposed:  true,
78
 
                CharmURL: serviceCharmURL(wordpress).String(),
 
79
                Name:        "wordpress",
 
80
                Exposed:     true,
 
81
                CharmURL:    serviceCharmURL(wordpress).String(),
 
82
                Constraints: constraints.MustParse("mem=100M"),
79
83
        })
80
84
        pairs := map[string]string{"x": "12", "y": "99"}
81
85
        err = wordpress.SetAnnotations(pairs)
118
122
                        Series:    m.Series(),
119
123
                        MachineId: m.Id(),
120
124
                        Ports:     []params.Port{},
121
 
                        Status:    params.UnitPending,
 
125
                        Status:    params.StatusPending,
122
126
                })
123
127
                pairs := map[string]string{"name": fmt.Sprintf("bar %d", i)}
124
128
                err = wu.SetAnnotations(pairs)
130
134
 
131
135
                err = m.SetProvisioned(InstanceId("i-"+m.Tag()), "fake_nonce")
132
136
                c.Assert(err, IsNil)
133
 
                err = m.SetStatus(params.MachineError, m.Tag())
 
137
                err = m.SetStatus(params.StatusError, m.Tag())
134
138
                c.Assert(err, IsNil)
135
139
                add(&params.MachineInfo{
136
140
                        Id:         fmt.Sprint(i + 1),
137
141
                        InstanceId: "i-" + m.Tag(),
138
 
                        Status:     params.MachineError,
 
142
                        Status:     params.StatusError,
139
143
                        StatusInfo: m.Tag(),
140
144
                })
141
145
                err = wu.AssignToMachine(m)
164
168
                        Service: "logging",
165
169
                        Series:  "series",
166
170
                        Ports:   []params.Port{},
167
 
                        Status:  params.UnitPending,
 
171
                        Status:  params.StatusPending,
168
172
                })
169
173
        }
170
174
        return
237
241
                setUp: func(c *C, st *State) {
238
242
                        m, err := st.AddMachine("series", JobHostUnits)
239
243
                        c.Assert(err, IsNil)
240
 
                        err = m.SetStatus(params.MachineError, "failure")
 
244
                        err = m.SetStatus(params.StatusError, "failure")
241
245
                        c.Assert(err, IsNil)
242
246
                },
243
247
                change: watcher.Change{
247
251
                expectContents: []params.EntityInfo{
248
252
                        &params.MachineInfo{
249
253
                                Id:         "0",
250
 
                                Status:     params.MachineError,
 
254
                                Status:     params.StatusError,
251
255
                                StatusInfo: "failure",
252
256
                        },
253
257
                },
256
260
                add: []params.EntityInfo{
257
261
                        &params.MachineInfo{
258
262
                                Id:         "0",
259
 
                                Status:     params.MachineError,
 
263
                                Status:     params.StatusError,
260
264
                                StatusInfo: "another failure",
261
265
                        },
262
266
                },
274
278
                        &params.MachineInfo{
275
279
                                Id:         "0",
276
280
                                InstanceId: "i-0",
277
 
                                Status:     params.MachineError,
 
281
                                Status:     params.StatusError,
278
282
                                StatusInfo: "another failure",
279
283
                        },
280
284
                },
312
316
                        c.Assert(err, IsNil)
313
317
                        err = u.AssignToMachine(m)
314
318
                        c.Assert(err, IsNil)
315
 
                        err = u.SetStatus(params.UnitError, "failure")
 
319
                        err = u.SetStatus(params.StatusError, "failure")
316
320
                        c.Assert(err, IsNil)
317
321
                },
318
322
                change: watcher.Change{
328
332
                                PrivateAddress: "private",
329
333
                                MachineId:      "0",
330
334
                                Ports:          []params.Port{{"tcp", 12345}},
331
 
                                Status:         params.UnitError,
 
335
                                Status:         params.StatusError,
332
336
                                StatusInfo:     "failure",
333
337
                        },
334
338
                },
336
340
                about: "unit is updated if it's in backing and in multiwatcher.Store",
337
341
                add: []params.EntityInfo{&params.UnitInfo{
338
342
                        Name:       "wordpress/0",
339
 
                        Status:     params.UnitError,
 
343
                        Status:     params.StatusError,
340
344
                        StatusInfo: "another failure",
341
345
                }},
342
346
                setUp: func(c *C, st *State) {
360
364
                                Series:        "series",
361
365
                                PublicAddress: "public",
362
366
                                Ports:         []params.Port{{"udp", 17070}},
363
 
                                Status:        params.UnitError,
 
367
                                Status:        params.StatusError,
364
368
                                StatusInfo:    "another failure",
365
369
                        },
366
370
                },
543
547
                about: "no change if status is not in backing",
544
548
                add: []params.EntityInfo{&params.UnitInfo{
545
549
                        Name:       "wordpress/0",
546
 
                        Status:     params.UnitError,
 
550
                        Status:     params.StatusError,
547
551
                        StatusInfo: "failure",
548
552
                }},
549
553
                setUp: func(*C, *State) {},
554
558
                expectContents: []params.EntityInfo{
555
559
                        &params.UnitInfo{
556
560
                                Name:       "wordpress/0",
557
 
                                Status:     params.UnitError,
 
561
                                Status:     params.StatusError,
558
562
                                StatusInfo: "failure",
559
563
                        },
560
564
                },
562
566
                about: "status is changed if the unit exists in the store",
563
567
                add: []params.EntityInfo{&params.UnitInfo{
564
568
                        Name:       "wordpress/0",
565
 
                        Status:     params.UnitError,
 
569
                        Status:     params.StatusError,
566
570
                        StatusInfo: "failure",
567
571
                }},
568
572
                setUp: func(c *C, st *State) {
570
574
                        c.Assert(err, IsNil)
571
575
                        u, err := wordpress.AddUnit()
572
576
                        c.Assert(err, IsNil)
573
 
                        err = u.SetStatus(params.UnitStarted, "")
 
577
                        err = u.SetStatus(params.StatusStarted, "")
574
578
                        c.Assert(err, IsNil)
575
579
                },
576
580
                change: watcher.Change{
580
584
                expectContents: []params.EntityInfo{
581
585
                        &params.UnitInfo{
582
586
                                Name:   "wordpress/0",
583
 
                                Status: params.UnitStarted,
 
587
                                Status: params.StatusStarted,
584
588
                        },
585
589
                },
586
590
        },
596
600
                about: "no change if status is not in backing",
597
601
                add: []params.EntityInfo{&params.MachineInfo{
598
602
                        Id:         "0",
599
 
                        Status:     params.MachineError,
 
603
                        Status:     params.StatusError,
600
604
                        StatusInfo: "failure",
601
605
                }},
602
606
                setUp: func(*C, *State) {},
606
610
                },
607
611
                expectContents: []params.EntityInfo{&params.MachineInfo{
608
612
                        Id:         "0",
609
 
                        Status:     params.MachineError,
 
613
                        Status:     params.StatusError,
610
614
                        StatusInfo: "failure",
611
615
                }},
612
616
        }, {
613
617
                about: "status is changed if the machine exists in the store",
614
618
                add: []params.EntityInfo{&params.MachineInfo{
615
619
                        Id:         "0",
616
 
                        Status:     params.MachineError,
 
620
                        Status:     params.StatusError,
617
621
                        StatusInfo: "failure",
618
622
                }},
619
623
                setUp: func(c *C, st *State) {
620
624
                        m, err := st.AddMachine("series", JobHostUnits)
621
625
                        c.Assert(err, IsNil)
622
 
                        err = m.SetStatus(params.MachineStarted, "")
 
626
                        err = m.SetStatus(params.StatusStarted, "")
623
627
                        c.Assert(err, IsNil)
624
628
                },
625
629
                change: watcher.Change{
629
633
                expectContents: []params.EntityInfo{
630
634
                        &params.MachineInfo{
631
635
                                Id:     "0",
632
 
                                Status: params.MachineStarted,
 
636
                                Status: params.StatusStarted,
 
637
                        },
 
638
                },
 
639
        },
 
640
        // Service constraints changes
 
641
        {
 
642
                about: "no service in state -> do nothing",
 
643
                setUp: func(c *C, st *State) {},
 
644
                change: watcher.Change{
 
645
                        C:  "constraints",
 
646
                        Id: "s#wordpress",
 
647
                },
 
648
        }, {
 
649
                about: "no change if service is not in backing",
 
650
                add: []params.EntityInfo{&params.ServiceInfo{
 
651
                        Name:        "wordpress",
 
652
                        Constraints: constraints.MustParse("mem=99M"),
 
653
                }},
 
654
                setUp: func(*C, *State) {},
 
655
                change: watcher.Change{
 
656
                        C:  "constraints",
 
657
                        Id: "s#wordpress",
 
658
                },
 
659
                expectContents: []params.EntityInfo{&params.ServiceInfo{
 
660
                        Name:        "wordpress",
 
661
                        Constraints: constraints.MustParse("mem=99M"),
 
662
                }},
 
663
        }, {
 
664
                about: "status is changed if the service exists in the store",
 
665
                add: []params.EntityInfo{&params.ServiceInfo{
 
666
                        Name:        "wordpress",
 
667
                        Constraints: constraints.MustParse("mem=99M cpu-cores=2 cpu-power=4"),
 
668
                }},
 
669
                setUp: func(c *C, st *State) {
 
670
                        svc, err := st.AddService("wordpress", AddTestingCharm(c, st, "wordpress"))
 
671
                        c.Assert(err, IsNil)
 
672
                        err = svc.SetConstraints(constraints.MustParse("mem=4G cpu-cores= arch=amd64"))
 
673
                        c.Assert(err, IsNil)
 
674
                },
 
675
                change: watcher.Change{
 
676
                        C:  "constraints",
 
677
                        Id: "s#wordpress",
 
678
                },
 
679
                expectContents: []params.EntityInfo{
 
680
                        &params.ServiceInfo{
 
681
                                Name:        "wordpress",
 
682
                                Constraints: constraints.MustParse("mem=4G cpu-cores= arch=amd64"),
633
683
                        },
634
684
                },
635
685
        },
643
693
                "relations":   s.State.relations,
644
694
                "annotations": s.State.annotations,
645
695
                "statuses":    s.State.statuses,
 
696
                "constraints": s.State.constraints,
646
697
        }
647
698
        for i, test := range allWatcherChangedTests {
648
699
                c.Logf("test %d. %s", i, test.about)
682
733
        checkNext(c, w, b, []params.Delta{{
683
734
                Entity: &params.MachineInfo{
684
735
                        Id:     "0",
685
 
                        Status: params.MachinePending,
 
736
                        Status: params.StatusPending,
686
737
                },
687
738
        }, {
688
739
                Entity: &params.MachineInfo{
689
740
                        Id:     "1",
690
 
                        Status: params.MachinePending,
 
741
                        Status: params.StatusPending,
691
742
                },
692
743
        }}, "")
693
744
 
720
771
                Removed: true,
721
772
                Entity: &params.MachineInfo{
722
773
                        Id:     "1",
723
 
                        Status: params.MachinePending,
 
774
                        Status: params.StatusPending,
724
775
                },
725
776
        }, {
726
777
                Entity: &params.MachineInfo{
727
778
                        Id:     "2",
728
 
                        Status: params.MachinePending,
 
779
                        Status: params.StatusPending,
729
780
                },
730
781
        }, {
731
782
                Entity: &params.MachineInfo{
732
783
                        Id:         "0",
733
784
                        InstanceId: "i-0",
734
 
                        Status:     params.MachinePending,
 
785
                        Status:     params.StatusPending,
735
786
                },
736
787
        }})
737
788