← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/worker/charmrevision/charmrevisionmanifold/manifold_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/worker/charmrevision/charmrevisionmanifold/manifold_test.go
 
1
// Copyright 2015 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
 
4
package charmrevisionmanifold_test
 
5
 
 
6
import (
 
7
        "time"
 
8
 
 
9
        "github.com/juju/errors"
 
10
        "github.com/juju/testing"
 
11
        jc "github.com/juju/testing/checkers"
 
12
        "github.com/juju/utils/clock"
 
13
        gc "gopkg.in/check.v1"
 
14
 
 
15
        "github.com/juju/juju/api/base"
 
16
        "github.com/juju/juju/worker"
 
17
        "github.com/juju/juju/worker/charmrevision"
 
18
        "github.com/juju/juju/worker/charmrevision/charmrevisionmanifold"
 
19
        "github.com/juju/juju/worker/dependency"
 
20
        dt "github.com/juju/juju/worker/dependency/testing"
 
21
)
 
22
 
 
23
type ManifoldSuite struct {
 
24
        testing.IsolationSuite
 
25
}
 
26
 
 
27
var _ = gc.Suite(&ManifoldSuite{})
 
28
 
 
29
func (s *ManifoldSuite) TestManifold(c *gc.C) {
 
30
        manifold := charmrevisionmanifold.Manifold(charmrevisionmanifold.ManifoldConfig{
 
31
                APICallerName: "billy",
 
32
                ClockName:     "bob",
 
33
        })
 
34
 
 
35
        c.Check(manifold.Inputs, jc.DeepEquals, []string{"billy", "bob"})
 
36
        c.Check(manifold.Start, gc.NotNil)
 
37
        c.Check(manifold.Output, gc.IsNil)
 
38
}
 
39
 
 
40
func (s *ManifoldSuite) TestMissingAPICaller(c *gc.C) {
 
41
        manifold := charmrevisionmanifold.Manifold(charmrevisionmanifold.ManifoldConfig{
 
42
                APICallerName: "api-caller",
 
43
                ClockName:     "clock",
 
44
        })
 
45
 
 
46
        _, err := manifold.Start(dt.StubContext(nil, map[string]interface{}{
 
47
                "api-caller": dependency.ErrMissing,
 
48
                "clock":      fakeClock{},
 
49
        }))
 
50
        c.Check(errors.Cause(err), gc.Equals, dependency.ErrMissing)
 
51
}
 
52
 
 
53
func (s *ManifoldSuite) TestMissingClock(c *gc.C) {
 
54
        manifold := charmrevisionmanifold.Manifold(charmrevisionmanifold.ManifoldConfig{
 
55
                APICallerName: "api-caller",
 
56
                ClockName:     "clock",
 
57
        })
 
58
 
 
59
        _, err := manifold.Start(dt.StubContext(nil, map[string]interface{}{
 
60
                "api-caller": fakeAPICaller{},
 
61
                "clock":      dependency.ErrMissing,
 
62
        }))
 
63
        c.Check(errors.Cause(err), gc.Equals, dependency.ErrMissing)
 
64
}
 
65
 
 
66
func (s *ManifoldSuite) TestNewFacadeError(c *gc.C) {
 
67
        fakeAPICaller := &fakeAPICaller{}
 
68
 
 
69
        stub := testing.Stub{}
 
70
        manifold := charmrevisionmanifold.Manifold(charmrevisionmanifold.ManifoldConfig{
 
71
                APICallerName: "api-caller",
 
72
                ClockName:     "clock",
 
73
                NewFacade: func(apiCaller base.APICaller) (charmrevisionmanifold.Facade, error) {
 
74
                        stub.AddCall("NewFacade", apiCaller)
 
75
                        return nil, errors.New("blefgh")
 
76
                },
 
77
        })
 
78
 
 
79
        _, err := manifold.Start(dt.StubContext(nil, map[string]interface{}{
 
80
                "api-caller": fakeAPICaller,
 
81
                "clock":      fakeClock{},
 
82
        }))
 
83
        c.Check(err, gc.ErrorMatches, "cannot create facade: blefgh")
 
84
        stub.CheckCalls(c, []testing.StubCall{{
 
85
                "NewFacade", []interface{}{fakeAPICaller},
 
86
        }})
 
87
}
 
88
 
 
89
func (s *ManifoldSuite) TestNewWorkerError(c *gc.C) {
 
90
        fakeClock := &fakeClock{}
 
91
        fakeFacade := &fakeFacade{}
 
92
        fakeAPICaller := &fakeAPICaller{}
 
93
 
 
94
        stub := testing.Stub{}
 
95
        manifold := charmrevisionmanifold.Manifold(charmrevisionmanifold.ManifoldConfig{
 
96
                APICallerName: "api-caller",
 
97
                ClockName:     "clock",
 
98
                NewFacade: func(apiCaller base.APICaller) (charmrevisionmanifold.Facade, error) {
 
99
                        stub.AddCall("NewFacade", apiCaller)
 
100
                        return fakeFacade, nil
 
101
                },
 
102
                NewWorker: func(config charmrevision.Config) (worker.Worker, error) {
 
103
                        stub.AddCall("NewWorker", config)
 
104
                        return nil, errors.New("snrght")
 
105
                },
 
106
        })
 
107
 
 
108
        _, err := manifold.Start(dt.StubContext(nil, map[string]interface{}{
 
109
                "api-caller": fakeAPICaller,
 
110
                "clock":      fakeClock,
 
111
        }))
 
112
        c.Check(err, gc.ErrorMatches, "cannot create worker: snrght")
 
113
        stub.CheckCalls(c, []testing.StubCall{{
 
114
                "NewFacade", []interface{}{fakeAPICaller},
 
115
        }, {
 
116
                "NewWorker", []interface{}{charmrevision.Config{
 
117
                        RevisionUpdater: fakeFacade,
 
118
                        Clock:           fakeClock,
 
119
                }},
 
120
        }})
 
121
}
 
122
 
 
123
func (s *ManifoldSuite) TestSuccess(c *gc.C) {
 
124
        fakeClock := &fakeClock{}
 
125
        fakeFacade := &fakeFacade{}
 
126
        fakeWorker := &fakeWorker{}
 
127
        fakeAPICaller := &fakeAPICaller{}
 
128
 
 
129
        stub := testing.Stub{}
 
130
        manifold := charmrevisionmanifold.Manifold(charmrevisionmanifold.ManifoldConfig{
 
131
                APICallerName: "api-caller",
 
132
                ClockName:     "clock",
 
133
                Period:        10 * time.Minute,
 
134
                NewFacade: func(apiCaller base.APICaller) (charmrevisionmanifold.Facade, error) {
 
135
                        stub.AddCall("NewFacade", apiCaller)
 
136
                        return fakeFacade, nil
 
137
                },
 
138
                NewWorker: func(config charmrevision.Config) (worker.Worker, error) {
 
139
                        stub.AddCall("NewWorker", config)
 
140
                        return fakeWorker, nil
 
141
                },
 
142
        })
 
143
 
 
144
        w, err := manifold.Start(dt.StubContext(nil, map[string]interface{}{
 
145
                "api-caller": fakeAPICaller,
 
146
                "clock":      fakeClock,
 
147
        }))
 
148
        c.Check(w, gc.Equals, fakeWorker)
 
149
        c.Check(err, jc.ErrorIsNil)
 
150
        stub.CheckCalls(c, []testing.StubCall{{
 
151
                "NewFacade", []interface{}{fakeAPICaller},
 
152
        }, {
 
153
                "NewWorker", []interface{}{charmrevision.Config{
 
154
                        Period:          10 * time.Minute,
 
155
                        RevisionUpdater: fakeFacade,
 
156
                        Clock:           fakeClock,
 
157
                }},
 
158
        }})
 
159
}
 
160
 
 
161
type fakeAPICaller struct {
 
162
        base.APICaller
 
163
}
 
164
 
 
165
type fakeClock struct {
 
166
        clock.Clock
 
167
}
 
168
 
 
169
type fakeWorker struct {
 
170
        worker.Worker
 
171
}
 
172
 
 
173
type fakeFacade struct {
 
174
        charmrevisionmanifold.Facade
 
175
}