github.com/juju/juju@v0.0.0-20240430160146-1752b71fcf00/apiserver/common/remove_test.go (about)

     1  // Copyright 2013 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package common_test
     5  
     6  import (
     7  	"fmt"
     8  
     9  	"github.com/juju/names/v5"
    10  	jc "github.com/juju/testing/checkers"
    11  	gc "gopkg.in/check.v1"
    12  
    13  	"github.com/juju/juju/apiserver/common"
    14  	apiservertesting "github.com/juju/juju/apiserver/testing"
    15  	"github.com/juju/juju/rpc/params"
    16  	"github.com/juju/juju/state"
    17  )
    18  
    19  type removeSuite struct{}
    20  
    21  var _ = gc.Suite(&removeSuite{})
    22  
    23  type fakeRemover struct {
    24  	state.Entity
    25  	life          state.Life
    26  	errEnsureDead error
    27  	errRemove     error
    28  	fetchError
    29  }
    30  
    31  func (r *fakeRemover) EnsureDead() error {
    32  	return r.errEnsureDead
    33  }
    34  
    35  func (r *fakeRemover) Remove() error {
    36  	return r.errRemove
    37  }
    38  
    39  func (r *fakeRemover) Life() state.Life {
    40  	return r.life
    41  }
    42  
    43  func (*removeSuite) TestRemove(c *gc.C) {
    44  	st := &fakeState{
    45  		entities: map[names.Tag]entityWithError{
    46  			u("x/0"): &fakeRemover{life: state.Dying, errEnsureDead: fmt.Errorf("x0 EnsureDead fails")},
    47  			u("x/1"): &fakeRemover{life: state.Dying, errRemove: fmt.Errorf("x1 Remove fails")},
    48  			u("x/2"): &fakeRemover{life: state.Alive},
    49  			u("x/3"): &fakeRemover{life: state.Dying},
    50  			u("x/4"): &fakeRemover{life: state.Dead},
    51  			u("x/5"): &fakeRemover{fetchError: "x5 error"},
    52  		},
    53  	}
    54  	getCanModify := func() (common.AuthFunc, error) {
    55  		u0 := u("x/0")
    56  		u1 := u("x/1")
    57  		u2 := u("x/2")
    58  		u3 := u("x/3")
    59  		u5 := u("x/5")
    60  		return func(tag names.Tag) bool {
    61  			return tag == u0 || tag == u1 || tag == u2 || tag == u3 || tag == u5
    62  		}, nil
    63  	}
    64  	afterDeadCalled := false
    65  	afterDead := func(tag names.Tag) {
    66  		if tag != u("x/1") && tag != u("x/3") {
    67  			c.Fail()
    68  		}
    69  		afterDeadCalled = true
    70  	}
    71  
    72  	r := common.NewRemover(st, afterDead, true, getCanModify)
    73  	entities := params.Entities{[]params.Entity{
    74  		{"unit-x-0"}, {"unit-x-1"}, {"unit-x-2"}, {"unit-x-3"}, {"unit-x-4"}, {"unit-x-5"}, {"unit-x-6"},
    75  	}}
    76  	result, err := r.Remove(entities)
    77  	c.Assert(err, jc.ErrorIsNil)
    78  	c.Assert(afterDeadCalled, jc.IsTrue)
    79  	c.Assert(result, gc.DeepEquals, params.ErrorResults{
    80  		Results: []params.ErrorResult{
    81  			{&params.Error{Message: "x0 EnsureDead fails"}},
    82  			{&params.Error{Message: "x1 Remove fails"}},
    83  			{&params.Error{Message: `cannot remove entity "unit-x-2": still alive`}},
    84  			{nil},
    85  			{apiservertesting.ErrUnauthorized},
    86  			{&params.Error{Message: "x5 error"}},
    87  			{apiservertesting.ErrUnauthorized},
    88  		},
    89  	})
    90  
    91  	// Make sure when callEnsureDead is false EnsureDead() doesn't
    92  	// get called.
    93  	afterDeadCalled = false
    94  	r = common.NewRemover(st, afterDead, false, getCanModify)
    95  	entities = params.Entities{[]params.Entity{{"unit-x-0"}, {"unit-x-1"}}}
    96  	result, err = r.Remove(entities)
    97  	c.Assert(err, jc.ErrorIsNil)
    98  	c.Assert(afterDeadCalled, jc.IsFalse)
    99  	c.Assert(result, gc.DeepEquals, params.ErrorResults{
   100  		Results: []params.ErrorResult{
   101  			{nil},
   102  			{&params.Error{Message: "x1 Remove fails"}},
   103  		},
   104  	})
   105  }
   106  
   107  func (*removeSuite) TestRemoveError(c *gc.C) {
   108  	getCanModify := func() (common.AuthFunc, error) {
   109  		return nil, fmt.Errorf("pow")
   110  	}
   111  	r := common.NewRemover(&fakeState{}, nil, true, getCanModify)
   112  	_, err := r.Remove(params.Entities{[]params.Entity{{"x0"}}})
   113  	c.Assert(err, gc.ErrorMatches, "pow")
   114  }
   115  
   116  func (*removeSuite) TestRemoveNoArgsNoError(c *gc.C) {
   117  	getCanModify := func() (common.AuthFunc, error) {
   118  		return nil, fmt.Errorf("pow")
   119  	}
   120  	r := common.NewRemover(&fakeState{}, nil, true, getCanModify)
   121  	result, err := r.Remove(params.Entities{})
   122  	c.Assert(err, jc.ErrorIsNil)
   123  	c.Assert(result.Results, gc.HasLen, 0)
   124  }