func (s *upgradeSuite) TestPerformUpgrade(c *gc.C) {
s.PatchValue(upgrades.StateUpgradeOperations, stateUpgradeOperations)
s.PatchValue(upgrades.UpgradeOperations, upgradeOperations)
for i, test := range upgradeTests {
c.Logf("%d: %s", i, test.about)
var messages []string
ctx := &mockContext{
messages: messages,
}
fromVersion := version.Zero
if test.fromVersion != "" {
fromVersion = version.MustParse(test.fromVersion)
}
toVersion := version.MustParse("1.18.0")
if test.toVersion != "" {
toVersion = version.MustParse(test.toVersion)
}
s.PatchValue(&jujuversion.Current, toVersion)
err := upgrades.PerformUpgrade(fromVersion, test.targets, ctx)
if test.err == "" {
c.Check(err, jc.ErrorIsNil)
} else {
c.Check(err, gc.ErrorMatches, test.err)
}
c.Check(ctx.messages, jc.DeepEquals, test.expectedSteps)
}
}
func (s *toolsSuite) TestFindToolsExactNotInStorage(c *gc.C) {
mockToolsStorage := &mockToolsStorage{}
s.PatchValue(&jujuversion.Current, version.MustParse("1.22-beta1"))
s.testFindToolsExact(c, mockToolsStorage, false, true)
s.PatchValue(&jujuversion.Current, version.MustParse("1.22.0"))
s.testFindToolsExact(c, mockToolsStorage, false, false)
}
func (s *ClientSuite) TestModelInfo(c *gc.C) {
var stub jujutesting.Stub
owner := names.NewUserTag("owner")
apiCaller := apitesting.APICallerFunc(func(objType string, v int, id, request string, arg, result interface{}) error {
stub.AddCall(objType+"."+request, id, arg)
*(result.(*params.MigrationModelInfo)) = params.MigrationModelInfo{
UUID: "uuid",
Name: "name",
OwnerTag: owner.String(),
AgentVersion: version.MustParse("1.2.3"),
}
return nil
})
client := migrationmaster.NewClient(apiCaller, nil)
model, err := client.ModelInfo()
stub.CheckCalls(c, []jujutesting.StubCall{
{"MigrationMaster.ModelInfo", []interface{}{"", nil}},
})
c.Check(err, jc.ErrorIsNil)
c.Check(model, jc.DeepEquals, migration.ModelInfo{
UUID: "uuid",
Name: "name",
Owner: owner,
AgentVersion: version.MustParse("1.2.3"),
})
}
func (s *serverSuite) TestAbortCurrentUpgrade(c *gc.C) {
// Create a provisioned controller.
machine, err := s.State.AddMachine("series", state.JobManageModel)
c.Assert(err, jc.ErrorIsNil)
err = machine.SetProvisioned(instance.Id("i-blah"), "fake-nonce", nil)
c.Assert(err, jc.ErrorIsNil)
// Start an upgrade.
_, err = s.State.EnsureUpgradeInfo(
machine.Id(),
version.MustParse("1.2.3"),
version.MustParse("9.8.7"),
)
c.Assert(err, jc.ErrorIsNil)
isUpgrading, err := s.State.IsUpgrading()
c.Assert(err, jc.ErrorIsNil)
c.Assert(isUpgrading, jc.IsTrue)
// Abort it.
err = s.client.AbortCurrentUpgrade()
c.Assert(err, jc.ErrorIsNil)
isUpgrading, err = s.State.IsUpgrading()
c.Assert(err, jc.ErrorIsNil)
c.Assert(isUpgrading, jc.IsFalse)
}
func (s *bootstrapSuite) TestBootstrapGUISuccessRemote(c *gc.C) {
s.PatchValue(bootstrap.GUIFetchMetadata, func(stream string, sources ...simplestreams.DataSource) ([]*gui.Metadata, error) {
c.Assert(stream, gc.Equals, gui.ReleasedStream)
c.Assert(sources[0].Description(), gc.Equals, "gui simplestreams")
c.Assert(sources[0].RequireSigned(), jc.IsTrue)
return []*gui.Metadata{{
Version: version.MustParse("2.0.42"),
FullPath: "https://1.2.3.4/juju-gui-2.0.42.tar.bz2",
SHA256: "hash-2.0.42",
Size: 42,
}, {
Version: version.MustParse("2.0.47"),
FullPath: "https://1.2.3.4/juju-gui-2.0.47.tar.bz2",
SHA256: "hash-2.0.47",
Size: 47,
}}, nil
})
env := newEnviron("foo", useDefaultKeys, nil)
ctx := coretesting.Context(c)
err := bootstrap.Bootstrap(modelcmd.BootstrapContext(ctx), env, bootstrap.BootstrapParams{
GUIDataSourceBaseURL: "https://1.2.3.4/gui/sources",
})
c.Assert(err, jc.ErrorIsNil)
c.Assert(coretesting.Stderr(ctx), jc.Contains, "Preparing for Juju GUI 2.0.42 release installation\n")
// The most recent GUI release info has been stored.
c.Assert(env.instanceConfig.GUI.URL, gc.Equals, "https://1.2.3.4/juju-gui-2.0.42.tar.bz2")
c.Assert(env.instanceConfig.GUI.Version.String(), gc.Equals, "2.0.42")
c.Assert(env.instanceConfig.GUI.Size, gc.Equals, int64(42))
c.Assert(env.instanceConfig.GUI.SHA256, gc.Equals, "hash-2.0.42")
}
func (s *clientSuite) TestGUIArchives(c *gc.C) {
client := s.APIState.Client()
called := false
response := params.GUIArchiveResponse{
Versions: []params.GUIArchiveVersion{{
Version: version.MustParse("1.0.0"),
SHA256: "hash1",
Current: false,
}, {
Version: version.MustParse("2.0.0"),
SHA256: "hash2",
Current: true,
}},
}
// Set up a fake endpoint for tests.
defer fakeAPIEndpoint(c, client, "/gui-archive", "GET",
func(w http.ResponseWriter, req *http.Request) {
defer req.Body.Close()
called = true
sendJSONResponse(c, w, response)
},
).Close()
versions, err := client.GUIArchives()
c.Assert(err, jc.ErrorIsNil)
c.Assert(versions, jc.DeepEquals, response.Versions)
c.Assert(called, jc.IsTrue)
}
func (*interfaceSuite) TestHighVersion(c *gc.C) {
read, err := readInterfaces(version.MustParse("2.1.9"), parseJSON(c, interfacesResponse))
c.Assert(err, jc.ErrorIsNil)
c.Assert(read, gc.HasLen, 1)
_, err = readInterface(version.MustParse("2.1.9"), parseJSON(c, interfaceResponse))
c.Assert(err, jc.ErrorIsNil)
}
func (s *machineUpgraderSuite) TestWatchAPIVersion(c *gc.C) {
w, err := s.st.WatchAPIVersion(s.rawMachine.Tag().String())
c.Assert(err, jc.ErrorIsNil)
wc := watchertest.NewNotifyWatcherC(c, w, s.BackingState.StartSync)
defer wc.AssertStops()
// Initial event
wc.AssertOneChange()
// One change noticing the new version
vers := version.MustParse("10.20.34")
err = statetesting.SetAgentVersion(s.BackingState, vers)
c.Assert(err, jc.ErrorIsNil)
wc.AssertOneChange()
// Setting the version to the same value doesn't trigger a change
err = statetesting.SetAgentVersion(s.BackingState, vers)
c.Assert(err, jc.ErrorIsNil)
wc.AssertNoChange()
// Another change noticing another new version
vers = version.MustParse("10.20.35")
err = statetesting.SetAgentVersion(s.BackingState, vers)
c.Assert(err, jc.ErrorIsNil)
wc.AssertOneChange()
}
func stateUpgradeOperations() []upgrades.Operation {
steps := []upgrades.Operation{
&mockUpgradeOperation{
targetVersion: version.MustParse("1.11.0"),
steps: []upgrades.Step{
newUpgradeStep("state step 1 - 1.11.0", upgrades.Controller),
newUpgradeStep("state step 2 error", upgrades.Controller),
newUpgradeStep("state step 3 - 1.11.0", upgrades.Controller),
},
},
&mockUpgradeOperation{
targetVersion: version.MustParse("1.21.0"),
steps: []upgrades.Step{
newUpgradeStep("state step 1 - 1.21.0", upgrades.DatabaseMaster),
newUpgradeStep("state step 2 - 1.21.0", upgrades.Controller),
},
},
&mockUpgradeOperation{
targetVersion: version.MustParse("1.22.0"),
steps: []upgrades.Step{
newUpgradeStep("state step 1 - 1.22.0", upgrades.DatabaseMaster),
newUpgradeStep("state step 2 - 1.22.0", upgrades.Controller),
},
},
}
return steps
}
func (*interfaceSuite) TestLowVersion(c *gc.C) {
_, err := readInterfaces(version.MustParse("1.9.0"), parseJSON(c, interfacesResponse))
c.Assert(err, jc.Satisfies, IsUnsupportedVersionError)
c.Assert(err.Error(), gc.Equals, `no interface read func for version 1.9.0`)
_, err = readInterface(version.MustParse("1.9.0"), parseJSON(c, interfaceResponse))
c.Assert(err, jc.Satisfies, IsUnsupportedVersionError)
c.Assert(err.Error(), gc.Equals, `no interface read func for version 1.9.0`)
}
func (s *UpgradeJujuSuite) TestBlockUpgradeJujuWithRealUpload(c *gc.C) {
s.Reset(c)
s.PatchValue(&jujuversion.Current, version.MustParse("1.99.99"))
cmd := newUpgradeJujuCommand(map[int]version.Number{2: version.MustParse("1.99.99")})
// Block operation
s.BlockAllChanges(c, "TestBlockUpgradeJujuWithRealUpload")
_, err := coretesting.RunCommand(c, cmd, "--build-agent")
coretesting.AssertOperationWasBlocked(c, err, ".*TestBlockUpgradeJujuWithRealUpload.*")
}
func (s *SimpleStreamsToolsSuite) TestPreferredStream(c *gc.C) {
for i, test := range preferredStreamTests {
c.Logf("\ntest %d", i)
s.PatchValue(&jujuversion.Current, version.MustParse(test.currentVers))
var vers *version.Number
if test.explicitVers != "" {
v := version.MustParse(test.explicitVers)
vers = &v
}
obtained := envtools.PreferredStream(vers, test.forceDevel, test.streamInConfig)
c.Check(obtained, gc.Equals, test.expected)
}
}
func (s *UpgradeJujuSuite) TestUpgradeJujuWithRealUpload(c *gc.C) {
s.Reset(c)
s.PatchValue(&jujuversion.Current, version.MustParse("1.99.99"))
cmd := newUpgradeJujuCommand(map[int]version.Number{2: version.MustParse("1.99.99")})
_, err := coretesting.RunCommand(c, cmd, "--build-agent")
c.Assert(err, jc.ErrorIsNil)
vers := version.Binary{
Number: jujuversion.Current,
Arch: arch.HostArch(),
Series: series.HostSeries(),
}
vers.Build = 1
s.checkToolsUploaded(c, vers, vers.Number)
}
func (s *clientSuite) TestClientAgentVersion(c *gc.C) {
current := version.MustParse("1.2.0")
s.PatchValue(&jujuversion.Current, current)
result, err := s.APIState.Client().AgentVersion()
c.Assert(err, jc.ErrorIsNil)
c.Assert(result, gc.Equals, current)
}
func (s *toolsSuite) TestFindAvailableToolsSpecificVersion(c *gc.C) {
currentVersion := version.Binary{
Number: jujuversion.Current,
Arch: arch.HostArch(),
Series: series.HostSeries(),
}
currentVersion.Major = 2
currentVersion.Minor = 3
s.PatchValue(&jujuversion.Current, currentVersion.Number)
var findToolsCalled int
s.PatchValue(bootstrap.FindTools, func(_ environs.Environ, major, minor int, stream string, f tools.Filter) (tools.List, error) {
c.Assert(f.Number.Major, gc.Equals, 10)
c.Assert(f.Number.Minor, gc.Equals, 11)
c.Assert(f.Number.Patch, gc.Equals, 12)
c.Assert(stream, gc.Equals, "released")
findToolsCalled++
return []*tools.Tools{
&tools.Tools{
Version: currentVersion,
URL: "http://testing.invalid/tools.tar.gz",
},
}, nil
})
env := newEnviron("foo", useDefaultKeys, nil)
toolsVersion := version.MustParse("10.11.12")
result, err := bootstrap.FindAvailableTools(env, &toolsVersion, nil, nil, false)
c.Assert(err, jc.ErrorIsNil)
c.Assert(findToolsCalled, gc.Equals, 1)
c.Assert(result, jc.DeepEquals, tools.List{
&tools.Tools{
Version: currentVersion,
URL: "http://testing.invalid/tools.tar.gz",
},
})
}
func (s *BootstrapSuite) TestAutoSyncLocalSource(c *gc.C) {
sourceDir := createToolsSource(c, vAll)
s.PatchValue(&jujuversion.Current, version.MustParse("1.2.0"))
series.SetLatestLtsForTesting("trusty")
resetJujuXDGDataHome(c)
// Bootstrap the controller with the valid source.
// The bootstrapping has to show no error, because the tools
// are automatically synchronized.
_, err := coretesting.RunCommand(
c, s.newBootstrapCommand(), "--metadata-source", sourceDir,
"devcontroller", "dummy-cloud/region-1",
)
c.Assert(err, jc.ErrorIsNil)
p, err := environs.Provider("dummy")
c.Assert(err, jc.ErrorIsNil)
cfg, err := modelcmd.NewGetBootstrapConfigFunc(s.store)("devcontroller")
c.Assert(err, jc.ErrorIsNil)
env, err := p.PrepareForBootstrap(envtesting.BootstrapContext(c), cfg)
c.Assert(err, jc.ErrorIsNil)
// Now check the available tools which are the 1.2.0 envtools.
checkTools(c, env, v120All)
}
func (s *upgradeSuite) TestStateStepsNotAttemptedWhenNoStateTarget(c *gc.C) {
stateCount := 0
stateUpgradeOperations := func() []upgrades.Operation {
stateCount++
return nil
}
s.PatchValue(upgrades.StateUpgradeOperations, stateUpgradeOperations)
apiCount := 0
upgradeOperations := func() []upgrades.Operation {
apiCount++
return nil
}
s.PatchValue(upgrades.UpgradeOperations, upgradeOperations)
fromVers := version.MustParse("1.18.0")
ctx := new(mockContext)
check := func(target upgrades.Target, expectedStateCallCount int) {
stateCount = 0
apiCount = 0
err := upgrades.PerformUpgrade(fromVers, targets(target), ctx)
c.Assert(err, jc.ErrorIsNil)
c.Assert(stateCount, gc.Equals, expectedStateCallCount)
c.Assert(apiCount, gc.Equals, 1)
}
check(upgrades.Controller, 1)
check(upgrades.DatabaseMaster, 1)
check(upgrades.AllMachines, 0)
check(upgrades.HostMachine, 0)
}
func (s *TargetPrecheckSuite) TestVersionLessThanSource(c *gc.C) {
backend := newFakeBackend()
s.modelInfo.AgentVersion = version.MustParse("1.2.4")
err := migration.TargetPrecheck(backend, s.modelInfo)
c.Assert(err.Error(), gc.Equals,
`model has higher version than target controller (1.2.4 > 1.2.3)`)
}
func (s *clientSuite) TestUploadGUIArchive(c *gc.C) {
client := s.APIState.Client()
called := false
archive := []byte("archive content")
hash, size, vers := "archive-hash", int64(len(archive)), version.MustParse("2.1.0")
// Set up a fake endpoint for tests.
defer fakeAPIEndpoint(c, client, "/gui-archive", "POST",
func(w http.ResponseWriter, req *http.Request) {
defer req.Body.Close()
called = true
err := req.ParseForm()
c.Assert(err, jc.ErrorIsNil)
// Check version and content length.
c.Assert(req.Form.Get("version"), gc.Equals, vers.String())
c.Assert(req.ContentLength, gc.Equals, size)
// Check request body.
obtainedArchive, err := ioutil.ReadAll(req.Body)
c.Assert(err, jc.ErrorIsNil)
c.Assert(obtainedArchive, gc.DeepEquals, archive)
// Check hash.
h := req.Form.Get("hash")
c.Assert(h, gc.Equals, hash)
// Send the response.
sendJSONResponse(c, w, params.GUIArchiveVersion{
Current: true,
})
},
).Close()
current, err := client.UploadGUIArchive(bytes.NewReader(archive), hash, size, vers)
c.Assert(err, jc.ErrorIsNil)
c.Assert(current, jc.IsTrue)
c.Assert(called, jc.IsTrue)
}
func (s *Suite) TestUploadGUIArchive(c *gc.C) {
archive := []byte("archive content")
hash, size, vers := "archive-hash", int64(len(archive)), version.MustParse("2.1.0")
withHTTPClient(c, "/gui-archive", "POST", func(w http.ResponseWriter, req *http.Request) {
defer req.Body.Close()
err := req.ParseForm()
c.Assert(err, jc.ErrorIsNil)
// Check version and content length.
c.Assert(req.Form.Get("version"), gc.Equals, vers.String())
c.Assert(req.ContentLength, gc.Equals, size)
// Check request body.
obtainedArchive, err := ioutil.ReadAll(req.Body)
c.Assert(err, jc.ErrorIsNil)
c.Assert(obtainedArchive, gc.DeepEquals, archive)
// Check hash.
h := req.Form.Get("hash")
c.Assert(h, gc.Equals, hash)
// Send the response.
sendJSONResponse(c, w, params.GUIArchiveVersion{
Current: true,
})
}, func(client *controller.Client) {
// Upload a new Juju GUI archive.
current, err := client.UploadGUIArchive(bytes.NewReader(archive), hash, size, vers)
c.Assert(err, jc.ErrorIsNil)
c.Assert(current, jc.IsTrue)
})
}
func (s *syncSuite) setUpTest(c *gc.C) {
if runtime.GOOS == "windows" {
c.Skip("issue 1403084: Currently does not work because of jujud problems")
}
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
s.ToolsFixture.SetUpTest(c)
// It's important that this be v1.8.x to match the test data.
s.PatchValue(&jujuversion.Current, version.MustParse("1.8.3"))
// Create a source storage.
baseDir := c.MkDir()
stor, err := filestorage.NewFileStorageWriter(baseDir)
c.Assert(err, jc.ErrorIsNil)
s.storage = stor
// Create a local tools directory.
s.localStorage = c.MkDir()
// Populate both local and default tools locations with the public tools.
versionStrings := make([]string, len(vAll))
for i, vers := range vAll {
versionStrings[i] = vers.String()
}
toolstesting.MakeTools(c, baseDir, "released", versionStrings)
toolstesting.MakeTools(c, s.localStorage, "released", versionStrings)
// Switch the default tools location.
baseURL, err := s.storage.URL(storage.BaseToolsPath)
c.Assert(err, jc.ErrorIsNil)
s.PatchValue(&envtools.DefaultBaseURL, baseURL)
}
func (s *serverSuite) assertSetEnvironAgentVersionBlocked(c *gc.C, msg string) {
args := params.SetModelAgentVersion{
Version: version.MustParse("9.8.7"),
}
err := s.client.SetModelAgentVersion(args)
s.AssertBlocked(c, err, msg)
}
func (s *guiArchiveSuite) TestGUIArchivePostCurrent(c *gc.C) {
// Add an existing GUI archive and set it as the current one.
storage, err := s.State.GUIStorage()
c.Assert(err, jc.ErrorIsNil)
defer storage.Close()
vers := version.MustParse("2.0.47")
setupGUIArchive(c, storage, vers.String(), nil)
err = s.State.GUISetVersion(vers)
c.Assert(err, jc.ErrorIsNil)
// Create a GUI archive to be uploaded.
r, hash, _ := makeGUIArchive(c, vers.String(), map[string]string{"filename": "content"})
// Prepare and send the request to upload a new GUI archive.
v := url.Values{}
v.Set("version", vers.String())
v.Set("hash", hash)
resp := s.authRequest(c, httpRequestParams{
method: "POST",
url: s.guiURL(c) + "?" + v.Encode(),
contentType: apiserver.BZMimeType,
body: r,
})
// Check that the response reflects a successful upload.
body := assertResponse(c, resp, http.StatusOK, params.ContentTypeJSON)
var jsonResponse params.GUIArchiveVersion
err = json.Unmarshal(body, &jsonResponse)
c.Assert(err, jc.ErrorIsNil, gc.Commentf("body: %s", body))
c.Assert(jsonResponse, jc.DeepEquals, params.GUIArchiveVersion{
Version: vers,
SHA256: hash,
Current: true,
})
}
func (s *guiSuite) TestGUIDirectory(c *gc.C) {
storage, err := s.State.GUIStorage()
c.Assert(err, jc.ErrorIsNil)
defer storage.Close()
// Create a Juju GUI archive and save it into the storage.
indexContent := "<!DOCTYPE html><html><body>Exterminate!</body></html>"
vers := version.MustParse("2.0.0")
hash := setupGUIArchive(c, storage, vers.String(), map[string]string{
guiIndexPath: indexContent,
apiserver.SpritePath: "",
})
err = s.State.GUISetVersion(vers)
c.Assert(err, jc.ErrorIsNil)
// Initially the GUI directory on the server is empty.
baseDir := agenttools.SharedGUIDir(s.DataDir())
c.Assert(baseDir, jc.DoesNotExist)
// Make a request for the Juju GUI.
resp := s.sendRequest(c, httpRequestParams{
url: s.guiURL(c, "", "/"),
})
body := assertResponse(c, resp, http.StatusOK, "text/html; charset=utf-8")
c.Assert(string(body), gc.Equals, indexContent)
// Now the GUI is stored on disk, in a directory corresponding to its
// archive SHA256 hash.
indexPath := filepath.Join(baseDir, hash, guiIndexPath)
c.Assert(indexPath, jc.IsNonEmptyFile)
b, err := ioutil.ReadFile(indexPath)
c.Assert(err, jc.ErrorIsNil)
c.Assert(string(b), gc.Equals, indexContent)
}
func (s *simplestreamsSuite) TestFetchMetadata(c *gc.C) {
for i, test := range fetchMetadataTests {
c.Logf("\ntest %d: %s", i, test.about)
// Patch the current Juju version.
jujuVersion := version.MustParse(test.jujuVersion)
s.PatchValue(&jujuversion.Current, jujuVersion)
// Add invalid datasource and check later that resolveInfo is correct.
invalidSource := simplestreams.NewURLDataSource(
"invalid", "file://invalid", utils.VerifySSLHostnames, simplestreams.DEFAULT_CLOUD_DATA, s.RequireSigned)
// Fetch the Juju GUI archives.
allMeta, err := gui.FetchMetadata(test.stream, invalidSource, s.Source)
for i, meta := range allMeta {
c.Logf("metadata %d:\n%#v", i, meta)
}
if test.expectedError != "" {
c.Assert(err, gc.ErrorMatches, test.expectedError)
c.Assert(allMeta, gc.IsNil)
continue
}
// Populate the expected metadata with missing fields.
for _, meta := range test.expectedMetadata {
meta.JujuMajorVersion = jujuVersion.Major
meta.FullPath = "test:/" + meta.Path
meta.Source = s.Source
meta.StringVersion = meta.Version.String()
}
c.Assert(err, jc.ErrorIsNil)
c.Assert(allMeta, jc.DeepEquals, test.expectedMetadata)
}
}
func (s *UpgradeJujuSuite) TestUpgradeDryRun(c *gc.C) {
tests := []DryRunTest{
{
about: "dry run outputs and doesn't change anything when uploading tools",
cmdArgs: []string{"--build-agent", "--dry-run"},
tools: []string{"2.1.0-quantal-amd64", "2.1.2-quantal-i386", "2.1.3-quantal-amd64", "2.1-dev1-quantal-amd64", "2.2.3-quantal-amd64"},
currentVersion: "2.1.3-quantal-amd64",
agentVersion: "2.0.0",
expectedCmdOutput: `upgrade to this version by running
juju upgrade-juju --agent-version="2.1.3"
`,
},
{
about: "dry run outputs and doesn't change anything",
cmdArgs: []string{"--dry-run"},
tools: []string{"2.1.0-quantal-amd64", "2.1.2-quantal-i386", "2.1.3-quantal-amd64", "2.1-dev1-quantal-amd64", "2.2.3-quantal-amd64"},
currentVersion: "2.0.0-quantal-amd64",
agentVersion: "2.0.0",
expectedCmdOutput: `upgrade to this version by running
juju upgrade-juju --agent-version="2.1.3"
`,
},
{
about: "dry run ignores unknown series",
cmdArgs: []string{"--dry-run"},
tools: []string{"2.1.0-quantal-amd64", "2.1.2-quantal-i386", "2.1.3-quantal-amd64", "1.2.3-myawesomeseries-amd64"},
currentVersion: "2.0.0-quantal-amd64",
agentVersion: "2.0.0",
expectedCmdOutput: `upgrade to this version by running
juju upgrade-juju --agent-version="2.1.3"
`,
},
}
for i, test := range tests {
c.Logf("\ntest %d: %s", i, test.about)
s.Reset(c)
tools.DefaultBaseURL = ""
s.setUpEnvAndTools(c, test.currentVersion, test.agentVersion, test.tools)
com := newUpgradeJujuCommand(nil)
err := coretesting.InitCommand(com, test.cmdArgs)
c.Assert(err, jc.ErrorIsNil)
ctx := coretesting.Context(c)
err = com.Run(ctx)
c.Assert(err, jc.ErrorIsNil)
// Check agent version doesn't change
cfg, err := s.State.ModelConfig()
c.Assert(err, jc.ErrorIsNil)
agentVer, ok := cfg.AgentVersion()
c.Assert(ok, jc.IsTrue)
c.Assert(agentVer, gc.Equals, version.MustParse(test.agentVersion))
output := coretesting.Stderr(ctx)
c.Assert(output, gc.Equals, test.expectedCmdOutput)
}
}
func (s *bootstrapSuite) TestBootstrapSpecificVersionClientMajorMismatch(c *gc.C) {
// bootstrap using a specified version only works if the patch number is different.
// The bootstrap client major and minor versions need to match the tools asked for.
toolsVersion := version.MustParse("10.11.12")
err, bootstrapCount, _ := s.setupBootstrapSpecificVersion(c, 1, 11, &toolsVersion)
c.Assert(strings.Replace(err.Error(), "\n", "", -1), gc.Matches, ".* no tools are available .*")
c.Assert(bootstrapCount, gc.Equals, 0)
}
func (s *productSpecSuite) TestIndexIdNoStream(c *gc.C) {
toolsConstraint := tools.NewVersionedToolsConstraint(version.MustParse("1.13.0"), simplestreams.LookupParams{
Series: []string{"precise"},
Arches: []string{"amd64"},
})
ids := toolsConstraint.IndexIds()
c.Assert(ids, gc.HasLen, 0)
}
func (s *Suite) TestModelInfo(c *gc.C) {
api := s.mustMakeAPI(c)
model, err := api.ModelInfo()
c.Assert(err, jc.ErrorIsNil)
c.Assert(model.UUID, gc.Equals, "model-uuid")
c.Assert(model.Name, gc.Equals, "model-name")
c.Assert(model.OwnerTag, gc.Equals, names.NewUserTag("owner").String())
c.Assert(model.AgentVersion, gc.Equals, version.MustParse("1.2.3"))
}
func (s *productSpecSuite) TestProductId(c *gc.C) {
toolsConstraint := tools.NewVersionedToolsConstraint(version.MustParse("1.13.0"), simplestreams.LookupParams{
Series: []string{"precise"},
Arches: []string{"amd64"},
})
ids, err := toolsConstraint.ProductIds()
c.Assert(err, jc.ErrorIsNil)
c.Assert(ids, gc.DeepEquals, []string{"com.ubuntu.juju:12.04:amd64"})
}