github.com/juju/juju@v0.0.0-20240327075706-a90865de2538/worker/uniter/container/workload_test.go (about)

     1  // Copyright 2021 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package container_test
     5  
     6  import (
     7  	"github.com/juju/errors"
     8  	"github.com/juju/loggo"
     9  	jc "github.com/juju/testing/checkers"
    10  	gc "gopkg.in/check.v1"
    11  
    12  	"github.com/juju/juju/worker/uniter/container"
    13  	"github.com/juju/juju/worker/uniter/hook"
    14  	"github.com/juju/juju/worker/uniter/operation"
    15  	"github.com/juju/juju/worker/uniter/remotestate"
    16  	"github.com/juju/juju/worker/uniter/resolver"
    17  )
    18  
    19  type workloadSuite struct{}
    20  
    21  var _ = gc.Suite(&workloadSuite{})
    22  
    23  func (s *workloadSuite) TestWorkloadEventList(c *gc.C) {
    24  	evt := container.WorkloadEvent{
    25  		Type:         container.ReadyEvent,
    26  		WorkloadName: "test",
    27  	}
    28  	cbCalled := false
    29  	expectedErr := errors.Errorf("expected error")
    30  	events := container.NewWorkloadEvents()
    31  	id := events.AddWorkloadEvent(evt, func(err error) {
    32  		c.Assert(err, gc.Equals, expectedErr)
    33  		c.Assert(cbCalled, jc.IsFalse)
    34  		cbCalled = true
    35  	})
    36  	c.Assert(id, gc.Not(gc.Equals), "")
    37  	c.Assert(events.Events(), gc.DeepEquals, []container.WorkloadEvent{evt})
    38  	c.Assert(events.EventIDs(), gc.DeepEquals, []string{id})
    39  	evt2, cb, err := events.GetWorkloadEvent(id)
    40  	c.Assert(err, jc.ErrorIsNil)
    41  	c.Assert(cb, gc.NotNil)
    42  	c.Assert(evt2, gc.DeepEquals, evt)
    43  	cb(expectedErr)
    44  	c.Assert(cbCalled, jc.IsTrue)
    45  }
    46  
    47  func (s *workloadSuite) TestWorkloadEventListFail(c *gc.C) {
    48  	events := container.NewWorkloadEvents()
    49  	evt, cb, err := events.GetWorkloadEvent("nope")
    50  	c.Assert(err, gc.ErrorMatches, "workload event nope not found")
    51  	c.Assert(cb, gc.IsNil)
    52  	c.Assert(evt, gc.DeepEquals, container.WorkloadEvent{})
    53  }
    54  
    55  func (s *workloadSuite) TestWorkloadReadyHook(c *gc.C) {
    56  	events := container.NewWorkloadEvents()
    57  	expectedErr := errors.Errorf("expected error")
    58  	handler := func(err error) {
    59  		c.Assert(err, gc.Equals, expectedErr)
    60  	}
    61  	containerResolver := container.NewWorkloadHookResolver(
    62  		loggo.GetLogger("test"),
    63  		events,
    64  		events.RemoveWorkloadEvent)
    65  	localState := resolver.LocalState{
    66  		State: operation.State{
    67  			Kind: operation.Continue,
    68  			Step: operation.Pending,
    69  		},
    70  	}
    71  	remoteState := remotestate.Snapshot{
    72  		WorkloadEvents: []string{
    73  			events.AddWorkloadEvent(container.WorkloadEvent{
    74  				Type:         container.ReadyEvent,
    75  				WorkloadName: "test",
    76  			}, handler),
    77  		},
    78  	}
    79  	opFactory := &mockOperations{}
    80  	op, err := containerResolver.NextOp(localState, remoteState, opFactory)
    81  	c.Assert(err, jc.ErrorIsNil)
    82  	c.Assert(op, gc.NotNil)
    83  	op = operation.Unwrap(op)
    84  	hookOp, ok := op.(*mockRunHookOp)
    85  	c.Assert(ok, jc.IsTrue)
    86  	c.Assert(hookOp.hookInfo, gc.DeepEquals, hook.Info{
    87  		Kind:         "pebble-ready",
    88  		WorkloadName: "test",
    89  	})
    90  }
    91  
    92  func (s *workloadSuite) TestWorkloadCustomNoticeHook(c *gc.C) {
    93  	events := container.NewWorkloadEvents()
    94  	expectedErr := errors.Errorf("expected error")
    95  	handler := func(err error) {
    96  		c.Assert(err, gc.Equals, expectedErr)
    97  	}
    98  	containerResolver := container.NewWorkloadHookResolver(
    99  		loggo.GetLogger("test"),
   100  		events,
   101  		events.RemoveWorkloadEvent)
   102  	localState := resolver.LocalState{
   103  		State: operation.State{
   104  			Kind: operation.Continue,
   105  			Step: operation.Pending,
   106  		},
   107  	}
   108  	remoteState := remotestate.Snapshot{
   109  		WorkloadEvents: []string{
   110  			events.AddWorkloadEvent(container.WorkloadEvent{
   111  				Type:         container.CustomNoticeEvent,
   112  				WorkloadName: "test",
   113  				NoticeID:     "123",
   114  				NoticeType:   "custom",
   115  				NoticeKey:    "example.com/foo",
   116  			}, handler),
   117  		},
   118  	}
   119  	opFactory := &mockOperations{}
   120  	op, err := containerResolver.NextOp(localState, remoteState, opFactory)
   121  	c.Assert(err, jc.ErrorIsNil)
   122  	c.Assert(op, gc.NotNil)
   123  	op = operation.Unwrap(op)
   124  	hookOp, ok := op.(*mockRunHookOp)
   125  	c.Assert(ok, jc.IsTrue)
   126  	c.Assert(hookOp.hookInfo, gc.DeepEquals, hook.Info{
   127  		Kind:         "pebble-custom-notice",
   128  		WorkloadName: "test",
   129  		NoticeID:     "123",
   130  		NoticeType:   "custom",
   131  		NoticeKey:    "example.com/foo",
   132  	})
   133  }