← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/cmd/jujud/agent/model/manifolds_test.go

  • Committer: Nicholas Skaggs
  • Date: 2016-10-24 20:56:05 UTC
  • Revision ID: nicholas.skaggs@canonical.com-20161024205605-z8lta0uvuhtxwzwl
Initi with beta15

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/juju/cmd/jujud/agent/model/manifolds_test.go
 
1
// Copyright 2016 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
 
4
package model_test
 
5
 
 
6
import (
 
7
        "github.com/juju/testing"
 
8
        jc "github.com/juju/testing/checkers"
 
9
        "github.com/juju/utils/clock"
 
10
        "github.com/juju/utils/set"
 
11
        gc "gopkg.in/check.v1"
 
12
 
 
13
        "github.com/juju/juju/cmd/jujud/agent/model"
 
14
        "github.com/juju/juju/worker/workertest"
 
15
)
 
16
 
 
17
type ManifoldsSuite struct {
 
18
        testing.IsolationSuite
 
19
}
 
20
 
 
21
var _ = gc.Suite(&ManifoldsSuite{})
 
22
 
 
23
func (s *ManifoldsSuite) TestNames(c *gc.C) {
 
24
        actual := set.NewStrings()
 
25
        manifolds := model.Manifolds(model.ManifoldsConfig{
 
26
                Agent: &mockAgent{},
 
27
        })
 
28
        for name := range manifolds {
 
29
                actual.Add(name)
 
30
        }
 
31
        // NOTE: if this test failed, the cmd/jujud/agent tests will
 
32
        // also fail. Search for 'ModelWorkers' to find affected vars.
 
33
        c.Check(actual.SortedValues(), jc.DeepEquals, []string{
 
34
                "agent",
 
35
                "api-caller",
 
36
                "api-config-watcher",
 
37
                "application-scaler",
 
38
                "charm-revision-updater",
 
39
                "clock",
 
40
                "compute-provisioner",
 
41
                "environ-tracker",
 
42
                "firewaller",
 
43
                "instance-poller",
 
44
                "is-responsible-flag",
 
45
                "metric-worker",
 
46
                "migration-fortress",
 
47
                "migration-inactive-flag",
 
48
                "migration-master",
 
49
                "not-alive-flag",
 
50
                "not-dead-flag",
 
51
                "space-importer",
 
52
                "spaces-imported-gate",
 
53
                "state-cleaner",
 
54
                "status-history-pruner",
 
55
                "storage-provisioner",
 
56
                "undertaker",
 
57
                "unit-assigner",
 
58
        })
 
59
}
 
60
 
 
61
func (s *ManifoldsSuite) TestFlagDependencies(c *gc.C) {
 
62
        exclusions := set.NewStrings(
 
63
                "agent",
 
64
                "api-caller",
 
65
                "api-config-watcher",
 
66
                "clock",
 
67
                "spaces-imported-gate",
 
68
                "is-responsible-flag",
 
69
                "not-alive-flag",
 
70
                "not-dead-flag",
 
71
        )
 
72
        manifolds := model.Manifolds(model.ManifoldsConfig{
 
73
                Agent: &mockAgent{},
 
74
        })
 
75
        for name, manifold := range manifolds {
 
76
                c.Logf("checking %s", name)
 
77
                if exclusions.Contains(name) {
 
78
                        continue
 
79
                }
 
80
                inputs := set.NewStrings(manifold.Inputs...)
 
81
                if !inputs.Contains("is-responsible-flag") {
 
82
                        c.Check(inputs.Contains("migration-fortress"), jc.IsTrue)
 
83
                        c.Check(inputs.Contains("migration-inactive-flag"), jc.IsTrue)
 
84
                }
 
85
        }
 
86
}
 
87
 
 
88
func (s *ManifoldsSuite) TestStateCleanerIgnoresLifeFlags(c *gc.C) {
 
89
        manifolds := model.Manifolds(model.ManifoldsConfig{
 
90
                Agent: &mockAgent{},
 
91
        })
 
92
        manifold, found := manifolds["state-cleaner"]
 
93
        c.Assert(found, jc.IsTrue)
 
94
 
 
95
        inputs := set.NewStrings(manifold.Inputs...)
 
96
        c.Check(inputs.Contains("not-alive-flag"), jc.IsFalse)
 
97
        c.Check(inputs.Contains("not-dead-flag"), jc.IsFalse)
 
98
}
 
99
 
 
100
func (s *ManifoldsSuite) TestClockWrapper(c *gc.C) {
 
101
        expectClock := &fakeClock{}
 
102
        manifolds := model.Manifolds(model.ManifoldsConfig{
 
103
                Agent: &mockAgent{},
 
104
                Clock: expectClock,
 
105
        })
 
106
        manifold, ok := manifolds["clock"]
 
107
        c.Assert(ok, jc.IsTrue)
 
108
        worker, err := manifold.Start(nil)
 
109
        c.Assert(err, jc.ErrorIsNil)
 
110
        defer workertest.CheckKill(c, worker)
 
111
 
 
112
        var clock clock.Clock
 
113
        err = manifold.Output(worker, &clock)
 
114
        c.Assert(err, jc.ErrorIsNil)
 
115
        c.Check(clock, gc.Equals, expectClock)
 
116
}
 
117
 
 
118
type fakeClock struct{ clock.Clock }