github.com/juju/juju@v0.0.0-20240430160146-1752b71fcf00/worker/provisioner/containermanifold_test.go (about)

     1  // Copyright 2022 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package provisioner_test
     5  
     6  import (
     7  	"github.com/juju/errors"
     8  	"github.com/juju/names/v5"
     9  	jc "github.com/juju/testing/checkers"
    10  	"go.uber.org/mock/gomock"
    11  	gc "gopkg.in/check.v1"
    12  
    13  	"github.com/juju/juju/api/base"
    14  	"github.com/juju/juju/core/instance"
    15  	"github.com/juju/juju/core/life"
    16  	"github.com/juju/juju/worker/common"
    17  	"github.com/juju/juju/worker/provisioner"
    18  	"github.com/juju/juju/worker/provisioner/mocks"
    19  )
    20  
    21  type containerManifoldSuite struct {
    22  	machine *mocks.MockContainerMachine
    23  	getter  *mocks.MockContainerMachineGetter
    24  }
    25  
    26  var _ = gc.Suite(&containerManifoldSuite{})
    27  
    28  func (s *containerManifoldSuite) TestConfigValidateAgentName(c *gc.C) {
    29  	cfg := provisioner.ContainerManifoldConfig{}
    30  	err := cfg.Validate()
    31  	c.Assert(err, gc.ErrorMatches, "empty AgentName not valid")
    32  }
    33  
    34  func (s *containerManifoldSuite) TestConfigValidateAPICallerName(c *gc.C) {
    35  	cfg := provisioner.ContainerManifoldConfig{AgentName: "testing"}
    36  	err := cfg.Validate()
    37  	c.Assert(err, gc.ErrorMatches, "empty APICallerName not valid")
    38  }
    39  
    40  func (s *containerManifoldSuite) TestConfigValidateLogger(c *gc.C) {
    41  	cfg := provisioner.ContainerManifoldConfig{
    42  		AgentName:     "testing",
    43  		APICallerName: "another string",
    44  	}
    45  	err := cfg.Validate()
    46  	c.Assert(err, gc.ErrorMatches, "nil Logger not valid")
    47  }
    48  
    49  func (s *containerManifoldSuite) TestConfigValidateMachineLock(c *gc.C) {
    50  	cfg := provisioner.ContainerManifoldConfig{
    51  		AgentName:     "testing",
    52  		APICallerName: "another string",
    53  		Logger:        &noOpLogger{},
    54  	}
    55  	err := cfg.Validate()
    56  	c.Assert(err, gc.ErrorMatches, "missing MachineLock not valid")
    57  }
    58  
    59  func (s *containerManifoldSuite) TestConfigValidateCredentialValidatorFacade(c *gc.C) {
    60  	cfg := provisioner.ContainerManifoldConfig{
    61  		AgentName:     "testing",
    62  		APICallerName: "another string",
    63  		Logger:        &noOpLogger{},
    64  		MachineLock:   &fakeMachineLock{},
    65  	}
    66  	err := cfg.Validate()
    67  	c.Assert(err, gc.ErrorMatches, "missing NewCredentialValidatorFacade not valid")
    68  }
    69  
    70  func (s *containerManifoldSuite) TestConfigValidateContainerType(c *gc.C) {
    71  	cfg := provisioner.ContainerManifoldConfig{
    72  		AgentName:                    "testing",
    73  		APICallerName:                "another string",
    74  		Logger:                       &noOpLogger{},
    75  		MachineLock:                  &fakeMachineLock{},
    76  		NewCredentialValidatorFacade: func(base.APICaller) (common.CredentialAPI, error) { return nil, nil },
    77  	}
    78  	err := cfg.Validate()
    79  	c.Assert(err, gc.ErrorMatches, "missing Container Type not valid")
    80  }
    81  
    82  func (s *containerManifoldSuite) TestConfigValidateSuccess(c *gc.C) {
    83  	cfg := provisioner.ContainerManifoldConfig{
    84  		AgentName:                    "testing",
    85  		APICallerName:                "another string",
    86  		Logger:                       &noOpLogger{},
    87  		MachineLock:                  &fakeMachineLock{},
    88  		NewCredentialValidatorFacade: func(base.APICaller) (common.CredentialAPI, error) { return nil, nil },
    89  		ContainerType:                instance.LXD,
    90  	}
    91  	err := cfg.Validate()
    92  	c.Assert(err, jc.ErrorIsNil)
    93  }
    94  
    95  func (s *containerManifoldSuite) TestContainerProvisioningManifold(c *gc.C) {
    96  	defer s.setupMocks(c).Finish()
    97  
    98  	tag := names.NewMachineTag("42")
    99  	retval := []provisioner.ContainerMachineResult{
   100  		{Machine: s.machine},
   101  	}
   102  	s.getter.EXPECT().Machines([]names.MachineTag{tag}).Return(retval, nil)
   103  	s.machine.EXPECT().SupportedContainers().Return([]instance.ContainerType{instance.LXD}, true, nil)
   104  	s.machine.EXPECT().Life().Return(life.Alive)
   105  	cfg := provisioner.ContainerManifoldConfig{
   106  		Logger:        &noOpLogger{},
   107  		ContainerType: instance.LXD,
   108  	}
   109  	m, err := provisioner.MachineSupportsContainers(cfg, s.getter, tag)
   110  	c.Assert(err, jc.ErrorIsNil)
   111  	c.Assert(m, gc.NotNil)
   112  }
   113  
   114  func (s *containerManifoldSuite) TestContainerProvisioningManifoldContainersNotKnown(c *gc.C) {
   115  	defer s.setupMocks(c).Finish()
   116  
   117  	tag := names.NewMachineTag("42")
   118  	retval := []provisioner.ContainerMachineResult{
   119  		{Machine: s.machine},
   120  	}
   121  	s.getter.EXPECT().Machines([]names.MachineTag{tag}).Return(retval, nil)
   122  	s.machine.EXPECT().SupportedContainers().Return(nil, false, nil)
   123  	s.machine.EXPECT().Life().Return(life.Alive)
   124  	cfg := provisioner.ContainerManifoldConfig{
   125  		Logger:        &noOpLogger{},
   126  		ContainerType: instance.LXD,
   127  	}
   128  	_, err := provisioner.MachineSupportsContainers(cfg, s.getter, tag)
   129  	c.Assert(errors.Is(err, errors.NotYetAvailable), jc.IsTrue)
   130  }
   131  
   132  func (s *containerManifoldSuite) TestContainerProvisioningManifoldNoContainerSupport(c *gc.C) {
   133  	defer s.setupMocks(c).Finish()
   134  
   135  	tag := names.NewMachineTag("42")
   136  	retval := []provisioner.ContainerMachineResult{
   137  		{Machine: s.machine},
   138  	}
   139  	s.getter.EXPECT().Machines([]names.MachineTag{tag}).Return(retval, nil)
   140  	s.machine.EXPECT().SupportedContainers().Return(nil, true, nil)
   141  	s.machine.EXPECT().Life().Return(life.Alive)
   142  	cfg := provisioner.ContainerManifoldConfig{
   143  		Logger:        &noOpLogger{},
   144  		ContainerType: instance.LXD,
   145  	}
   146  	_, err := provisioner.MachineSupportsContainers(cfg, s.getter, tag)
   147  	c.Assert(err, gc.ErrorMatches, "resource permanently unavailable")
   148  }
   149  
   150  func (s *containerManifoldSuite) TestContainerProvisioningManifoldMachineDead(c *gc.C) {
   151  	defer s.setupMocks(c).Finish()
   152  
   153  	tag := names.NewMachineTag("42")
   154  	retval := []provisioner.ContainerMachineResult{
   155  		{Machine: s.machine},
   156  	}
   157  	s.getter.EXPECT().Machines([]names.MachineTag{tag}).Return(retval, nil)
   158  	s.machine.EXPECT().Life().Return(life.Dead)
   159  	cfg := provisioner.ContainerManifoldConfig{
   160  		Logger:        &noOpLogger{},
   161  		ContainerType: instance.LXD,
   162  	}
   163  	_, err := provisioner.MachineSupportsContainers(cfg, s.getter, tag)
   164  	c.Assert(err, gc.ErrorMatches, "resource permanently unavailable")
   165  }
   166  
   167  func (s *containerManifoldSuite) setupMocks(c *gc.C) *gomock.Controller {
   168  	ctrl := gomock.NewController(c)
   169  
   170  	s.machine = mocks.NewMockContainerMachine(ctrl)
   171  	s.getter = mocks.NewMockContainerMachineGetter(ctrl)
   172  
   173  	return ctrl
   174  }