github.com/niedbalski/juju@v0.0.0-20190215020005-8ff100488e47/api/machineactions/machineactions_test.go (about)

     1  // Copyright 2016 Canonical Ltd.
     2  // Copyright 2016 Cloudbase Solutions
     3  // Licensed under the AGPLv3, see LICENCE file for details.
     4  
     5  package machineactions_test
     6  
     7  import (
     8  	"github.com/juju/errors"
     9  	jujutesting "github.com/juju/testing"
    10  	jc "github.com/juju/testing/checkers"
    11  	"github.com/juju/utils"
    12  	gc "gopkg.in/check.v1"
    13  	"gopkg.in/juju/names.v2"
    14  
    15  	apitesting "github.com/juju/juju/api/base/testing"
    16  	"github.com/juju/juju/api/machineactions"
    17  	"github.com/juju/juju/apiserver/params"
    18  )
    19  
    20  type ClientSuite struct {
    21  	jujutesting.IsolationSuite
    22  }
    23  
    24  var _ = gc.Suite(&ClientSuite{})
    25  
    26  func (s *ClientSuite) TestWatchFails(c *gc.C) {
    27  	tag := names.NewMachineTag("2")
    28  	expectErr := errors.Errorf("kuso")
    29  	expectedCalls := []jujutesting.StubCall{{
    30  		"MachineActions.WatchActionNotifications",
    31  		[]interface{}{"", params.Entities{
    32  			Entities: []params.Entity{{Tag: tag.String()}},
    33  		}},
    34  	}}
    35  	var stub jujutesting.Stub
    36  
    37  	apiCaller := apitesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
    38  		stub.AddCall(objType+"."+request, id, arg)
    39  		c.Check(result, gc.FitsTypeOf, &params.StringsWatchResults{})
    40  		res := result.(*params.StringsWatchResults)
    41  		res.Results = make([]params.StringsWatchResult, 1)
    42  		return expectErr
    43  	})
    44  
    45  	client := machineactions.NewClient(apiCaller)
    46  	w, err := client.WatchActionNotifications(tag)
    47  	c.Assert(errors.Cause(err), gc.Equals, expectErr)
    48  	c.Assert(w, gc.IsNil)
    49  	stub.CheckCalls(c, expectedCalls)
    50  }
    51  
    52  func (s *ClientSuite) TestWatchResultError(c *gc.C) {
    53  	tag := names.NewMachineTag("2")
    54  	expectErr := &params.Error{
    55  		Message: "rigged",
    56  		Code:    params.CodeNotAssigned,
    57  	}
    58  	expectedCalls := []jujutesting.StubCall{{
    59  		"MachineActions.WatchActionNotifications",
    60  		[]interface{}{"", params.Entities{
    61  			Entities: []params.Entity{{Tag: tag.String()}},
    62  		}},
    63  	}}
    64  	var stub jujutesting.Stub
    65  
    66  	apiCaller := apitesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
    67  		stub.AddCall(objType+"."+request, id, arg)
    68  		c.Check(result, gc.FitsTypeOf, &params.StringsWatchResults{})
    69  		res := result.(*params.StringsWatchResults)
    70  		res.Results = make([]params.StringsWatchResult, 1)
    71  		res.Results[0].Error = expectErr
    72  		return nil
    73  	})
    74  
    75  	client := machineactions.NewClient(apiCaller)
    76  	w, err := client.WatchActionNotifications(tag)
    77  	c.Assert(errors.Cause(err), gc.Equals, expectErr)
    78  	c.Assert(w, gc.IsNil)
    79  	stub.CheckCalls(c, expectedCalls)
    80  }
    81  
    82  func (s *ClientSuite) TestWatchResultTooMany(c *gc.C) {
    83  	tag := names.NewMachineTag("2")
    84  	expectedCalls := []jujutesting.StubCall{{
    85  		"MachineActions.WatchActionNotifications",
    86  		[]interface{}{"", params.Entities{
    87  			Entities: []params.Entity{{Tag: tag.String()}},
    88  		}},
    89  	}}
    90  	var stub jujutesting.Stub
    91  
    92  	apiCaller := apitesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
    93  		stub.AddCall(objType+"."+request, id, arg)
    94  		c.Check(result, gc.FitsTypeOf, &params.StringsWatchResults{})
    95  		res := result.(*params.StringsWatchResults)
    96  		res.Results = make([]params.StringsWatchResult, 2)
    97  		return nil
    98  	})
    99  
   100  	client := machineactions.NewClient(apiCaller)
   101  	w, err := client.WatchActionNotifications(tag)
   102  	c.Assert(err, gc.ErrorMatches, "expected 1 result, got 2")
   103  	c.Assert(w, gc.IsNil)
   104  	stub.CheckCalls(c, expectedCalls)
   105  }
   106  
   107  func (s *ClientSuite) TestActionBeginSuccess(c *gc.C) {
   108  	tag := names.NewActionTag(utils.MustNewUUID().String())
   109  	expectedCalls := []jujutesting.StubCall{{
   110  		"MachineActions.BeginActions",
   111  		[]interface{}{"", params.Entities{
   112  			Entities: []params.Entity{{Tag: tag.String()}},
   113  		}},
   114  	}}
   115  	var stub jujutesting.Stub
   116  
   117  	apiCaller := apitesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
   118  		stub.AddCall(objType+"."+request, id, arg)
   119  		c.Check(result, gc.FitsTypeOf, &params.ErrorResults{})
   120  		*(result.(*params.ErrorResults)) = params.ErrorResults{
   121  			Results: []params.ErrorResult{{}},
   122  		}
   123  
   124  		return nil
   125  	})
   126  
   127  	client := machineactions.NewClient(apiCaller)
   128  	err := client.ActionBegin(tag)
   129  	c.Assert(err, jc.ErrorIsNil)
   130  	stub.CheckCalls(c, expectedCalls)
   131  }
   132  
   133  func (s *ClientSuite) TestActionBeginError(c *gc.C) {
   134  	tag := names.NewActionTag(utils.MustNewUUID().String())
   135  	expectedCalls := []jujutesting.StubCall{{
   136  		"MachineActions.BeginActions",
   137  		[]interface{}{"", params.Entities{
   138  			Entities: []params.Entity{{Tag: tag.String()}},
   139  		}},
   140  	}}
   141  	expectedErr := errors.Errorf("blam")
   142  	var stub jujutesting.Stub
   143  
   144  	apiCaller := apitesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
   145  		stub.AddCall(objType+"."+request, id, arg)
   146  		c.Check(result, gc.FitsTypeOf, &params.ErrorResults{})
   147  		return expectedErr
   148  	})
   149  
   150  	client := machineactions.NewClient(apiCaller)
   151  	err := client.ActionBegin(tag)
   152  	c.Assert(errors.Cause(err), gc.Equals, expectedErr)
   153  	stub.CheckCalls(c, expectedCalls)
   154  }
   155  
   156  func (s *ClientSuite) TestActionBeginResultError(c *gc.C) {
   157  	tag := names.NewActionTag(utils.MustNewUUID().String())
   158  	expectedCalls := []jujutesting.StubCall{{
   159  		"MachineActions.BeginActions",
   160  		[]interface{}{"", params.Entities{
   161  			Entities: []params.Entity{{Tag: tag.String()}},
   162  		}},
   163  	}}
   164  	expectedErr := &params.Error{
   165  		Message: "rigged",
   166  		Code:    params.CodeNotAssigned,
   167  	}
   168  	var stub jujutesting.Stub
   169  
   170  	apiCaller := apitesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
   171  		stub.AddCall(objType+"."+request, id, arg)
   172  		c.Check(result, gc.FitsTypeOf, &params.ErrorResults{})
   173  		*(result.(*params.ErrorResults)) = params.ErrorResults{
   174  			Results: []params.ErrorResult{{expectedErr}},
   175  		}
   176  
   177  		return nil
   178  	})
   179  
   180  	client := machineactions.NewClient(apiCaller)
   181  	err := client.ActionBegin(tag)
   182  	c.Assert(errors.Cause(err), gc.Equals, expectedErr)
   183  	stub.CheckCalls(c, expectedCalls)
   184  }
   185  
   186  func (s *ClientSuite) TestActionBeginTooManyResults(c *gc.C) {
   187  	tag := names.NewActionTag(utils.MustNewUUID().String())
   188  	expectedCalls := []jujutesting.StubCall{{
   189  		"MachineActions.BeginActions",
   190  		[]interface{}{"", params.Entities{
   191  			Entities: []params.Entity{{Tag: tag.String()}},
   192  		}},
   193  	}}
   194  	var stub jujutesting.Stub
   195  
   196  	apiCaller := apitesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
   197  		stub.AddCall(objType+"."+request, id, arg)
   198  		c.Check(result, gc.FitsTypeOf, &params.ErrorResults{})
   199  		res := result.(*params.ErrorResults)
   200  		res.Results = make([]params.ErrorResult, 2)
   201  		return nil
   202  	})
   203  
   204  	client := machineactions.NewClient(apiCaller)
   205  	err := client.ActionBegin(tag)
   206  	c.Assert(err, gc.ErrorMatches, "expected 1 result, got 2")
   207  	stub.CheckCalls(c, expectedCalls)
   208  }
   209  
   210  func (s *ClientSuite) TestActionFinishSuccess(c *gc.C) {
   211  	tag := names.NewActionTag(utils.MustNewUUID().String())
   212  	status := "stubstatus"
   213  	actionResults := map[string]interface{}{"stub": "stub"}
   214  	message := "stubmsg"
   215  	expectedCalls := []jujutesting.StubCall{{
   216  		"MachineActions.FinishActions",
   217  		[]interface{}{"", params.ActionExecutionResults{
   218  			Results: []params.ActionExecutionResult{{
   219  				ActionTag: tag.String(),
   220  				Status:    status,
   221  				Results:   actionResults,
   222  				Message:   message,
   223  			}},
   224  		}},
   225  	}}
   226  	var stub jujutesting.Stub
   227  
   228  	apiCaller := apitesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
   229  		stub.AddCall(objType+"."+request, id, arg)
   230  		c.Check(result, gc.FitsTypeOf, &params.ErrorResults{})
   231  		*(result.(*params.ErrorResults)) = params.ErrorResults{
   232  			Results: []params.ErrorResult{{}},
   233  		}
   234  		return nil
   235  	})
   236  
   237  	client := machineactions.NewClient(apiCaller)
   238  	err := client.ActionFinish(tag, status, actionResults, message)
   239  	c.Assert(err, jc.ErrorIsNil)
   240  	stub.CheckCalls(c, expectedCalls)
   241  }
   242  
   243  func (s *ClientSuite) TestActionFinishError(c *gc.C) {
   244  	tag := names.NewActionTag(utils.MustNewUUID().String())
   245  	expectedCalls := []jujutesting.StubCall{{
   246  		"MachineActions.FinishActions",
   247  		[]interface{}{"", params.ActionExecutionResults{
   248  			Results: []params.ActionExecutionResult{{
   249  				ActionTag: tag.String(),
   250  				Status:    "",
   251  				Results:   nil,
   252  				Message:   "",
   253  			}},
   254  		}},
   255  	}}
   256  	expectedErr := errors.Errorf("blam")
   257  	var stub jujutesting.Stub
   258  
   259  	apiCaller := apitesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
   260  		stub.AddCall(objType+"."+request, id, arg)
   261  		c.Check(result, gc.FitsTypeOf, &params.ErrorResults{})
   262  		return expectedErr
   263  	})
   264  
   265  	client := machineactions.NewClient(apiCaller)
   266  	err := client.ActionFinish(tag, "", nil, "")
   267  	c.Assert(errors.Cause(err), gc.Equals, expectedErr)
   268  	stub.CheckCalls(c, expectedCalls)
   269  }
   270  
   271  func (s *ClientSuite) TestActionFinishResultError(c *gc.C) {
   272  	tag := names.NewActionTag(utils.MustNewUUID().String())
   273  	expectedCalls := []jujutesting.StubCall{{
   274  		"MachineActions.FinishActions",
   275  		[]interface{}{"", params.ActionExecutionResults{
   276  			Results: []params.ActionExecutionResult{{
   277  				ActionTag: tag.String(),
   278  				Status:    "",
   279  				Results:   nil,
   280  				Message:   "",
   281  			}},
   282  		}},
   283  	}}
   284  	expectedErr := &params.Error{
   285  		Message: "rigged",
   286  		Code:    params.CodeNotAssigned,
   287  	}
   288  	var stub jujutesting.Stub
   289  
   290  	apiCaller := apitesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
   291  		stub.AddCall(objType+"."+request, id, arg)
   292  		c.Check(result, gc.FitsTypeOf, &params.ErrorResults{})
   293  		*(result.(*params.ErrorResults)) = params.ErrorResults{
   294  			Results: []params.ErrorResult{{expectedErr}},
   295  		}
   296  
   297  		return nil
   298  	})
   299  
   300  	client := machineactions.NewClient(apiCaller)
   301  	err := client.ActionFinish(tag, "", nil, "")
   302  	c.Assert(errors.Cause(err), gc.Equals, expectedErr)
   303  	stub.CheckCalls(c, expectedCalls)
   304  }
   305  
   306  func (s *ClientSuite) TestActionFinishTooManyResults(c *gc.C) {
   307  	tag := names.NewActionTag(utils.MustNewUUID().String())
   308  	expectedCalls := []jujutesting.StubCall{{
   309  		"MachineActions.FinishActions",
   310  		[]interface{}{"", params.ActionExecutionResults{
   311  			Results: []params.ActionExecutionResult{{
   312  				ActionTag: tag.String(),
   313  				Status:    "",
   314  				Results:   nil,
   315  				Message:   "",
   316  			}},
   317  		}},
   318  	}}
   319  	var stub jujutesting.Stub
   320  
   321  	apiCaller := apitesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
   322  		stub.AddCall(objType+"."+request, id, arg)
   323  		c.Check(result, gc.FitsTypeOf, &params.ErrorResults{})
   324  		res := result.(*params.ErrorResults)
   325  		res.Results = make([]params.ErrorResult, 2)
   326  		return nil
   327  	})
   328  
   329  	client := machineactions.NewClient(apiCaller)
   330  	err := client.ActionFinish(tag, "", nil, "")
   331  	c.Assert(err, gc.ErrorMatches, "expected 1 result, got 2")
   332  	stub.CheckCalls(c, expectedCalls)
   333  }
   334  
   335  func (s *ClientSuite) TestGetActionSuccess(c *gc.C) {
   336  	tag := names.NewActionTag(utils.MustNewUUID().String())
   337  	expectedCalls := []jujutesting.StubCall{{
   338  		"MachineActions.Actions",
   339  		[]interface{}{"", params.Entities{
   340  			Entities: []params.Entity{{Tag: tag.String()}},
   341  		}},
   342  	}}
   343  	expectedName := "ack"
   344  	expectedParams := map[string]interface{}{"floob": "zgloob"}
   345  	var stub jujutesting.Stub
   346  
   347  	apiCaller := apitesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
   348  		stub.AddCall(objType+"."+request, id, arg)
   349  		c.Check(result, gc.FitsTypeOf, &params.ActionResults{})
   350  		*(result.(*params.ActionResults)) = params.ActionResults{
   351  			Results: []params.ActionResult{{
   352  				Action: &params.Action{
   353  					Name:       expectedName,
   354  					Parameters: expectedParams,
   355  				},
   356  			}},
   357  		}
   358  		return nil
   359  	})
   360  
   361  	client := machineactions.NewClient(apiCaller)
   362  	action, err := client.Action(tag)
   363  	c.Assert(err, jc.ErrorIsNil)
   364  	c.Assert(action.Name(), gc.Equals, expectedName)
   365  	c.Assert(action.Params(), gc.DeepEquals, expectedParams)
   366  	stub.CheckCalls(c, expectedCalls)
   367  }
   368  
   369  func (s *ClientSuite) TestGetActionError(c *gc.C) {
   370  	tag := names.NewActionTag(utils.MustNewUUID().String())
   371  	expectedCalls := []jujutesting.StubCall{{
   372  		"MachineActions.Actions",
   373  		[]interface{}{"", params.Entities{
   374  			Entities: []params.Entity{{Tag: tag.String()}},
   375  		}},
   376  	}}
   377  	expectedErr := errors.Errorf("blam")
   378  	var stub jujutesting.Stub
   379  
   380  	apiCaller := apitesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
   381  		stub.AddCall(objType+"."+request, id, arg)
   382  		c.Check(result, gc.FitsTypeOf, &params.ActionResults{})
   383  		return expectedErr
   384  	})
   385  
   386  	client := machineactions.NewClient(apiCaller)
   387  	action, err := client.Action(tag)
   388  	c.Assert(errors.Cause(err), gc.Equals, expectedErr)
   389  	c.Assert(action, gc.IsNil)
   390  	stub.CheckCalls(c, expectedCalls)
   391  }
   392  
   393  func (s *ClientSuite) TestGetActionResultError(c *gc.C) {
   394  	tag := names.NewActionTag(utils.MustNewUUID().String())
   395  	expectedCalls := []jujutesting.StubCall{{
   396  		"MachineActions.Actions",
   397  		[]interface{}{"", params.Entities{
   398  			Entities: []params.Entity{{Tag: tag.String()}},
   399  		}},
   400  	}}
   401  	expectedErr := &params.Error{
   402  		Message: "rigged",
   403  		Code:    params.CodeNotAssigned,
   404  	}
   405  	var stub jujutesting.Stub
   406  
   407  	apiCaller := apitesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
   408  		stub.AddCall(objType+"."+request, id, arg)
   409  		c.Check(result, gc.FitsTypeOf, &params.ActionResults{})
   410  		*(result.(*params.ActionResults)) = params.ActionResults{
   411  			Results: []params.ActionResult{{
   412  				Error: expectedErr,
   413  			}},
   414  		}
   415  		return nil
   416  	})
   417  
   418  	client := machineactions.NewClient(apiCaller)
   419  	action, err := client.Action(tag)
   420  	c.Assert(errors.Cause(err), gc.Equals, expectedErr)
   421  	c.Assert(action, gc.IsNil)
   422  	stub.CheckCalls(c, expectedCalls)
   423  }
   424  
   425  func (s *ClientSuite) TestGetActionTooManyResults(c *gc.C) {
   426  	tag := names.NewActionTag(utils.MustNewUUID().String())
   427  	expectedCalls := []jujutesting.StubCall{{
   428  		"MachineActions.Actions",
   429  		[]interface{}{"", params.Entities{
   430  			Entities: []params.Entity{{Tag: tag.String()}},
   431  		}},
   432  	}}
   433  	var stub jujutesting.Stub
   434  
   435  	apiCaller := apitesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
   436  		stub.AddCall(objType+"."+request, id, arg)
   437  		c.Check(result, gc.FitsTypeOf, &params.ActionResults{})
   438  		res := result.(*params.ActionResults)
   439  		res.Results = make([]params.ActionResult, 2)
   440  		return nil
   441  	})
   442  
   443  	client := machineactions.NewClient(apiCaller)
   444  	action, err := client.Action(tag)
   445  	c.Assert(err, gc.ErrorMatches, "expected only 1 action query result, got 2")
   446  	c.Assert(action, gc.IsNil)
   447  	stub.CheckCalls(c, expectedCalls)
   448  }
   449  
   450  func (s *ClientSuite) TestRunningActionSuccess(c *gc.C) {
   451  	tag := names.NewMachineTag(utils.MustNewUUID().String())
   452  	expectedCalls := []jujutesting.StubCall{{
   453  		"MachineActions.RunningActions",
   454  		[]interface{}{"", params.Entities{
   455  			Entities: []params.Entity{{Tag: tag.String()}},
   456  		}},
   457  	}}
   458  	actionsList := []params.ActionResult{
   459  		{Action: &params.Action{Name: "foo"}},
   460  		{Action: &params.Action{Name: "baz"}},
   461  	}
   462  	var stub jujutesting.Stub
   463  
   464  	apiCaller := apitesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
   465  		stub.AddCall(objType+"."+request, id, arg)
   466  		c.Check(result, gc.FitsTypeOf, &params.ActionsByReceivers{})
   467  		*(result.(*params.ActionsByReceivers)) = params.ActionsByReceivers{
   468  			Actions: []params.ActionsByReceiver{{
   469  				Actions: actionsList,
   470  			}},
   471  		}
   472  		return nil
   473  	})
   474  
   475  	client := machineactions.NewClient(apiCaller)
   476  	actions, err := client.RunningActions(tag)
   477  	c.Assert(err, jc.ErrorIsNil)
   478  	c.Assert(actions, jc.DeepEquals, actionsList)
   479  	stub.CheckCalls(c, expectedCalls)
   480  }
   481  
   482  func (s *ClientSuite) TestRunningActionsError(c *gc.C) {
   483  	tag := names.NewMachineTag(utils.MustNewUUID().String())
   484  	expectedCalls := []jujutesting.StubCall{{
   485  		"MachineActions.RunningActions",
   486  		[]interface{}{"", params.Entities{
   487  			Entities: []params.Entity{{Tag: tag.String()}},
   488  		}},
   489  	}}
   490  	expectedErr := errors.Errorf("blam")
   491  	var stub jujutesting.Stub
   492  
   493  	apiCaller := apitesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
   494  		stub.AddCall(objType+"."+request, id, arg)
   495  		c.Check(result, gc.FitsTypeOf, &params.ActionsByReceivers{})
   496  		return expectedErr
   497  	})
   498  
   499  	client := machineactions.NewClient(apiCaller)
   500  	actions, err := client.RunningActions(tag)
   501  	c.Assert(errors.Cause(err), gc.Equals, expectedErr)
   502  	c.Assert(actions, gc.IsNil)
   503  	stub.CheckCalls(c, expectedCalls)
   504  }
   505  
   506  func (s *ClientSuite) TestRunningActionsResultError(c *gc.C) {
   507  	tag := names.NewMachineTag(utils.MustNewUUID().String())
   508  	expectedCalls := []jujutesting.StubCall{{
   509  		"MachineActions.RunningActions",
   510  		[]interface{}{"", params.Entities{
   511  			Entities: []params.Entity{{Tag: tag.String()}},
   512  		}},
   513  	}}
   514  	expectedErr := &params.Error{
   515  		Message: "rigged",
   516  		Code:    params.CodeNotAssigned,
   517  	}
   518  	var stub jujutesting.Stub
   519  
   520  	apiCaller := apitesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
   521  		stub.AddCall(objType+"."+request, id, arg)
   522  		c.Check(result, gc.FitsTypeOf, &params.ActionsByReceivers{})
   523  		*(result.(*params.ActionsByReceivers)) = params.ActionsByReceivers{
   524  			Actions: []params.ActionsByReceiver{{
   525  				Error: expectedErr,
   526  			}},
   527  		}
   528  		return nil
   529  	})
   530  
   531  	client := machineactions.NewClient(apiCaller)
   532  	action, err := client.RunningActions(tag)
   533  	c.Assert(errors.Cause(err), gc.Equals, expectedErr)
   534  	c.Assert(action, gc.IsNil)
   535  	stub.CheckCalls(c, expectedCalls)
   536  }
   537  
   538  func (s *ClientSuite) TestRunningActionsTooManyResults(c *gc.C) {
   539  	tag := names.NewMachineTag(utils.MustNewUUID().String())
   540  	expectedCalls := []jujutesting.StubCall{{
   541  		"MachineActions.RunningActions",
   542  		[]interface{}{"", params.Entities{
   543  			Entities: []params.Entity{{Tag: tag.String()}},
   544  		}},
   545  	}}
   546  	var stub jujutesting.Stub
   547  
   548  	apiCaller := apitesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
   549  		stub.AddCall(objType+"."+request, id, arg)
   550  		c.Check(result, gc.FitsTypeOf, &params.ActionsByReceivers{})
   551  		res := result.(*params.ActionsByReceivers)
   552  		res.Actions = make([]params.ActionsByReceiver, 2)
   553  		return nil
   554  	})
   555  
   556  	client := machineactions.NewClient(apiCaller)
   557  	actions, err := client.RunningActions(tag)
   558  	c.Assert(err, gc.ErrorMatches, "expected 1 result, got 2")
   559  	c.Assert(actions, gc.IsNil)
   560  	stub.CheckCalls(c, expectedCalls)
   561  }