← Back to branch summary

~sinzui/ubuntu/wily/juju-core/wily-1.24.7

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/apiserver/client/run_test.go

  • Committer: Package Import Robot
  • Author(s): Curtis C. Hovey
  • Date: 2015-09-22 15:27:01 UTC
  • mfrom: (1.1.36)
  • Revision ID: package-import@ubuntu.com-20150922152701-lzq2yhn2uaahrdqu
Tags: 1.24.6-0ubuntu1
https://launchpad.net/bugs/1481556
* New upstream release (LP: #1481556).
* d/copyright updated for Juju 1.24.6 (Last verified commit changes).
* d/tests/* Run tests with upstart when Juju version before 1.23.
* Prefer gccgo-5 for ppc64el and arm64 in build-deps.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/juju/apiserver/client/run_test.go
5
5
 
6
6
import (
7
7
        "fmt"
8
 
        "io/ioutil"
9
 
        "path/filepath"
10
8
        "time"
11
9
 
12
 
        "github.com/juju/errors"
 
10
        gitjujutesting "github.com/juju/testing"
13
11
        jc "github.com/juju/testing/checkers"
14
12
        "github.com/juju/utils/exec"
15
13
        gc "gopkg.in/check.v1"
16
14
 
17
15
        "github.com/juju/juju/apiserver/client"
18
 
        "github.com/juju/juju/apiserver/common"
19
16
        "github.com/juju/juju/apiserver/params"
20
17
        "github.com/juju/juju/network"
21
18
        "github.com/juju/juju/state"
37
34
 
38
35
func (s *runSuite) addMachineWithAddress(c *gc.C, address string) *state.Machine {
39
36
        machine := s.addMachine(c)
40
 
        machine.SetProviderAddresses(network.NewAddress(address, network.ScopeUnknown))
 
37
        machine.SetProviderAddresses(network.NewAddress(address))
41
38
        return machine
42
39
}
43
40
 
53
50
        c.Assert(result.Host, gc.Equals, "")
54
51
}
55
52
 
56
 
// blockAllChanges blocks all operations that could change environment -
57
 
// setting block-all-changes to true.
58
 
// Asserts that no errors were encountered.
59
 
func (s *runSuite) blockAllChanges(c *gc.C) {
60
 
        err := s.State.UpdateEnvironConfig(map[string]interface{}{"block-all-changes": true}, nil, nil)
61
 
        c.Assert(err, jc.ErrorIsNil)
62
 
}
63
 
 
64
53
func (s *runSuite) TestRemoteParamsForMachinePopulatesWithAddress(c *gc.C) {
65
54
        machine := s.addMachineWithAddress(c, "10.3.2.1")
66
55
 
80
69
        c.Assert(err, jc.ErrorIsNil)
81
70
        machine, err := s.State.Machine(mId)
82
71
        c.Assert(err, jc.ErrorIsNil)
83
 
        machine.SetProviderAddresses(network.NewAddress("10.3.2.1", network.ScopeUnknown))
 
72
        machine.SetProviderAddresses(network.NewAddress("10.3.2.1"))
84
73
        return unit
85
74
}
86
75
 
87
76
func (s *runSuite) TestGetAllUnitNames(c *gc.C) {
88
77
        charm := s.AddTestingCharm(c, "dummy")
89
78
        owner := s.AdminUserTag(c)
90
 
        magic, err := s.State.AddService("magic", owner.String(), charm, nil)
 
79
        magic, err := s.State.AddService("magic", owner.String(), charm, nil, nil, nil)
91
80
        s.addUnit(c, magic)
92
81
        s.addUnit(c, magic)
93
82
 
94
 
        notAssigned, err := s.State.AddService("not-assigned", owner.String(), charm, nil)
 
83
        notAssigned, err := s.State.AddService("not-assigned", owner.String(), charm, nil, nil, nil)
95
84
        c.Assert(err, jc.ErrorIsNil)
96
85
        _, err = notAssigned.AddUnit()
97
86
        c.Assert(err, jc.ErrorIsNil)
98
87
 
99
 
        _, err = s.State.AddService("no-units", owner.String(), charm, nil)
 
88
        _, err = s.State.AddService("no-units", owner.String(), charm, nil, nil, nil)
100
89
        c.Assert(err, jc.ErrorIsNil)
101
90
 
102
 
        wordpress, err := s.State.AddService("wordpress", owner.String(), s.AddTestingCharm(c, "wordpress"), nil)
 
91
        wordpress, err := s.State.AddService("wordpress", owner.String(), s.AddTestingCharm(c, "wordpress"), nil, nil, nil)
103
92
        c.Assert(err, jc.ErrorIsNil)
104
93
        wordpress0 := s.addUnit(c, wordpress)
105
 
        _, err = s.State.AddService("logging", owner.String(), s.AddTestingCharm(c, "logging"), nil)
 
94
        _, err = s.State.AddService("logging", owner.String(), s.AddTestingCharm(c, "logging"), nil, nil, nil)
106
95
        c.Assert(err, jc.ErrorIsNil)
107
96
 
108
97
        eps, err := s.State.InferEndpoints("logging", "wordpress")
171
160
}
172
161
 
173
162
func (s *runSuite) mockSSH(c *gc.C, cmd string) {
174
 
        testbin := c.MkDir()
175
 
        fakessh := filepath.Join(testbin, "ssh")
176
 
        s.PatchEnvPathPrepend(testbin)
177
 
        err := ioutil.WriteFile(fakessh, []byte(cmd), 0755)
178
 
        c.Assert(err, jc.ErrorIsNil)
 
163
        gitjujutesting.PatchExecutable(c, s, "ssh", cmd)
 
164
        gitjujutesting.PatchExecutable(c, s, "scp", cmd)
 
165
        client, _ := ssh.NewOpenSSHClient()
 
166
        s.PatchValue(&ssh.DefaultClient, client)
179
167
}
180
168
 
181
169
func (s *runSuite) TestParallelExecuteErrorsOnBlankHost(c *gc.C) {
182
170
        s.mockSSH(c, echoInputShowArgs)
183
171
 
184
172
        params := []*client.RemoteExec{
185
 
                &client.RemoteExec{
 
173
                {
186
174
                        ExecParams: ssh.ExecParams{
187
175
                                Command: "foo",
188
176
                                Timeout: testing.LongWait,
200
188
        s.mockSSH(c, echoInputShowArgs)
201
189
 
202
190
        params := []*client.RemoteExec{
203
 
                &client.RemoteExec{
 
191
                {
204
192
                        ExecParams: ssh.ExecParams{
205
193
                                Host:    "localhost",
206
194
                                Command: "foo",
213
201
        c.Assert(runResults.Results, gc.HasLen, 1)
214
202
        result := runResults.Results[0]
215
203
        c.Assert(result.Error, gc.Equals, "")
216
 
        c.Assert(string(result.Stderr), jc.Contains, "-i /some/dir/system-identity")
 
204
        c.Assert(string(result.Stderr), jc.Contains, "system-identity")
217
205
}
218
206
 
219
207
func (s *runSuite) TestParallelExecuteCopiesAcrossMachineAndUnit(c *gc.C) {
220
208
        s.mockSSH(c, echoInputShowArgs)
221
209
 
222
210
        params := []*client.RemoteExec{
223
 
                &client.RemoteExec{
 
211
                {
224
212
                        ExecParams: ssh.ExecParams{
225
213
                                Host:    "localhost",
226
214
                                Command: "foo",
254
242
        results, err := client.RunOnAllMachines("hostname", testing.LongWait)
255
243
        c.Assert(err, jc.ErrorIsNil)
256
244
        c.Assert(results, gc.HasLen, 3)
 
245
 
257
246
        var expectedResults []params.RunResult
258
247
        for i := 0; i < 3; i++ {
259
248
                expectedResults = append(expectedResults,
260
249
                        params.RunResult{
261
 
                                ExecResponse: exec.ExecResponse{Stdout: []byte("juju-run --no-context 'hostname'\n")},
 
250
                                ExecResponse: exec.ExecResponse{Stdout: []byte(expectedCommand[0])},
262
251
 
263
252
                                MachineId: fmt.Sprint(i),
264
253
                        })
276
265
        s.mockSSH(c, echoInput)
277
266
 
278
267
        // block all changes
279
 
        s.blockAllChanges(c)
280
 
        client := s.APIState.Client()
281
 
        _, err := client.RunOnAllMachines("hostname", testing.LongWait)
282
 
        c.Assert(errors.Cause(err), gc.DeepEquals, common.ErrOperationBlocked)
 
268
        s.BlockAllChanges(c, "TestBlockRunOnAllMachines")
 
269
        _, err := s.APIState.Client().RunOnAllMachines("hostname", testing.LongWait)
 
270
        s.AssertBlocked(c, err, "TestBlockRunOnAllMachines")
283
271
}
284
272
 
285
273
func (s *runSuite) TestRunMachineAndService(c *gc.C) {
288
276
 
289
277
        charm := s.AddTestingCharm(c, "dummy")
290
278
        owner := s.Factory.MakeUser(c, nil).Tag()
291
 
        magic, err := s.State.AddService("magic", owner.String(), charm, nil)
 
279
        magic, err := s.State.AddService("magic", owner.String(), charm, nil, nil, nil)
292
280
        c.Assert(err, jc.ErrorIsNil)
293
281
        s.addUnit(c, magic)
294
282
        s.addUnit(c, magic)
308
296
                })
309
297
        c.Assert(err, jc.ErrorIsNil)
310
298
        c.Assert(results, gc.HasLen, 3)
 
299
 
311
300
        expectedResults := []params.RunResult{
312
 
                params.RunResult{
313
 
                        ExecResponse: exec.ExecResponse{Stdout: []byte("juju-run --no-context 'hostname'\n")},
 
301
                {
 
302
                        ExecResponse: exec.ExecResponse{Stdout: []byte(expectedCommand[0])},
314
303
                        MachineId:    "0",
315
304
                },
316
 
                params.RunResult{
317
 
                        ExecResponse: exec.ExecResponse{Stdout: []byte("juju-run magic/0 'hostname'\n")},
 
305
                {
 
306
                        ExecResponse: exec.ExecResponse{Stdout: []byte(expectedCommand[1])},
318
307
                        MachineId:    "1",
319
308
                        UnitId:       "magic/0",
320
309
                },
321
 
                params.RunResult{
322
 
                        ExecResponse: exec.ExecResponse{Stdout: []byte("juju-run magic/1 'hostname'\n")},
 
310
                {
 
311
                        ExecResponse: exec.ExecResponse{Stdout: []byte(expectedCommand[2])},
323
312
                        MachineId:    "2",
324
313
                        UnitId:       "magic/1",
325
314
                },
334
323
 
335
324
        charm := s.AddTestingCharm(c, "dummy")
336
325
        owner := s.Factory.MakeUser(c, nil).Tag()
337
 
        magic, err := s.State.AddService("magic", owner.String(), charm, nil)
 
326
        magic, err := s.State.AddService("magic", owner.String(), charm, nil, nil, nil)
338
327
        c.Assert(err, jc.ErrorIsNil)
339
328
        s.addUnit(c, magic)
340
329
        s.addUnit(c, magic)
347
336
        client := s.APIState.Client()
348
337
 
349
338
        // block all changes
350
 
        s.blockAllChanges(c)
 
339
        s.BlockAllChanges(c, "TestBlockRunMachineAndService")
351
340
        _, err = client.Run(
352
341
                params.RunParams{
353
342
                        Commands: "hostname",
355
344
                        Machines: []string{"0"},
356
345
                        Services: []string{"magic"},
357
346
                })
358
 
        c.Assert(errors.Cause(err), gc.DeepEquals, common.ErrOperationBlocked)
 
347
        s.AssertBlocked(c, err, "TestBlockRunMachineAndService")
359
348
}
360
 
 
361
 
var echoInputShowArgs = `#!/bin/bash
362
 
# Write the args to stderr
363
 
echo "$*" >&2
364
 
# And echo stdin to stdout
365
 
while read line
366
 
do echo $line
367
 
done <&0
368
 
`
369
 
 
370
 
var echoInput = `#!/bin/bash
371
 
# And echo stdin to stdout
372
 
while read line
373
 
do echo $line
374
 
done <&0
375
 
`