← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/service/windows/service_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/service/windows/service_test.go
 
1
// Copyright 2015 Canonical Ltd.
 
2
// Copyright 2015 Cloudbase Solutions SRL
 
3
// Licensed under the AGPLv3, see LICENCE file for details.
 
4
 
 
5
package windows_test
 
6
 
 
7
import (
 
8
        "github.com/juju/errors"
 
9
        "github.com/juju/testing"
 
10
        jc "github.com/juju/testing/checkers"
 
11
        gc "gopkg.in/check.v1"
 
12
 
 
13
        "github.com/juju/juju/service/common"
 
14
        "github.com/juju/juju/service/windows"
 
15
        coretesting "github.com/juju/juju/testing"
 
16
)
 
17
 
 
18
type serviceSuite struct {
 
19
        coretesting.BaseSuite
 
20
 
 
21
        name     string
 
22
        conf     common.Conf
 
23
        execPath string
 
24
 
 
25
        stub    *testing.Stub
 
26
        stubMgr *windows.StubSvcManager
 
27
 
 
28
        svcExistsErr error
 
29
 
 
30
        mgr *windows.Service
 
31
}
 
32
 
 
33
var _ = gc.Suite(&serviceSuite{})
 
34
 
 
35
func (s *serviceSuite) SetUpTest(c *gc.C) {
 
36
        s.BaseSuite.SetUpTest(c)
 
37
        var err error
 
38
        s.execPath = `C:\juju\bin\jujud.exe`
 
39
        s.stub = &testing.Stub{}
 
40
        s.stubMgr = windows.PatchServiceManager(s, s.stub)
 
41
 
 
42
        // Set up the service.
 
43
        s.name = "machine-1"
 
44
        s.conf = common.Conf{
 
45
                Desc:      "service for " + s.name,
 
46
                ExecStart: s.execPath + " " + s.name,
 
47
        }
 
48
 
 
49
        s.svcExistsErr = errors.New("Service machine-1 already installed")
 
50
 
 
51
        s.mgr, err = windows.NewService(s.name, s.conf)
 
52
        c.Assert(err, gc.IsNil)
 
53
 
 
54
        // Clear services
 
55
        s.stubMgr.Clear()
 
56
        s.stub.ResetCalls()
 
57
}
 
58
 
 
59
func (s *serviceSuite) TestInstall(c *gc.C) {
 
60
        err := s.mgr.Install()
 
61
        c.Assert(err, gc.IsNil)
 
62
 
 
63
        exists, err := s.stubMgr.Exists(s.name, s.conf)
 
64
        c.Assert(err, gc.IsNil)
 
65
        c.Assert(exists, jc.IsTrue)
 
66
 
 
67
        s.stub.CheckCallNames(c, "listServices", "Create")
 
68
}
 
69
 
 
70
func (s *serviceSuite) TestInstallAlreadyExists(c *gc.C) {
 
71
        err := s.mgr.Install()
 
72
        c.Assert(err, gc.IsNil)
 
73
 
 
74
        exists, err := s.stubMgr.Exists(s.name, s.conf)
 
75
        c.Assert(err, gc.IsNil)
 
76
        c.Assert(exists, jc.IsTrue)
 
77
 
 
78
        err = s.mgr.Install()
 
79
        c.Assert(err.Error(), gc.Equals, s.svcExistsErr.Error())
 
80
 
 
81
        s.stub.CheckCallNames(c, "listServices", "Create", "listServices")
 
82
}
 
83
 
 
84
func (s *serviceSuite) TestStop(c *gc.C) {
 
85
        err := s.mgr.Install()
 
86
        c.Assert(err, gc.IsNil)
 
87
 
 
88
        running, err := s.mgr.Running()
 
89
        c.Assert(err, gc.IsNil)
 
90
        c.Assert(running, jc.IsFalse)
 
91
 
 
92
        err = s.mgr.Start()
 
93
        c.Assert(err, gc.IsNil)
 
94
 
 
95
        running, err = s.mgr.Running()
 
96
        c.Assert(err, gc.IsNil)
 
97
        c.Assert(running, jc.IsTrue)
 
98
 
 
99
        err = s.mgr.Stop()
 
100
        c.Assert(err, gc.IsNil)
 
101
 
 
102
        running, err = s.mgr.Running()
 
103
        c.Assert(err, gc.IsNil)
 
104
        c.Assert(running, jc.IsFalse)
 
105
}
 
106
 
 
107
func (s *serviceSuite) TestStopStart(c *gc.C) {
 
108
        err := s.mgr.Install()
 
109
        c.Assert(err, gc.IsNil)
 
110
 
 
111
        running, err := s.mgr.Running()
 
112
        c.Assert(err, gc.IsNil)
 
113
        c.Assert(running, jc.IsFalse)
 
114
 
 
115
        err = s.mgr.Start()
 
116
        c.Assert(err, gc.IsNil)
 
117
 
 
118
        running, err = s.mgr.Running()
 
119
        c.Assert(err, gc.IsNil)
 
120
        c.Assert(running, jc.IsTrue)
 
121
 
 
122
        err = s.mgr.Stop()
 
123
        c.Assert(err, gc.IsNil)
 
124
 
 
125
        running, err = s.mgr.Running()
 
126
        c.Assert(err, gc.IsNil)
 
127
        c.Assert(running, jc.IsFalse)
 
128
 
 
129
        err = s.mgr.Start()
 
130
        c.Assert(err, gc.IsNil)
 
131
 
 
132
        running, err = s.mgr.Running()
 
133
        c.Assert(err, gc.IsNil)
 
134
        c.Assert(running, jc.IsTrue)
 
135
}
 
136
 
 
137
func (s *serviceSuite) TestRemove(c *gc.C) {
 
138
        err := s.mgr.Install()
 
139
        c.Assert(err, gc.IsNil)
 
140
 
 
141
        exists, err := s.stubMgr.Exists(s.name, s.conf)
 
142
        c.Assert(err, gc.IsNil)
 
143
        c.Assert(exists, jc.IsTrue)
 
144
 
 
145
        err = s.mgr.Remove()
 
146
        c.Assert(err, gc.IsNil)
 
147
 
 
148
        exists, err = s.stubMgr.Exists(s.name, s.conf)
 
149
        c.Assert(err, gc.IsNil)
 
150
        c.Assert(exists, jc.IsFalse)
 
151
 
 
152
        s.stub.CheckCallNames(c, "listServices", "Create", "listServices", "listServices", "Running", "Delete")
 
153
}
 
154
 
 
155
func (s *serviceSuite) TestRemoveRunningService(c *gc.C) {
 
156
        err := s.mgr.Install()
 
157
        c.Assert(err, gc.IsNil)
 
158
 
 
159
        exists, err := s.stubMgr.Exists(s.name, s.conf)
 
160
        c.Assert(err, gc.IsNil)
 
161
        c.Assert(exists, jc.IsTrue)
 
162
 
 
163
        err = s.mgr.Start()
 
164
        c.Assert(err, gc.IsNil)
 
165
 
 
166
        err = s.mgr.Remove()
 
167
        c.Assert(err, gc.IsNil)
 
168
 
 
169
        exists, err = s.stubMgr.Exists(s.name, s.conf)
 
170
        c.Assert(err, gc.IsNil)
 
171
        c.Assert(exists, jc.IsFalse)
 
172
 
 
173
        s.stub.CheckCallNames(c, "listServices", "Create", "listServices", "Running", "Start", "listServices", "listServices", "Running", "Stop", "Delete")
 
174
}
 
175
 
 
176
func (s *serviceSuite) TestRemoveInexistent(c *gc.C) {
 
177
        exists, err := s.stubMgr.Exists(s.name, s.conf)
 
178
        c.Assert(err, gc.IsNil)
 
179
        c.Assert(exists, jc.IsFalse)
 
180
 
 
181
        err = s.mgr.Remove()
 
182
        c.Assert(err, gc.IsNil)
 
183
 
 
184
        s.stub.CheckCallNames(c, "listServices")
 
185
}
 
186
 
 
187
func (s *serviceSuite) TestInstalled(c *gc.C) {
 
188
        err := s.mgr.Install()
 
189
        c.Assert(err, gc.IsNil)
 
190
 
 
191
        exists, err := s.mgr.Installed()
 
192
        c.Assert(err, gc.IsNil)
 
193
        c.Assert(exists, jc.IsTrue)
 
194
 
 
195
        s.stub.CheckCallNames(c, "listServices", "Create", "listServices")
 
196
}
 
197
 
 
198
func (s *serviceSuite) TestInstalledListError(c *gc.C) {
 
199
        err := s.mgr.Install()
 
200
        c.Assert(err, gc.IsNil)
 
201
 
 
202
        listErr := errors.New("random error")
 
203
        s.stub.SetErrors(listErr)
 
204
 
 
205
        exists, err := s.mgr.Installed()
 
206
        c.Assert(err.Error(), gc.Equals, listErr.Error())
 
207
        c.Assert(exists, jc.IsFalse)
 
208
}