github.com/juju/juju@v0.0.0-20240430160146-1752b71fcf00/core/base/supported_test.go (about)

     1  // Copyright 2020 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package base
     5  
     6  import (
     7  	"github.com/juju/clock"
     8  	"github.com/juju/os/v2/series"
     9  	"github.com/juju/testing"
    10  	jc "github.com/juju/testing/checkers"
    11  	"go.uber.org/mock/gomock"
    12  	gc "gopkg.in/check.v1"
    13  )
    14  
    15  type SupportedSuite struct {
    16  	testing.IsolationSuite
    17  }
    18  
    19  var _ = gc.Suite(&SupportedSuite{})
    20  
    21  func (s *SupportedSuite) TestCompileForControllers(c *gc.C) {
    22  	ctrl := gomock.NewController(c)
    23  	defer ctrl.Finish()
    24  
    25  	now := clock.WallClock.Now()
    26  
    27  	mockDistroSource := NewMockDistroSource(ctrl)
    28  	mockDistroSource.EXPECT().Refresh().Return(nil)
    29  	mockDistroSource.EXPECT().SeriesInfo("supported").Return(series.DistroInfoSerie{
    30  		Released: now.AddDate(0, 0, -1),
    31  		EOL:      now.AddDate(0, 0, 1),
    32  	}, true)
    33  	mockDistroSource.EXPECT().SeriesInfo("deprecated-lts").Return(series.DistroInfoSerie{
    34  		Released: now.AddDate(0, 0, -1),
    35  		EOL:      now.AddDate(0, 0, 1),
    36  	}, true)
    37  	mockDistroSource.EXPECT().SeriesInfo("not-updated").Return(series.DistroInfoSerie{
    38  		Released: now.AddDate(0, 0, 1),
    39  		EOL:      now.AddDate(0, 0, 2),
    40  	}, true)
    41  	mockDistroSource.EXPECT().SeriesInfo("ignored").Return(series.DistroInfoSerie{}, false)
    42  
    43  	preset := map[SeriesName]seriesVersion{
    44  		"supported": {
    45  			WorkloadType: ControllerWorkloadType,
    46  			OS:           "foo",
    47  			Version:      "1.1.1",
    48  			Supported:    true,
    49  		},
    50  		"deprecated-lts": {
    51  			WorkloadType: ControllerWorkloadType,
    52  			OS:           "foo",
    53  			Version:      "1.1.2",
    54  			Supported:    false,
    55  		},
    56  		"not-updated": {
    57  			WorkloadType: ControllerWorkloadType,
    58  			OS:           "foo",
    59  			Version:      "1.1.3",
    60  			Supported:    false,
    61  		},
    62  		"ignored": {
    63  			WorkloadType: ControllerWorkloadType,
    64  			OS:           "foo",
    65  			Version:      "1.1.4",
    66  			Supported:    false,
    67  		},
    68  	}
    69  
    70  	info := newSupportedInfo(mockDistroSource, preset)
    71  	err := info.compile(now)
    72  	c.Assert(err, jc.ErrorIsNil)
    73  
    74  	ctrlBases := info.controllerBases()
    75  
    76  	c.Assert(ctrlBases, jc.DeepEquals, []Base{MustParseBaseFromString("foo@1.1.1")})
    77  }
    78  
    79  func (s *SupportedSuite) TestCompileForControllersWithOverride(c *gc.C) {
    80  	ctrl := gomock.NewController(c)
    81  	defer ctrl.Finish()
    82  
    83  	now := clock.WallClock.Now()
    84  
    85  	mockDistroSource := NewMockDistroSource(ctrl)
    86  	mockDistroSource.EXPECT().Refresh().Return(nil)
    87  	mockDistroSource.EXPECT().SeriesInfo("supported").Return(series.DistroInfoSerie{
    88  		Released: now.AddDate(0, 0, 9),
    89  		EOL:      now.AddDate(0, 0, 10),
    90  	}, true)
    91  
    92  	preset := map[SeriesName]seriesVersion{
    93  		"supported": {
    94  			WorkloadType:           ControllerWorkloadType,
    95  			OS:                     "foo",
    96  			Version:                "1.1.1",
    97  			Supported:              true,
    98  			IgnoreDistroInfoUpdate: true,
    99  		},
   100  	}
   101  
   102  	info := newSupportedInfo(mockDistroSource, preset)
   103  	err := info.compile(now)
   104  	c.Assert(err, jc.ErrorIsNil)
   105  
   106  	ctrlBases := info.controllerBases()
   107  
   108  	c.Assert(ctrlBases, jc.DeepEquals, []Base{MustParseBaseFromString("foo@1.1.1")})
   109  }
   110  
   111  func (s *SupportedSuite) TestCompileForControllersNoUpdate(c *gc.C) {
   112  	ctrl := gomock.NewController(c)
   113  	defer ctrl.Finish()
   114  
   115  	now := clock.WallClock.Now()
   116  
   117  	mockDistroSource := NewMockDistroSource(ctrl)
   118  	mockDistroSource.EXPECT().Refresh().Return(nil)
   119  	mockDistroSource.EXPECT().SeriesInfo("supported").Return(series.DistroInfoSerie{
   120  		Released: now.AddDate(0, 0, 9),
   121  		EOL:      now.AddDate(0, 0, 10),
   122  	}, true)
   123  
   124  	preset := map[SeriesName]seriesVersion{
   125  		"supported": {
   126  			WorkloadType:           ControllerWorkloadType,
   127  			OS:                     "foo",
   128  			Version:                "1.1.1",
   129  			Supported:              false,
   130  			IgnoreDistroInfoUpdate: false,
   131  		},
   132  	}
   133  
   134  	info := newSupportedInfo(mockDistroSource, preset)
   135  	err := info.compile(now)
   136  	c.Assert(err, jc.ErrorIsNil)
   137  
   138  	ctrlBases := info.controllerBases()
   139  
   140  	c.Assert(ctrlBases, jc.DeepEquals, []Base{})
   141  }
   142  
   143  func (s *SupportedSuite) TestCompileForControllersUpdated(c *gc.C) {
   144  	ctrl := gomock.NewController(c)
   145  	defer ctrl.Finish()
   146  
   147  	now := clock.WallClock.Now()
   148  
   149  	mockDistroSource := NewMockDistroSource(ctrl)
   150  	mockDistroSource.EXPECT().Refresh().Return(nil)
   151  	mockDistroSource.EXPECT().SeriesInfo("supported").Return(series.DistroInfoSerie{
   152  		Released: now.AddDate(0, 0, -10),
   153  		EOL:      now.AddDate(0, 0, -9),
   154  	}, true)
   155  
   156  	preset := map[SeriesName]seriesVersion{
   157  		"supported": {
   158  			WorkloadType:           ControllerWorkloadType,
   159  			OS:                     "foo",
   160  			Version:                "1.1.1",
   161  			Supported:              true,
   162  			IgnoreDistroInfoUpdate: false,
   163  		},
   164  	}
   165  
   166  	info := newSupportedInfo(mockDistroSource, preset)
   167  	err := info.compile(now)
   168  	c.Assert(err, jc.ErrorIsNil)
   169  
   170  	ctrlBases := info.controllerBases()
   171  
   172  	c.Assert(ctrlBases, jc.DeepEquals, []Base{})
   173  }
   174  
   175  func (s *SupportedSuite) TestCompileForControllersWithoutOverride(c *gc.C) {
   176  	ctrl := gomock.NewController(c)
   177  	defer ctrl.Finish()
   178  
   179  	now := clock.WallClock.Now()
   180  
   181  	mockDistroSource := NewMockDistroSource(ctrl)
   182  	mockDistroSource.EXPECT().Refresh().Return(nil)
   183  	mockDistroSource.EXPECT().SeriesInfo("supported").Return(series.DistroInfoSerie{
   184  		Released: now.AddDate(0, 0, 9),
   185  		EOL:      now.AddDate(0, 0, 10),
   186  	}, true)
   187  
   188  	preset := map[SeriesName]seriesVersion{
   189  		"supported": {
   190  			WorkloadType: ControllerWorkloadType,
   191  			OS:           "foo",
   192  			Version:      "1.1.1",
   193  			Supported:    true,
   194  		},
   195  	}
   196  
   197  	info := newSupportedInfo(mockDistroSource, preset)
   198  	err := info.compile(now)
   199  	c.Assert(err, jc.ErrorIsNil)
   200  
   201  	ctrlBases := info.controllerBases()
   202  
   203  	c.Assert(ctrlBases, jc.DeepEquals, []Base{})
   204  }
   205  
   206  func (s *SupportedSuite) TestCompileForWorkloads(c *gc.C) {
   207  	ctrl := gomock.NewController(c)
   208  	defer ctrl.Finish()
   209  
   210  	now := clock.WallClock.Now()
   211  
   212  	mockDistroSource := NewMockDistroSource(ctrl)
   213  	mockDistroSource.EXPECT().Refresh().Return(nil)
   214  	mockDistroSource.EXPECT().SeriesInfo("ctrl-supported").Return(series.DistroInfoSerie{
   215  		Released: now.AddDate(0, 0, -1),
   216  		EOL:      now.AddDate(0, 0, 1),
   217  	}, true)
   218  	mockDistroSource.EXPECT().SeriesInfo("ctrl-deprecated-lts").Return(series.DistroInfoSerie{
   219  		Released: now.AddDate(0, 0, -1),
   220  		EOL:      now.AddDate(0, 0, 1),
   221  	}, true)
   222  	mockDistroSource.EXPECT().SeriesInfo("ctrl-not-updated").Return(series.DistroInfoSerie{
   223  		Released: now.AddDate(0, 0, 1),
   224  		EOL:      now.AddDate(0, 0, 2),
   225  	}, true)
   226  	mockDistroSource.EXPECT().SeriesInfo("ctrl-ignored").Return(series.DistroInfoSerie{}, false)
   227  	mockDistroSource.EXPECT().SeriesInfo("work-supported").Return(series.DistroInfoSerie{
   228  		Released: now.AddDate(0, 0, -1),
   229  		EOL:      now.AddDate(0, 0, 1),
   230  	}, true)
   231  	mockDistroSource.EXPECT().SeriesInfo("work-deprecated-lts").Return(series.DistroInfoSerie{
   232  		Released: now.AddDate(0, 0, -1),
   233  		EOL:      now.AddDate(0, 0, 1),
   234  	}, true)
   235  	mockDistroSource.EXPECT().SeriesInfo("work-not-updated").Return(series.DistroInfoSerie{
   236  		Released: now.AddDate(0, 0, 1),
   237  		EOL:      now.AddDate(0, 0, 2),
   238  	}, true)
   239  	mockDistroSource.EXPECT().SeriesInfo("work-ignored").Return(series.DistroInfoSerie{}, false)
   240  
   241  	preset := map[SeriesName]seriesVersion{
   242  		"ctrl-supported": {
   243  			WorkloadType: ControllerWorkloadType,
   244  			OS:           "foo",
   245  			Version:      "1.1.1",
   246  			Supported:    true,
   247  		},
   248  		"ctrl-deprecated-lts": {
   249  			WorkloadType: ControllerWorkloadType,
   250  			OS:           "foo",
   251  			Version:      "1.1.2",
   252  			Supported:    false,
   253  		},
   254  		"ctrl-not-updated": {
   255  			WorkloadType: ControllerWorkloadType,
   256  			OS:           "foo",
   257  			Version:      "1.1.3",
   258  			Supported:    false,
   259  		},
   260  		"ctrl-ignored": {
   261  			WorkloadType: ControllerWorkloadType,
   262  			OS:           "foo",
   263  			Version:      "1.1.4",
   264  			Supported:    false,
   265  		},
   266  		"work-supported": {
   267  			WorkloadType: OtherWorkloadType,
   268  			OS:           "foo",
   269  			Version:      "1.1.5",
   270  			Supported:    true,
   271  		},
   272  		"work-deprecated-lts": {
   273  			WorkloadType: OtherWorkloadType,
   274  			OS:           "foo",
   275  			Version:      "1.1.6",
   276  			Supported:    false,
   277  		},
   278  		"work-not-updated": {
   279  			WorkloadType: OtherWorkloadType,
   280  			OS:           "foo",
   281  			Version:      "1.1.7",
   282  			Supported:    false,
   283  		},
   284  		"work-ignored": {
   285  			WorkloadType: OtherWorkloadType,
   286  			OS:           "foo",
   287  			Version:      "1.1.8",
   288  			Supported:    false,
   289  		},
   290  	}
   291  
   292  	info := newSupportedInfo(mockDistroSource, preset)
   293  	err := info.compile(now)
   294  	c.Assert(err, jc.ErrorIsNil)
   295  
   296  	workloadBases := info.workloadBases(false)
   297  
   298  	c.Assert(workloadBases, jc.DeepEquals, []Base{MustParseBaseFromString("foo@1.1.1"), MustParseBaseFromString("foo@1.1.5")})
   299  
   300  	// Double check that controller series doesn't change when we have workload
   301  	// types.
   302  	ctrlBases := info.controllerBases()
   303  
   304  	c.Assert(ctrlBases, jc.DeepEquals, []Base{MustParseBaseFromString("foo@1.1.1")})
   305  }