func (suite *environSuite) TestAcquireNodePassedAgentName(c *gc.C) {
stor := NewStorage(suite.makeEnviron())
fakeTools := envtesting.MustUploadFakeToolsVersions(stor, version.Current)[0]
env := suite.makeEnviron()
suite.testMAASObject.TestServer.NewNode(`{"system_id": "node0", "hostname": "host0"}`)
_, _, err := env.acquireNode("", constraints.Value{}, nil, nil, tools.List{fakeTools})
c.Check(err, gc.IsNil)
requestValues := suite.testMAASObject.TestServer.NodeOperationRequestValues()
nodeRequestValues, found := requestValues["node0"]
c.Assert(found, gc.Equals, true)
c.Assert(nodeRequestValues[0].Get("agent_name"), gc.Equals, exampleAgentName)
}
func (suite *environSuite) TestAcquireNodeTakesConstraintsIntoAccount(c *gc.C) {
stor := NewStorage(suite.makeEnviron())
fakeTools := envtesting.MustUploadFakeToolsVersions(stor, version.Current)[0]
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, nil, nil, tools.List{fakeTools})
c.Check(err, gc.IsNil)
requestValues := suite.testMAASObject.TestServer.NodeOperationRequestValues()
nodeRequestValues, found := requestValues["node0"]
c.Assert(found, gc.Equals, true)
c.Assert(nodeRequestValues[0].Get("arch"), gc.Equals, "arm")
c.Assert(nodeRequestValues[0].Get("mem"), gc.Equals, "1024")
}
func (suite *environSuite) TestAcquireNodeByName(c *gc.C) {
stor := NewStorage(suite.makeEnviron())
fakeTools := envtesting.MustUploadFakeToolsVersions(stor, version.Current)[0]
env := suite.makeEnviron()
suite.testMAASObject.TestServer.NewNode(`{"system_id": "node0", "hostname": "host0"}`)
_, _, err := env.acquireNode("host0", constraints.Value{}, nil, nil, tools.List{fakeTools})
c.Check(err, gc.IsNil)
operations := suite.testMAASObject.TestServer.NodeOperations()
actions, found := operations["node0"]
c.Assert(found, gc.Equals, true)
c.Check(actions, gc.DeepEquals, []string{"acquire"})
// no "name" parameter should have been passed through
values := suite.testMAASObject.TestServer.NodeOperationRequestValues()["node0"][0]
nodeName := values.Get("name")
c.Assert(nodeName, gc.Equals, "host0")
}
func (s *JujuConnSuite) setUpConn(c *gc.C) {
if s.RootDir != "" {
panic("JujuConnSuite.setUpConn without teardown")
}
s.RootDir = c.MkDir()
s.oldHome = osenv.Home()
home := filepath.Join(s.RootDir, "/home/ubuntu")
err := os.MkdirAll(home, 0777)
c.Assert(err, gc.IsNil)
osenv.SetHome(home)
s.oldJujuHome = osenv.SetJujuHome(filepath.Join(home, ".juju"))
err = os.Mkdir(osenv.JujuHome(), 0777)
c.Assert(err, gc.IsNil)
err = os.MkdirAll(s.DataDir(), 0777)
c.Assert(err, gc.IsNil)
s.PatchEnvironment(osenv.JujuEnvEnvKey, "")
// TODO(rog) remove these files and add them only when
// the tests specifically need them (in cmd/juju for example)
s.writeSampleConfig(c, osenv.JujuHomePath("environments.yaml"))
err = ioutil.WriteFile(osenv.JujuHomePath("dummyenv-cert.pem"), []byte(testing.CACert), 0666)
c.Assert(err, gc.IsNil)
err = ioutil.WriteFile(osenv.JujuHomePath("dummyenv-private-key.pem"), []byte(testing.CAKey), 0600)
c.Assert(err, gc.IsNil)
store, err := configstore.Default()
c.Assert(err, gc.IsNil)
s.ConfigStore = store
ctx := testing.Context(c)
environ, err := environs.PrepareFromName("dummyenv", ctx, s.ConfigStore)
c.Assert(err, gc.IsNil)
// sanity check we've got the correct environment.
c.Assert(environ.Name(), gc.Equals, "dummyenv")
s.PatchValue(&dummy.DataDir, s.DataDir())
s.LogDir = c.MkDir()
s.PatchValue(&dummy.LogDir, s.LogDir)
versions := PreferredDefaultVersions(environ.Config(), version.Binary{Number: version.Current.Number, Series: "precise", Arch: "amd64"})
versions = append(versions, version.Current)
// Upload tools for both preferred and fake default series
envtesting.MustUploadFakeToolsVersions(environ.Storage(), versions...)
c.Assert(bootstrap.Bootstrap(ctx, environ, environs.BootstrapParams{}), gc.IsNil)
s.BackingState = environ.(GetStater).GetStateInAPIServer()
conn, err := juju.NewConn(environ)
c.Assert(err, gc.IsNil)
s.Conn = conn
s.State = conn.State
apiConn, err := juju.NewAPIConn(environ, api.DialOpts{})
c.Assert(err, gc.IsNil)
s.APIConn = apiConn
s.APIState = apiConn.State
s.environ = environ
}
func (s *UpgradeJujuSuite) TestUpgradeJuju(c *gc.C) {
s.PatchValue(&sync.BuildToolsTarball, s.getMockBuildTools(c))
oldVersion := version.Current
defer func() {
version.Current = oldVersion
}()
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, gc.ErrorMatches, test.expectInitErr)
} else {
c.Check(err, gc.IsNil)
}
continue
}
// Set up state and environ, and run the command.
toolsDir := c.MkDir()
updateAttrs := map[string]interface{}{
"agent-version": test.agentVersion,
"tools-metadata-url": "file://" + toolsDir,
}
err := s.State.UpdateEnvironConfig(updateAttrs, nil, nil)
c.Assert(err, gc.IsNil)
versions := make([]version.Binary, len(test.tools))
for i, v := range test.tools {
versions[i] = version.MustParseBinary(v)
}
if len(versions) > 0 {
envtesting.MustUploadFakeToolsVersions(s.Conn.Environ.Storage(), versions...)
stor, err := filestorage.NewFileStorageWriter(toolsDir)
c.Assert(err, gc.IsNil)
envtesting.MustUploadFakeToolsVersions(stor, versions...)
}
err = com.Run(coretesting.Context(c))
if test.expectErr != "" {
c.Check(err, gc.ErrorMatches, test.expectErr)
continue
} else if !c.Check(err, gc.IsNil) {
continue
}
// Check expected changes to environ/state.
cfg, err := s.State.EnvironConfig()
c.Check(err, gc.IsNil)
agentVersion, ok := cfg.AgentVersion()
c.Check(ok, gc.Equals, true)
c.Check(agentVersion, gc.Equals, version.MustParse(test.expectVersion))
for _, uploaded := range test.expectUploaded {
// Substitute latest LTS for placeholder in expected series for uploaded tools
uploaded = strings.Replace(uploaded, "%LTS%", config.LatestLtsSeries(), 1)
vers := version.MustParseBinary(uploaded)
r, err := storage.Get(s.Conn.Environ.Storage(), envtools.StorageName(vers))
if !c.Check(err, gc.IsNil) {
continue
}
data, err := ioutil.ReadAll(r)
r.Close()
c.Check(err, gc.IsNil)
expectContent := version.Current
expectContent.Number = agentVersion
checkToolsContent(c, data, "jujud contents "+expectContent.String())
}
}
}
