func (s *provisionerSuite) testFindTools(c *gc.C, matchArch bool, apiError, logicError error) {
current := version.Binary{
Number: jujuversion.Current,
Arch: arch.HostArch(),
Series: series.HostSeries(),
}
var toolsList = coretools.List{&coretools.Tools{Version: current}}
var called bool
var a string
if matchArch {
// if matchArch is true, this will be overwriten with the host's arch, otherwise
// leave a blank.
a = arch.HostArch()
}
provisioner.PatchFacadeCall(s, s.provisioner, func(request string, args, response interface{}) error {
called = true
c.Assert(request, gc.Equals, "FindTools")
expected := params.FindToolsParams{
Number: jujuversion.Current,
Series: series.HostSeries(),
Arch: a,
MinorVersion: -1,
MajorVersion: -1,
}
c.Assert(args, gc.Equals, expected)
result := response.(*params.FindToolsResult)
result.List = toolsList
if logicError != nil {
result.Error = common.ServerError(logicError)
}
return apiError
})
apiList, err := s.provisioner.FindTools(jujuversion.Current, series.HostSeries(), a)
c.Assert(called, jc.IsTrue)
if apiError != nil {
c.Assert(err, gc.Equals, apiError)
} else if logicError != nil {
c.Assert(err.Error(), gc.Equals, logicError.Error())
} else {
c.Assert(err, jc.ErrorIsNil)
c.Assert(apiList, jc.SameContents, toolsList)
}
}
func (s *provisionerSuite) testFindTools(c *gc.C, matchArch bool, apiError, logicError error) {
var toolsList = coretools.List{&coretools.Tools{Version: version.Current}}
var called bool
provisioner.PatchFacadeCall(s, s.provisioner, func(request string, args, response interface{}) error {
called = true
c.Assert(request, gc.Equals, "FindTools")
expected := params.FindToolsParams{
Number: version.Current.Number,
Series: version.Current.Series,
MinorVersion: -1,
MajorVersion: -1,
}
if matchArch {
expected.Arch = arch.HostArch()
}
c.Assert(args, gc.Equals, expected)
result := response.(*params.FindToolsResult)
result.List = toolsList
if logicError != nil {
result.Error = common.ServerError(logicError)
}
return apiError
})
var a *string
if matchArch {
arch := arch.HostArch()
a = &arch
}
apiList, err := s.provisioner.FindTools(version.Current.Number, version.Current.Series, a)
c.Assert(called, jc.IsTrue)
if apiError != nil {
c.Assert(err, gc.Equals, apiError)
} else if logicError != nil {
c.Assert(err.Error(), gc.Equals, logicError.Error())
} else {
c.Assert(err, jc.ErrorIsNil)
c.Assert(apiList, jc.SameContents, toolsList)
}
}
func (s *provisionerSuite) TestContainerManagerConfigLXCDefaultMTU(c *gc.C) {
var resultConfig = map[string]string{
"lxc-default-mtu": "9000",
}
var called bool
provisioner.PatchFacadeCall(s, s.provisioner, func(request string, args, response interface{}) error {
called = true
c.Assert(request, gc.Equals, "ContainerManagerConfig")
expected := params.ContainerManagerConfigParams{
Type: instance.LXC,
}
c.Assert(args, gc.Equals, expected)
result := response.(*params.ContainerManagerConfig)
result.ManagerConfig = resultConfig
return nil
})
args := params.ContainerManagerConfigParams{Type: instance.LXC}
result, err := s.provisioner.ContainerManagerConfig(args)
c.Assert(called, jc.IsTrue)
c.Assert(err, jc.ErrorIsNil)
c.Assert(result.ManagerConfig, jc.DeepEquals, resultConfig)
}
