func (s *toolsSuite) TestFindAvailableToolsCompleteNoValidate(c *gc.C) {
s.PatchValue(&arch.HostArch, func() string {
return "amd64"
})
s.PatchValue(&version.Current.Arch, "amd64")
var allTools tools.List
for _, series := range version.SupportedSeries() {
binary := version.Current
binary.Series = series
allTools = append(allTools, &tools.Tools{
Version: binary,
URL: "http://testing.invalid/tools.tar.gz",
})
}
s.PatchValue(bootstrap.FindTools, func(_ environs.ConfigGetter, major, minor int, f tools.Filter, retry bool) (tools.List, error) {
return allTools, nil
})
env := newEnviron("foo", useDefaultKeys, nil)
availableTools, err := bootstrap.FindAvailableTools(env, nil, false)
c.Assert(err, gc.IsNil)
c.Assert(availableTools, gc.HasLen, len(allTools))
c.Assert(env.supportedArchitecturesCount, gc.Equals, 0)
}
func (s *toolsSuite) TestFindAvailableToolsCompleteNoValidate(c *gc.C) {
s.PatchValue(&arch.HostArch, func() string { return arch.AMD64 })
var allTools tools.List
for _, series := range series.SupportedSeries() {
binary := version.Binary{
Number: version.Current,
Series: series,
Arch: arch.HostArch(),
}
allTools = append(allTools, &tools.Tools{
Version: binary,
URL: "http://testing.invalid/tools.tar.gz",
})
}
s.PatchValue(bootstrap.FindTools, func(_ environs.Environ, major, minor int, stream string, f tools.Filter) (tools.List, error) {
return allTools, nil
})
env := newEnviron("foo", useDefaultKeys, nil)
availableTools, err := bootstrap.FindAvailableTools(env, nil, nil, nil, false)
c.Assert(err, jc.ErrorIsNil)
c.Assert(availableTools, gc.HasLen, len(allTools))
c.Assert(env.supportedArchitecturesCount, gc.Equals, 0)
}
func (s *toolsSuite) TestFindAvailableToolsAutoUpload(c *gc.C) {
s.PatchValue(&arch.HostArch, func() string {
return "amd64"
})
s.PatchValue(&version.Current.Arch, "amd64")
trustyTools := &tools.Tools{
Version: version.MustParseBinary("1.2.3-trusty-amd64"),
URL: "http://testing.invalid/tools.tar.gz",
}
s.PatchValue(bootstrap.FindTools, func(_ environs.ConfigGetter, major, minor int, f tools.Filter, retry bool) (tools.List, error) {
return tools.List{trustyTools}, nil
})
env := newEnviron("foo", useDefaultKeys, nil)
availableTools, err := bootstrap.FindAvailableTools(env, nil, false)
c.Assert(err, gc.IsNil)
c.Assert(len(availableTools), jc.GreaterThan, 1)
c.Assert(env.supportedArchitecturesCount, gc.Equals, 1)
var trustyToolsFound int
expectedVersion := version.Current.Number
expectedVersion.Build++
for _, tools := range availableTools {
if tools == trustyTools {
trustyToolsFound++
} else {
c.Assert(tools.Version.Number, gc.Equals, expectedVersion)
c.Assert(tools.Version.Series, gc.Not(gc.Equals), "trusty")
c.Assert(tools.URL, gc.Equals, "")
}
}
c.Assert(trustyToolsFound, gc.Equals, 1)
}
func (s *toolsSuite) TestFindAvailableToolsSpecificVersion(c *gc.C) {
currentVersion := version.Binary{
Number: version.Current,
Arch: arch.HostArch(),
Series: series.HostSeries(),
}
currentVersion.Major = 2
currentVersion.Minor = 3
s.PatchValue(&version.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 *toolsSuite) TestFindAvailableToolsError(c *gc.C) {
s.PatchValue(bootstrap.FindTools, func(_ environs.ConfigGetter, major, minor int, f tools.Filter, retry bool) (tools.List, error) {
return nil, errors.New("splat")
})
env := newEnviron("foo", useDefaultKeys, nil)
_, err := bootstrap.FindAvailableTools(env, nil, false)
c.Assert(err, gc.ErrorMatches, "splat")
}
func (s *toolsSuite) TestFindAvailableToolsNoUpload(c *gc.C) {
s.PatchValue(bootstrap.FindTools, func(_ environs.ConfigGetter, major, minor int, f tools.Filter, retry bool) (tools.List, error) {
return nil, errors.NotFoundf("tools")
})
env := newEnviron("foo", useDefaultKeys, map[string]interface{}{
"agent-version": "1.17.1",
})
_, err := bootstrap.FindAvailableTools(env, nil, false)
c.Assert(err, jc.Satisfies, errors.IsNotFound)
}
func (s *toolsSuite) TestFindAvailableToolsForceUploadInvalidArch(c *gc.C) {
s.PatchValue(&arch.HostArch, func() string {
return arch.I386
})
var findToolsCalled int
s.PatchValue(bootstrap.FindTools, func(_ environs.ConfigGetter, major, minor int, f tools.Filter, retry bool) (tools.List, error) {
findToolsCalled++
return nil, errors.NotFoundf("tools")
})
env := newEnviron("foo", useDefaultKeys, nil)
_, err := bootstrap.FindAvailableTools(env, nil, true)
c.Assert(err, gc.ErrorMatches, `environment "foo" of type dummy does not support instances running on "i386"`)
c.Assert(findToolsCalled, gc.Equals, 0)
}
func (s *toolsSuite) TestFindAvailableToolsForceUpload(c *gc.C) {
s.PatchValue(&arch.HostArch, func() string { return arch.AMD64 })
var findToolsCalled int
s.PatchValue(bootstrap.FindTools, func(_ environs.Environ, major, minor int, stream string, f tools.Filter) (tools.List, error) {
findToolsCalled++
return nil, errors.NotFoundf("tools")
})
env := newEnviron("foo", useDefaultKeys, nil)
uploadedTools, err := bootstrap.FindAvailableTools(env, nil, nil, nil, true)
c.Assert(err, jc.ErrorIsNil)
c.Assert(uploadedTools, gc.Not(gc.HasLen), 0)
c.Assert(findToolsCalled, gc.Equals, 0)
expectedVersion := version.Current
expectedVersion.Build++
for _, tools := range uploadedTools {
c.Assert(tools.Version.Number, gc.Equals, expectedVersion)
c.Assert(tools.URL, gc.Equals, "")
}
}