// getBlockAPI returns a block api for listing blocks.
func getBlockAPI(c *envcmd.EnvCommandBase) (block.BlockListAPI, error) {
root, err := c.NewAPIRoot()
if err != nil {
return nil, err
}
return apiblock.NewClient(root), nil
}
// getBlockAPI returns a block api for block manipulation.
func getBlockAPI(c newAPIRoot) (*apiblock.Client, error) {
root, err := c.NewAPIRoot()
if err != nil {
return nil, err
}
return apiblock.NewClient(root), nil
}
func (s *blockMockSuite) TestSwitchBlockOff(c *gc.C) {
called := false
blockType := state.DestroyBlock.String()
apiCaller := basetesting.APICallerFunc(
func(objType string,
version int,
id, request string,
a, response interface{},
) error {
called = true
c.Check(objType, gc.Equals, "Block")
c.Check(id, gc.Equals, "")
c.Check(request, gc.Equals, "SwitchBlockOff")
args, ok := a.(params.BlockSwitchParams)
c.Assert(ok, jc.IsTrue)
// message is never sent, so this argument should
// always be empty string.
c.Assert(args.Message, gc.DeepEquals, "")
c.Assert(args.Type, gc.DeepEquals, blockType)
_, ok = response.(*params.ErrorResult)
c.Assert(ok, jc.IsTrue)
return nil
})
blockClient := block.NewClient(apiCaller)
err := blockClient.SwitchBlockOff(blockType)
c.Assert(called, jc.IsTrue)
c.Assert(err, gc.IsNil)
}
// getBlockAPI returns a block api for listing blocks.
func getBlockAPI(c *modelcmd.ModelCommandBase) (listBlocksAPI, error) {
root, err := c.NewAPIRoot()
if err != nil {
return nil, errors.Trace(err)
}
return block.NewClient(root), nil
}
func (s *blockMockSuite) TestSwitchBlockOn(c *gc.C) {
called := false
blockType := state.DestroyBlock.String()
msg := "for test switch block on"
apiCaller := basetesting.APICallerFunc(
func(objType string,
version int,
id, request string,
a, response interface{},
) error {
called = true
c.Check(objType, gc.Equals, "Block")
c.Check(id, gc.Equals, "")
c.Check(request, gc.Equals, "SwitchBlockOn")
args, ok := a.(params.BlockSwitchParams)
c.Assert(ok, jc.IsTrue)
c.Assert(args.Message, gc.DeepEquals, msg)
c.Assert(args.Type, gc.DeepEquals, blockType)
_, ok = response.(*params.ErrorResult)
c.Assert(ok, jc.IsTrue)
return nil
})
blockClient := block.NewClient(apiCaller)
err := blockClient.SwitchBlockOn(blockType, msg)
c.Assert(called, jc.IsTrue)
c.Assert(err, gc.IsNil)
}
func (s *blockSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
s.blockClient = block.NewClient(s.APIState)
c.Assert(s.blockClient, gc.NotNil)
s.AddCleanup(func(*gc.C) {
s.blockClient.ClientFacade.Close()
})
}
func (s *blockSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
conn, err := juju.NewAPIState(s.AdminUserTag(c), s.Environ, api.DialOpts{})
c.Assert(err, jc.ErrorIsNil)
s.AddCleanup(func(*gc.C) { conn.Close() })
s.ctx = &mockContext{
agentConfig: &mockAgentConfig{dataDir: s.DataDir()},
apiState: conn,
state: s.State,
}
s.blockClient = block.NewClient(conn)
}
func (s *blockMockSuite) TestSwitchBlockOnError(c *gc.C) {
called := false
errmsg := "test error"
apiCaller := basetesting.APICallerFunc(
func(objType string,
version int,
id, request string,
a, response interface{},
) error {
called = true
result, ok := response.(*params.ErrorResult)
c.Assert(ok, jc.IsTrue)
result.Error = common.ServerError(errors.New(errmsg))
return nil
})
blockClient := block.NewClient(apiCaller)
err := blockClient.SwitchBlockOn("", "")
c.Assert(called, jc.IsTrue)
c.Assert(errors.Cause(err), gc.ErrorMatches, errmsg)
}
func (s *blockMockSuite) TestList(c *gc.C) {
var called bool
one := params.BlockResult{
Result: params.Block{
Id: "-42",
Type: state.DestroyBlock.String(),
Message: "for test switch on",
Tag: "some valid tag, right?",
},
}
errmsg := "another test error"
two := params.BlockResult{
Error: common.ServerError(errors.New(errmsg)),
}
apiCaller := basetesting.APICallerFunc(
func(
objType string,
version int,
id, request string,
a, response interface{}) error {
called = true
c.Check(objType, gc.Equals, "Block")
c.Check(id, gc.Equals, "")
c.Check(request, gc.Equals, "List")
c.Assert(a, gc.IsNil)
result := response.(*params.BlockResults)
result.Results = []params.BlockResult{one, two}
return nil
})
blockClient := block.NewClient(apiCaller)
found, err := blockClient.List()
c.Assert(called, jc.IsTrue)
c.Assert(errors.Cause(err), gc.ErrorMatches, errmsg)
c.Assert(found, gc.HasLen, 1)
}
// NewBlockHelper creates a block switch used in testing
// to manage desired juju blocks.
func NewBlockHelper(st api.Connection) BlockHelper {
return BlockHelper{
blockClient: block.NewClient(st),
}
}
// NewBlockHelper creates a block switch used in testing
// to manage desired juju blocks.
func NewBlockHelper(st *api.State) BlockHelper {
return BlockHelper{
blockClient: block.NewClient(st),
}
}
// NewBlockHelper creates a block switch used in testing
// to manage desired juju blocks.
func NewBlockHelper(st api.Connection) BlockHelper {
return BlockHelper{
ApiState: st,
client: block.NewClient(st),
}
}
func (s *blockSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
s.blockClient = block.NewClient(s.APIState)
c.Assert(s.blockClient, gc.NotNil)
}
// NewBlockHelper creates a block switch used in testing
// to manage desired juju blocks.
func NewBlockHelper(st *api.State) BlockHelper {
return BlockHelper{
ApiState: st,
client: block.NewClient(st),
}
}
// NewCmdBlockHelper creates a block switch used in testing
// to manage desired juju blocks.
func NewCmdBlockHelper(api base.APICallCloser) CmdBlockHelper {
return CmdBlockHelper{
blockClient: block.NewClient(api),
}
}
