// mockUploadTools simulates the effect of tools.Upload, but skips the time-
// consuming build from source.
// TODO(fwereade) better factor environs/tools such that build logic is
// exposed and can itself be neatly mocked?
func mockUploadTools(putter tools.URLPutter, forceVersion *version.Number, series ...string) (*state.Tools, error) {
storage := putter.(environs.Storage)
vers := version.Current
if forceVersion != nil {
vers.Number = *forceVersion
}
t := envtesting.MustUploadFakeToolsVersion(storage, vers)
for _, series := range series {
if series != version.Current.Series {
vers.Series = series
envtesting.MustUploadFakeToolsVersion(storage, vers)
}
}
return t, nil
}
func (suite *EnvironSuite) TestAcquireNode(c *C) {
storage := NewStorage(suite.environ)
fakeTools := envtesting.MustUploadFakeToolsVersion(storage, version.Current)
env := suite.makeEnviron()
suite.testMAASObject.TestServer.NewNode(`{"system_id": "node0", "hostname": "host0"}`)
_, _, err := env.acquireNode(constraints.Value{}, tools.List{fakeTools})
c.Check(err, IsNil)
operations := suite.testMAASObject.TestServer.NodeOperations()
actions, found := operations["node0"]
c.Assert(found, Equals, true)
c.Check(actions, DeepEquals, []string{"acquire"})
}
func (suite *EnvironSuite) TestAcquireNodeTakesConstraintsIntoAccount(c *C) {
storage := NewStorage(suite.environ)
fakeTools := envtesting.MustUploadFakeToolsVersion(storage, version.Current)
env := suite.makeEnviron()
suite.testMAASObject.TestServer.NewNode(`{"system_id": "node0", "hostname": "host0"}`)
constraints := constraints.Value{Arch: stringp("arm"), Mem: uint64p(1024)}
_, _, err := env.acquireNode(constraints, tools.List{fakeTools})
c.Check(err, IsNil)
requestValues := suite.testMAASObject.TestServer.NodeOperationRequestValues()
nodeRequestValues, found := requestValues["node0"]
c.Assert(found, Equals, true)
c.Assert(nodeRequestValues[0].Get("arch"), Equals, "arm")
c.Assert(nodeRequestValues[0].Get("mem"), Equals, "1024")
}
func (s *UpgradeJujuSuite) TestUpgradeJuju(c *C) {
oldVersion := version.Current
uploadTools = mockUploadTools
defer func() {
version.Current = oldVersion
uploadTools = tools.Upload
}()
for i, test := range upgradeJujuTests {
c.Logf("\ntest %d: %s", i, test.about)
s.Reset(c)
// Set up apparent CLI version and initialize the command.
version.Current = version.MustParseBinary(test.currentVersion)
com := &UpgradeJujuCommand{}
if err := coretesting.InitCommand(com, test.args); err != nil {
if test.expectInitErr != "" {
c.Check(err, ErrorMatches, test.expectInitErr)
} else {
c.Check(err, IsNil)
}
continue
}
// Set up state and environ, and run the command.
cfg, err := s.State.EnvironConfig()
c.Assert(err, IsNil)
cfg, err = cfg.Apply(map[string]interface{}{
"agent-version": test.agentVersion,
"development": test.development,
})
c.Assert(err, IsNil)
err = s.State.SetEnvironConfig(cfg)
c.Assert(err, IsNil)
for _, v := range test.private {
vers := version.MustParseBinary(v)
envtesting.MustUploadFakeToolsVersion(s.Conn.Environ.Storage(), vers)
}
for _, v := range test.public {
vers := version.MustParseBinary(v)
storage := s.Conn.Environ.PublicStorage().(environs.Storage)
envtesting.MustUploadFakeToolsVersion(storage, vers)
}
err = com.Run(coretesting.Context(c))
if test.expectErr != "" {
c.Check(err, ErrorMatches, test.expectErr)
continue
} else if !c.Check(err, IsNil) {
continue
}
// Check expected changes to environ/state.
cfg, err = s.State.EnvironConfig()
c.Check(err, IsNil)
agentVersion, ok := cfg.AgentVersion()
c.Check(ok, Equals, true)
c.Check(agentVersion, Equals, version.MustParse(test.expectVersion))
c.Check(cfg.Development(), Equals, test.development)
for _, uploaded := range test.expectUploaded {
vers := version.MustParseBinary(uploaded)
r, err := s.Conn.Environ.Storage().Get(tools.StorageName(vers))
if !c.Check(err, IsNil) {
continue
}
data, err := ioutil.ReadAll(r)
r.Close()
c.Check(err, IsNil)
c.Check(string(data), Equals, uploaded)
}
}
}