From 9341d4d86b16b51db119749db830e62ef60eba19 Mon Sep 17 00:00:00 2001 From: Jack Shaw Date: Fri, 18 Aug 2023 11:31:19 +0100 Subject: [PATCH] Use generated mocks in core/charm/baseselector_test.go --- core/charm/baseselector_test.go | 78 ++++++++++----------- core/charm/core_charm_mock_test.go | 106 +++++++++++++++++++++++++++++ core/charm/package_test.go | 1 + 3 files changed, 147 insertions(+), 38 deletions(-) create mode 100644 core/charm/core_charm_mock_test.go diff --git a/core/charm/baseselector_test.go b/core/charm/baseselector_test.go index 50e11c53dfee..d86d54d039ed 100644 --- a/core/charm/baseselector_test.go +++ b/core/charm/baseselector_test.go @@ -7,6 +7,7 @@ import ( "github.com/juju/collections/set" "github.com/juju/testing" jc "github.com/juju/testing/checkers" + "go.uber.org/mock/gomock" gc "gopkg.in/check.v1" "github.com/juju/juju/core/base" @@ -15,6 +16,9 @@ import ( type baseSelectorSuite struct { testing.IsolationSuite + + logger *MockSelectorLogger + cfg *MockSelectorModelConfig } var _ = gc.Suite(&baseSelectorSuite{}) @@ -32,7 +36,20 @@ var ( jujuDefault = version.DefaultSupportedLTSBase() ) +func (s *baseSelectorSuite) setup(c *gc.C) *gomock.Controller { + ctrl := gomock.NewController(c) + s.logger = NewMockSelectorLogger(ctrl) + s.logger.EXPECT().Infof(gomock.Any(), gomock.Any()).AnyTimes() + s.logger.EXPECT().Tracef(gomock.Any(), gomock.Any()).AnyTimes() + + s.cfg = NewMockSelectorModelConfig(ctrl) + + return ctrl +} + func (s *baseSelectorSuite) TestCharmBase(c *gc.C) { + defer s.setup(c).Finish() + deployBasesTests := []struct { title string selector BaseSelector @@ -139,11 +156,7 @@ func (s *baseSelectorSuite) TestCharmBase(c *gc.C) { for i, test := range deployBasesTests { c.Logf("test %d [%s]", i, test.title) - test.selector.logger = &noOpLogger{} - // For test purposes, change the supportedJujuBases to a consistent - // known value. Allowing for juju supported bases to change without - // making the tests fail. - //baseSelect.supportedJujuBases = []base.Base{bionic, focal, cosmic} + test.selector.logger = s.logger base, err := test.selector.CharmBase() if test.err != "" { c.Check(err, gc.ErrorMatches, test.err) @@ -156,6 +169,8 @@ func (s *baseSelectorSuite) TestCharmBase(c *gc.C) { } func (s *baseSelectorSuite) TestValidate(c *gc.C) { + defer s.setup(c).Finish() + deploySeriesTests := []struct { title string selector BaseSelector @@ -199,7 +214,7 @@ func (s *baseSelectorSuite) TestValidate(c *gc.C) { for i, test := range deploySeriesTests { c.Logf("test %d [%s]", i, test.title) - test.selector.logger = &noOpLogger{} + test.selector.logger = s.logger test.selector.jujuSupportedBases = set.NewStrings() _, err := test.selector.validate(test.supportedCharmBases, test.supportedJujuBases) if test.err != "" { @@ -211,10 +226,13 @@ func (s *baseSelectorSuite) TestValidate(c *gc.C) { } func (s *baseSelectorSuite) TestConfigureBaseSelector(c *gc.C) { + defer s.setup(c).Finish() + + s.cfg.EXPECT().DefaultBase() cfg := SelectorConfig{ - Config: mockModelCfg{}, + Config: s.cfg, Force: false, - Logger: &noOpLogger{}, + Logger: s.logger, RequestedBase: base.Base{}, SupportedCharmBases: []base.Base{jammy, focal, bionic}, WorkloadBases: []base.Base{jammy, focal}, @@ -227,14 +245,16 @@ func (s *baseSelectorSuite) TestConfigureBaseSelector(c *gc.C) { } func (s *baseSelectorSuite) TestConfigureBaseSelectorCentos(c *gc.C) { + defer s.setup(c).Finish() + s.cfg.EXPECT().DefaultBase() c7 := base.MustParseBaseFromString("centos@7/stable") c8 := base.MustParseBaseFromString("centos@8/stable") c6 := base.MustParseBaseFromString("centos@6/stable") cfg := SelectorConfig{ - Config: mockModelCfg{}, + Config: s.cfg, Force: false, - Logger: &noOpLogger{}, + Logger: s.logger, RequestedBase: base.Base{}, SupportedCharmBases: []base.Base{c6, c7, c8}, WorkloadBases: []base.Base{c7, c8}, @@ -247,13 +267,13 @@ func (s *baseSelectorSuite) TestConfigureBaseSelectorCentos(c *gc.C) { } func (s *baseSelectorSuite) TestConfigureBaseSelectorDefaultBase(c *gc.C) { + defer s.setup(c).Finish() + + s.cfg.EXPECT().DefaultBase().Return("ubuntu@20.04", true) cfg := SelectorConfig{ - Config: mockModelCfg{ - base: "ubuntu@20.04", - explicit: true, - }, + Config: s.cfg, Force: false, - Logger: &noOpLogger{}, + Logger: s.logger, RequestedBase: base.Base{}, SupportedCharmBases: []base.Base{jammy, focal, bionic}, WorkloadBases: []base.Base{jammy, focal}, @@ -273,13 +293,13 @@ func (s *baseSelectorSuite) TestConfigureBaseSelectorDefaultBase(c *gc.C) { } func (s *baseSelectorSuite) TestConfigureBaseSelectorDefaultBaseFail(c *gc.C) { + defer s.setup(c).Finish() + + s.cfg.EXPECT().DefaultBase().Return("ubuntu@18.04", true) cfg := SelectorConfig{ - Config: mockModelCfg{ - base: "ubuntu@18.04", - explicit: true, - }, + Config: s.cfg, Force: false, - Logger: &noOpLogger{}, + Logger: s.logger, RequestedBase: base.Base{}, SupportedCharmBases: []base.Base{jammy, focal, bionic}, WorkloadBases: []base.Base{jammy, focal}, @@ -291,21 +311,3 @@ func (s *baseSelectorSuite) TestConfigureBaseSelectorDefaultBaseFail(c *gc.C) { _, err = baseSelector.CharmBase() c.Assert(err, gc.ErrorMatches, `base: ubuntu@18.04/stable`) } - -type mockModelCfg struct { - base string - explicit bool -} - -func (d mockModelCfg) DefaultBase() (string, bool) { - return d.base, d.explicit -} - -func (d mockModelCfg) ImageStream() string { - return "released" -} - -type noOpLogger struct{} - -func (noOpLogger) Infof(string, ...interface{}) {} -func (noOpLogger) Tracef(string, ...interface{}) {} diff --git a/core/charm/core_charm_mock_test.go b/core/charm/core_charm_mock_test.go new file mode 100644 index 000000000000..0e0308097fe0 --- /dev/null +++ b/core/charm/core_charm_mock_test.go @@ -0,0 +1,106 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/juju/juju/core/charm (interfaces: SelectorLogger,SelectorModelConfig) + +// Package charm is a generated GoMock package. +package charm + +import ( + reflect "reflect" + + gomock "go.uber.org/mock/gomock" +) + +// MockSelectorLogger is a mock of SelectorLogger interface. +type MockSelectorLogger struct { + ctrl *gomock.Controller + recorder *MockSelectorLoggerMockRecorder +} + +// MockSelectorLoggerMockRecorder is the mock recorder for MockSelectorLogger. +type MockSelectorLoggerMockRecorder struct { + mock *MockSelectorLogger +} + +// NewMockSelectorLogger creates a new mock instance. +func NewMockSelectorLogger(ctrl *gomock.Controller) *MockSelectorLogger { + mock := &MockSelectorLogger{ctrl: ctrl} + mock.recorder = &MockSelectorLoggerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockSelectorLogger) EXPECT() *MockSelectorLoggerMockRecorder { + return m.recorder +} + +// Infof mocks base method. +func (m *MockSelectorLogger) Infof(arg0 string, arg1 ...interface{}) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + m.ctrl.Call(m, "Infof", varargs...) +} + +// Infof indicates an expected call of Infof. +func (mr *MockSelectorLoggerMockRecorder) Infof(arg0 interface{}, arg1 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Infof", reflect.TypeOf((*MockSelectorLogger)(nil).Infof), varargs...) +} + +// Tracef mocks base method. +func (m *MockSelectorLogger) Tracef(arg0 string, arg1 ...interface{}) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + m.ctrl.Call(m, "Tracef", varargs...) +} + +// Tracef indicates an expected call of Tracef. +func (mr *MockSelectorLoggerMockRecorder) Tracef(arg0 interface{}, arg1 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Tracef", reflect.TypeOf((*MockSelectorLogger)(nil).Tracef), varargs...) +} + +// MockSelectorModelConfig is a mock of SelectorModelConfig interface. +type MockSelectorModelConfig struct { + ctrl *gomock.Controller + recorder *MockSelectorModelConfigMockRecorder +} + +// MockSelectorModelConfigMockRecorder is the mock recorder for MockSelectorModelConfig. +type MockSelectorModelConfigMockRecorder struct { + mock *MockSelectorModelConfig +} + +// NewMockSelectorModelConfig creates a new mock instance. +func NewMockSelectorModelConfig(ctrl *gomock.Controller) *MockSelectorModelConfig { + mock := &MockSelectorModelConfig{ctrl: ctrl} + mock.recorder = &MockSelectorModelConfigMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockSelectorModelConfig) EXPECT() *MockSelectorModelConfigMockRecorder { + return m.recorder +} + +// DefaultBase mocks base method. +func (m *MockSelectorModelConfig) DefaultBase() (string, bool) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DefaultBase") + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(bool) + return ret0, ret1 +} + +// DefaultBase indicates an expected call of DefaultBase. +func (mr *MockSelectorModelConfigMockRecorder) DefaultBase() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DefaultBase", reflect.TypeOf((*MockSelectorModelConfig)(nil).DefaultBase)) +} diff --git a/core/charm/package_test.go b/core/charm/package_test.go index 1c0fffae20ac..facd8da45cc8 100644 --- a/core/charm/package_test.go +++ b/core/charm/package_test.go @@ -10,6 +10,7 @@ import ( ) //go:generate go run go.uber.org/mock/mockgen -package charm -destination charm_mock_test.go github.com/juju/charm/v11 CharmMeta +//go:generate go run go.uber.org/mock/mockgen -package charm -destination core_charm_mock_test.go github.com/juju/juju/core/charm SelectorLogger,SelectorModelConfig func TestPackage(t *testing.T) { gc.TestingT(t)