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

     1  // Copyright 2020 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package container_test
     5  
     6  import (
     7  	"time"
     8  
     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/operation"
    14  	"github.com/juju/juju/worker/uniter/remotestate"
    15  	"github.com/juju/juju/worker/uniter/resolver"
    16  )
    17  
    18  type containerSuite struct{}
    19  
    20  var _ = gc.Suite(&containerSuite{})
    21  
    22  func (s *containerSuite) TestNoRemoteInitRequired(c *gc.C) {
    23  	containerResolver := container.NewRemoteContainerInitResolver()
    24  	localState := resolver.LocalState{}
    25  	remoteState := remotestate.Snapshot{}
    26  	_, err := containerResolver.NextOp(localState, remoteState, &mockOperations{})
    27  	c.Assert(err, gc.DeepEquals, resolver.ErrNoOperation)
    28  }
    29  
    30  func (s *containerSuite) TestRunningStatusNil(c *gc.C) {
    31  	containerResolver := container.NewRemoteContainerInitResolver()
    32  	localState := resolver.LocalState{
    33  		OutdatedRemoteCharm: true,
    34  	}
    35  	remoteState := remotestate.Snapshot{}
    36  	_, err := containerResolver.NextOp(localState, remoteState, &mockOperations{})
    37  	c.Assert(err, gc.DeepEquals, resolver.ErrNoOperation)
    38  }
    39  
    40  func (s *containerSuite) TestRemoteInitRequiredContinue(c *gc.C) {
    41  	containerResolver := container.NewRemoteContainerInitResolver()
    42  	localState := resolver.LocalState{
    43  		State: operation.State{
    44  			Kind: operation.Continue,
    45  		},
    46  		OutdatedRemoteCharm: true,
    47  	}
    48  	remoteState := remotestate.Snapshot{
    49  		ContainerRunningStatus: &remotestate.ContainerRunningStatus{
    50  			Initialising:     true,
    51  			InitialisingTime: time.Now(),
    52  			PodName:          "pod-name",
    53  			Running:          false,
    54  		},
    55  	}
    56  	op, err := containerResolver.NextOp(localState, remoteState, &mockOperations{})
    57  	c.Assert(err, jc.ErrorIsNil)
    58  	c.Assert(op.String(), gc.Equals, "remote init")
    59  }
    60  
    61  func (s *containerSuite) TestRemoteInitRequiredRunHookPending(c *gc.C) {
    62  	containerResolver := container.NewRemoteContainerInitResolver()
    63  	localState := resolver.LocalState{
    64  		State: operation.State{
    65  			Kind: operation.RunHook,
    66  			Step: operation.Pending,
    67  		},
    68  		OutdatedRemoteCharm: true,
    69  	}
    70  	remoteState := remotestate.Snapshot{
    71  		ContainerRunningStatus: &remotestate.ContainerRunningStatus{
    72  			Initialising:     true,
    73  			InitialisingTime: time.Now(),
    74  			PodName:          "pod-name",
    75  			Running:          false,
    76  		},
    77  	}
    78  	op, err := containerResolver.NextOp(localState, remoteState, &mockOperations{})
    79  	c.Assert(err, jc.ErrorIsNil)
    80  	c.Assert(op.String(), gc.Equals, "remote init")
    81  }
    82  
    83  func (s *containerSuite) TestRemoteInitRequiredRunHookNotPending(c *gc.C) {
    84  	containerResolver := container.NewRemoteContainerInitResolver()
    85  	localState := resolver.LocalState{
    86  		State: operation.State{
    87  			Kind: operation.RunHook,
    88  			Step: operation.Done,
    89  		},
    90  		OutdatedRemoteCharm: true,
    91  	}
    92  	remoteState := remotestate.Snapshot{
    93  		ContainerRunningStatus: &remotestate.ContainerRunningStatus{
    94  			Initialising:     true,
    95  			InitialisingTime: time.Now(),
    96  			PodName:          "pod-name",
    97  			Running:          false,
    98  		},
    99  	}
   100  	_, err := containerResolver.NextOp(localState, remoteState, &mockOperations{})
   101  	c.Assert(err, gc.DeepEquals, resolver.ErrNoOperation)
   102  }
   103  
   104  func (s *containerSuite) TestRemoteInitRequiredAndPending(c *gc.C) {
   105  	containerResolver := container.NewRemoteContainerInitResolver()
   106  	localState := resolver.LocalState{
   107  		State: operation.State{
   108  			Kind: operation.RemoteInit,
   109  			Step: operation.Pending,
   110  		},
   111  		OutdatedRemoteCharm: true,
   112  	}
   113  	remoteState := remotestate.Snapshot{
   114  		ContainerRunningStatus: &remotestate.ContainerRunningStatus{
   115  			Initialising:     true,
   116  			InitialisingTime: time.Now(),
   117  			PodName:          "pod-name",
   118  			Running:          false,
   119  		},
   120  	}
   121  	op, err := containerResolver.NextOp(localState, remoteState, &mockOperations{})
   122  	c.Assert(err, jc.ErrorIsNil)
   123  	c.Assert(op.String(), gc.Equals, "remote init")
   124  }
   125  
   126  func (s *containerSuite) TestRemoteInitRequiredAndDone(c *gc.C) {
   127  	containerResolver := container.NewRemoteContainerInitResolver()
   128  	localState := resolver.LocalState{
   129  		State: operation.State{
   130  			Kind: operation.RemoteInit,
   131  			Step: operation.Done,
   132  		},
   133  		OutdatedRemoteCharm: true,
   134  	}
   135  	remoteState := remotestate.Snapshot{
   136  		ContainerRunningStatus: &remotestate.ContainerRunningStatus{
   137  			Initialising:     true,
   138  			InitialisingTime: time.Now(),
   139  			PodName:          "pod-name",
   140  			Running:          false,
   141  		},
   142  	}
   143  	op, err := containerResolver.NextOp(localState, remoteState, &mockOperations{})
   144  	c.Assert(err, jc.ErrorIsNil)
   145  	c.Assert(op.String(), gc.Equals, "skip remote init")
   146  }
   147  
   148  func (s *containerSuite) TestReinit(c *gc.C) {
   149  	containerResolver := container.NewRemoteContainerInitResolver()
   150  	t := time.Now()
   151  	localState := resolver.LocalState{
   152  		State: operation.State{
   153  			Kind: operation.Continue,
   154  		},
   155  		ContainerRunningStatus: &remotestate.ContainerRunningStatus{
   156  			Initialising:     false,
   157  			InitialisingTime: t,
   158  			PodName:          "pod-name",
   159  			Running:          true,
   160  		},
   161  	}
   162  	remoteState := remotestate.Snapshot{
   163  		ContainerRunningStatus: &remotestate.ContainerRunningStatus{
   164  			Initialising:     true,
   165  			InitialisingTime: t.Add(time.Second),
   166  			PodName:          "pod-name",
   167  			Running:          false,
   168  		},
   169  	}
   170  	op, err := containerResolver.NextOp(localState, remoteState, &mockOperations{})
   171  	c.Assert(err, jc.ErrorIsNil)
   172  	c.Assert(op.String(), gc.Equals, "remote init")
   173  }