← Back to branch summary

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

« back to all changes in this revision

Viewing changes to cmd/juju/upgradejuju_test.go

Merge trunk and resolve conflicts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
cmd/juju/upgradejuju_test.go
1
1
package main
2
2
 
3
3
import (
4
 
        "fmt"
5
4
        "io/ioutil"
6
5
        . "launchpad.net/gocheck"
7
6
        "launchpad.net/juju-core/environs"
 
7
        envtesting "launchpad.net/juju-core/environs/testing"
 
8
        "launchpad.net/juju-core/environs/tools"
8
9
        "launchpad.net/juju-core/juju/testing"
9
10
        "launchpad.net/juju-core/state"
10
11
        coretesting "launchpad.net/juju-core/testing"
11
12
        "launchpad.net/juju-core/version"
12
 
        "strings"
13
13
)
14
14
 
15
15
type UpgradeJujuSuite struct {
88
88
        expectDevelopment: true,
89
89
}, {
90
90
        about:          "specified version",
 
91
        public:         []string{"2.0.3-foo-bar"},
 
92
        currentVersion: "3.0.0-foo-bar",
 
93
        agentVersion:   "2.0.0",
 
94
        args:           []string{"--version", "2.0.3"},
 
95
        expectVersion:  "2.0.3",
 
96
}, {
 
97
        about:          "specified version missing",
91
98
        currentVersion: "3.0.0-foo-bar",
92
99
        agentVersion:   "2.0.0",
93
100
        args:           []string{"--version", "2.0.3"},
110
117
        currentVersion: "2.0.1-foo-bar",
111
118
        agentVersion:   "2.0.0",
112
119
        args:           []string{"--upload-tools"},
113
 
        expectErr:      "cannot find newest version: no tools found",
 
120
        expectVersion:  "2.0.1",
114
121
        expectUploaded: "2.0.1-foo-bar",
115
122
}, {
116
123
        about:          "upload and bump version",
133
140
},
134
141
}
135
142
 
136
 
func upload(s environs.Storage, v string) {
137
 
        vers := version.MustParseBinary(v)
138
 
        p := environs.ToolsStoragePath(vers)
139
 
        err := s.Put(p, strings.NewReader(v), int64(len(v)))
140
 
        if err != nil {
141
 
                panic(err)
142
 
        }
143
 
}
144
 
 
145
 
// testPutTools mocks environs.PutTools. This is an advantage in
146
 
// two ways:
147
 
// - we can make it return a tools with a version == version.Current.
148
 
// - we don't need to actually rebuild the juju source for each test
149
 
// that uses --upload-tools.
150
 
func testPutTools(storage environs.Storage, forceVersion *version.Number, fakeSeries ...string) (*state.Tools, error) {
 
143
// mockUploadTools simulates the effect of tools.Upload, but skips the time-
 
144
// consuming build from source.
 
145
// TODO(fwereade) better factor environs/tools such that build logic is
 
146
// exposed and can itself be neatly mocked?
 
147
func mockUploadTools(putter tools.URLPutter, forceVersion *version.Number, fakeSeries ...string) (*state.Tools, error) {
 
148
        storage := putter.(environs.Storage)
151
149
        vers := version.Current
152
150
        if forceVersion != nil {
153
151
                vers.Number = *forceVersion
154
152
        }
155
 
        if len(fakeSeries) != 0 {
156
 
                return nil, fmt.Errorf("test framework should not be trusted with this")
 
153
        t := envtesting.MustUploadFakeToolsVersion(storage, vers)
 
154
        for _, series := range fakeSeries {
 
155
                vers.Series = series
 
156
                envtesting.MustUploadFakeToolsVersion(storage, vers)
157
157
        }
158
 
        upload(storage, vers.String())
159
 
        return &state.Tools{
160
 
                Binary: vers,
161
 
        }, nil
 
158
        return t, nil
162
159
}
163
160
 
164
161
func (s *UpgradeJujuSuite) TestUpgradeJuju(c *C) {
165
162
        oldVersion := version.Current
166
 
        putTools = testPutTools
 
163
        uploadTools = mockUploadTools
167
164
        defer func() {
168
165
                version.Current = oldVersion
169
 
                putTools = environs.PutTools
 
166
                uploadTools = tools.Upload
170
167
        }()
171
168
 
172
169
        for i, test := range upgradeJujuTests {
174
171
                // Set up the test preconditions.
175
172
                s.Reset(c)
176
173
                for _, v := range test.private {
177
 
                        upload(s.Conn.Environ.Storage(), v)
 
174
                        vers := version.MustParseBinary(v)
 
175
                        envtesting.MustUploadFakeToolsVersion(s.Conn.Environ.Storage(), vers)
178
176
                }
179
177
                for _, v := range test.public {
 
178
                        vers := version.MustParseBinary(v)
180
179
                        storage := s.Conn.Environ.PublicStorage().(environs.Storage)
181
 
                        upload(storage, v)
 
180
                        envtesting.MustUploadFakeToolsVersion(storage, vers)
182
181
                }
183
182
                version.Current = version.MustParseBinary(test.currentVersion)
184
183
                err := SetAgentVersion(s.State, version.MustParse(test.agentVersion), false)
203
202
                c.Check(cfg.Development(), Equals, test.expectDevelopment)
204
203
 
205
204
                if test.expectUploaded != "" {
206
 
                        p := environs.ToolsStoragePath(version.MustParseBinary(test.expectUploaded))
207
 
                        r, err := s.Conn.Environ.Storage().Get(p)
 
205
                        vers := version.MustParseBinary(test.expectUploaded)
 
206
                        r, err := s.Conn.Environ.Storage().Get(tools.StorageName(vers))
208
207
                        c.Assert(err, IsNil)
209
208
                        data, err := ioutil.ReadAll(r)
210
209
                        c.Check(err, IsNil)
219
218
// 'em there.
220
219
func (s *UpgradeJujuSuite) Reset(c *C) {
221
220
        s.JujuConnSuite.Reset(c)
222
 
        removeAll := func(storage environs.Storage) {
223
 
                names, err := storage.List("")
224
 
                c.Assert(err, IsNil)
225
 
                for _, name := range names {
226
 
                        err := storage.Remove(name)
227
 
                        c.Assert(err, IsNil)
228
 
                }
229
 
        }
230
 
        removeAll(s.Conn.Environ.Storage())
231
 
        removeAll(s.Conn.Environ.PublicStorage().(environs.Storage))
 
221
        envtesting.RemoveTools(c, s.Conn.Environ.Storage())
 
222
        envtesting.RemoveTools(c, s.Conn.Environ.PublicStorage().(environs.Storage))
232
223
}
233
224
 
234
225
func (s *UpgradeJujuSuite) TestUpgradeJujuWithRealPutTools(c *C) {
235
226
        s.Reset(c)
236
227
        _, err := coretesting.RunCommand(c, &UpgradeJujuCommand{}, []string{"--upload-tools", "--dev"})
237
228
        c.Assert(err, IsNil)
238
 
        p := environs.ToolsStoragePath(version.Current)
239
 
        r, err := s.Conn.Environ.Storage().Get(p)
 
229
        name := tools.StorageName(version.Current)
 
230
        r, err := s.Conn.Environ.Storage().Get(name)
240
231
        c.Assert(err, IsNil)
241
232
        r.Close()
242
233
}