← Back to branch summary

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

« back to all changes in this revision

Viewing changes to environs/testing/tools.go

Merge trunk and resolve conflicts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
environs/testing/tools.go
4
4
        . "launchpad.net/gocheck"
5
5
        "launchpad.net/juju-core/environs"
6
6
        "launchpad.net/juju-core/environs/config"
 
7
        "launchpad.net/juju-core/environs/tools"
 
8
        "launchpad.net/juju-core/state"
7
9
        "launchpad.net/juju-core/version"
8
10
        "strings"
9
11
)
10
12
 
11
 
// PutFakeTools sets up a bucket containing something
12
 
// that looks like a tools archive so test methods
13
 
// that start an instance can succeed even though they
14
 
// do not upload tools.
15
 
func PutFakeTools(c *C, s environs.StorageWriter) {
 
13
func uploadFakeToolsVersion(storage environs.Storage, vers version.Binary) (*state.Tools, error) {
 
14
        data := vers.String()
 
15
        name := tools.StorageName(vers)
 
16
        if err := storage.Put(name, strings.NewReader(data), int64(len(data))); err != nil {
 
17
                return nil, err
 
18
        }
 
19
        url, err := storage.URL(name)
 
20
        if err != nil {
 
21
                return nil, err
 
22
        }
 
23
        return &state.Tools{Binary: vers, URL: url}, nil
 
24
}
 
25
 
 
26
// UploadFakeToolsVersion puts fake tools in the supplied storage for the
 
27
// supplied version.
 
28
func UploadFakeToolsVersion(c *C, storage environs.Storage, vers version.Binary) *state.Tools {
 
29
        t, err := uploadFakeToolsVersion(storage, vers)
 
30
        c.Assert(err, IsNil)
 
31
        return t
 
32
}
 
33
 
 
34
// MustUploadFakeToolsVersion acts as UploadFakeToolsVersion, but panics on failure.
 
35
func MustUploadFakeToolsVersion(storage environs.Storage, vers version.Binary) *state.Tools {
 
36
        t, err := uploadFakeToolsVersion(storage, vers)
 
37
        if err != nil {
 
38
                panic(err)
 
39
        }
 
40
        return t
 
41
}
 
42
 
 
43
func uploadFakeTools(storage environs.Storage) error {
16
44
        toolsVersion := version.Current
17
 
        path := environs.ToolsStoragePath(toolsVersion)
18
 
        c.Logf("putting fake tools at %v", path)
19
 
        toolsContents := "tools archive, honest guv"
20
 
        err := s.Put(path, strings.NewReader(toolsContents), int64(len(toolsContents)))
 
45
        if _, err := uploadFakeToolsVersion(storage, toolsVersion); err != nil {
 
46
                return err
 
47
        }
 
48
        if toolsVersion.Series == config.DefaultSeries {
 
49
                return nil
 
50
        }
 
51
        toolsVersion.Series = config.DefaultSeries
 
52
        _, err := uploadFakeToolsVersion(storage, toolsVersion)
 
53
        return err
 
54
}
 
55
 
 
56
// UploadFakeTools puts fake tools into the supplied storage with a binary
 
57
// version matching version.Current; if version.Current's series is different
 
58
// to config.DefaultSeries, matching fake tools will be uploaded for that series.
 
59
// This is useful for tests that are kinda casual about specifying their
 
60
// environment.
 
61
func UploadFakeTools(c *C, storage environs.Storage) {
 
62
        c.Assert(uploadFakeTools(storage), IsNil)
 
63
}
 
64
 
 
65
// MustUploadFakeTools acts as UploadFakeTools, but panics on failure.
 
66
func MustUploadFakeTools(storage environs.Storage) {
 
67
        if err := uploadFakeTools(storage); err != nil {
 
68
                panic(err)
 
69
        }
 
70
}
 
71
 
 
72
// RemoveTools deletes all tools from the supplied storage.
 
73
func RemoveTools(c *C, storage environs.Storage) {
 
74
        names, err := storage.List("tools/juju-")
21
75
        c.Assert(err, IsNil)
22
 
        if toolsVersion.Series != config.DefaultSeries {
23
 
                toolsVersion.Series = config.DefaultSeries
24
 
                path = environs.ToolsStoragePath(toolsVersion)
25
 
                c.Logf("putting fake tools at %v", path)
26
 
                err = s.Put(path, strings.NewReader(toolsContents), int64(len(toolsContents)))
 
76
        for _, name := range names {
 
77
                err = storage.Remove(name)
27
78
                c.Assert(err, IsNil)
28
79
        }
29
80
}