github.com/choria-io/go-choria@v0.28.1-0.20240416190746-b3bf9c7d5a45/aagent/model/model_mock.go (about)

     1  // Code generated by MockGen. DO NOT EDIT.
     2  // Source: github.com/choria-io/go-choria/aagent/model (interfaces: Watcher,WatcherConstructor,ChoriaProvider,Machine)
     3  
     4  // mockgen -package model -destination model_mock.go github.com/choria-io/go-choria/aagent/model Watcher,WatcherConstructor,ChoriaProvider,Machine
     5  
     6  // Package model is a generated GoMock package.
     7  package model
     8  
     9  import (
    10  	context "context"
    11  	json "encoding/json"
    12  	reflect "reflect"
    13  	sync "sync"
    14  	time "time"
    15  
    16  	inter "github.com/choria-io/go-choria/inter"
    17  	lifecycle "github.com/choria-io/go-choria/lifecycle"
    18  	gomock "github.com/golang/mock/gomock"
    19  	jsm_go "github.com/nats-io/jsm.go"
    20  	logrus "github.com/sirupsen/logrus"
    21  )
    22  
    23  // MockWatcher is a mock of Watcher interface.
    24  type MockWatcher struct {
    25  	ctrl     *gomock.Controller
    26  	recorder *MockWatcherMockRecorder
    27  }
    28  
    29  // MockWatcherMockRecorder is the mock recorder for MockWatcher.
    30  type MockWatcherMockRecorder struct {
    31  	mock *MockWatcher
    32  }
    33  
    34  // NewMockWatcher creates a new mock instance.
    35  func NewMockWatcher(ctrl *gomock.Controller) *MockWatcher {
    36  	mock := &MockWatcher{ctrl: ctrl}
    37  	mock.recorder = &MockWatcherMockRecorder{mock}
    38  	return mock
    39  }
    40  
    41  // EXPECT returns an object that allows the caller to indicate expected use.
    42  func (m *MockWatcher) EXPECT() *MockWatcherMockRecorder {
    43  	return m.recorder
    44  }
    45  
    46  // AnnounceInterval mocks base method.
    47  func (m *MockWatcher) AnnounceInterval() time.Duration {
    48  	m.ctrl.T.Helper()
    49  	ret := m.ctrl.Call(m, "AnnounceInterval")
    50  	ret0, _ := ret[0].(time.Duration)
    51  	return ret0
    52  }
    53  
    54  // AnnounceInterval indicates an expected call of AnnounceInterval.
    55  func (mr *MockWatcherMockRecorder) AnnounceInterval() *gomock.Call {
    56  	mr.mock.ctrl.T.Helper()
    57  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AnnounceInterval", reflect.TypeOf((*MockWatcher)(nil).AnnounceInterval))
    58  }
    59  
    60  // CurrentState mocks base method.
    61  func (m *MockWatcher) CurrentState() interface{} {
    62  	m.ctrl.T.Helper()
    63  	ret := m.ctrl.Call(m, "CurrentState")
    64  	ret0, _ := ret[0].(interface{})
    65  	return ret0
    66  }
    67  
    68  // CurrentState indicates an expected call of CurrentState.
    69  func (mr *MockWatcherMockRecorder) CurrentState() *gomock.Call {
    70  	mr.mock.ctrl.T.Helper()
    71  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CurrentState", reflect.TypeOf((*MockWatcher)(nil).CurrentState))
    72  }
    73  
    74  // Delete mocks base method.
    75  func (m *MockWatcher) Delete() {
    76  	m.ctrl.T.Helper()
    77  	m.ctrl.Call(m, "Delete")
    78  }
    79  
    80  // Delete indicates an expected call of Delete.
    81  func (mr *MockWatcherMockRecorder) Delete() *gomock.Call {
    82  	mr.mock.ctrl.T.Helper()
    83  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockWatcher)(nil).Delete))
    84  }
    85  
    86  // Name mocks base method.
    87  func (m *MockWatcher) Name() string {
    88  	m.ctrl.T.Helper()
    89  	ret := m.ctrl.Call(m, "Name")
    90  	ret0, _ := ret[0].(string)
    91  	return ret0
    92  }
    93  
    94  // Name indicates an expected call of Name.
    95  func (mr *MockWatcherMockRecorder) Name() *gomock.Call {
    96  	mr.mock.ctrl.T.Helper()
    97  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockWatcher)(nil).Name))
    98  }
    99  
   100  // NotifyStateChance mocks base method.
   101  func (m *MockWatcher) NotifyStateChance() {
   102  	m.ctrl.T.Helper()
   103  	m.ctrl.Call(m, "NotifyStateChance")
   104  }
   105  
   106  // NotifyStateChance indicates an expected call of NotifyStateChance.
   107  func (mr *MockWatcherMockRecorder) NotifyStateChance() *gomock.Call {
   108  	mr.mock.ctrl.T.Helper()
   109  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyStateChance", reflect.TypeOf((*MockWatcher)(nil).NotifyStateChance))
   110  }
   111  
   112  // Run mocks base method.
   113  func (m *MockWatcher) Run(arg0 context.Context, arg1 *sync.WaitGroup) {
   114  	m.ctrl.T.Helper()
   115  	m.ctrl.Call(m, "Run", arg0, arg1)
   116  }
   117  
   118  // Run indicates an expected call of Run.
   119  func (mr *MockWatcherMockRecorder) Run(arg0, arg1 interface{}) *gomock.Call {
   120  	mr.mock.ctrl.T.Helper()
   121  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockWatcher)(nil).Run), arg0, arg1)
   122  }
   123  
   124  // Type mocks base method.
   125  func (m *MockWatcher) Type() string {
   126  	m.ctrl.T.Helper()
   127  	ret := m.ctrl.Call(m, "Type")
   128  	ret0, _ := ret[0].(string)
   129  	return ret0
   130  }
   131  
   132  // Type indicates an expected call of Type.
   133  func (mr *MockWatcherMockRecorder) Type() *gomock.Call {
   134  	mr.mock.ctrl.T.Helper()
   135  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Type", reflect.TypeOf((*MockWatcher)(nil).Type))
   136  }
   137  
   138  // MockWatcherConstructor is a mock of WatcherConstructor interface.
   139  type MockWatcherConstructor struct {
   140  	ctrl     *gomock.Controller
   141  	recorder *MockWatcherConstructorMockRecorder
   142  }
   143  
   144  // MockWatcherConstructorMockRecorder is the mock recorder for MockWatcherConstructor.
   145  type MockWatcherConstructorMockRecorder struct {
   146  	mock *MockWatcherConstructor
   147  }
   148  
   149  // NewMockWatcherConstructor creates a new mock instance.
   150  func NewMockWatcherConstructor(ctrl *gomock.Controller) *MockWatcherConstructor {
   151  	mock := &MockWatcherConstructor{ctrl: ctrl}
   152  	mock.recorder = &MockWatcherConstructorMockRecorder{mock}
   153  	return mock
   154  }
   155  
   156  // EXPECT returns an object that allows the caller to indicate expected use.
   157  func (m *MockWatcherConstructor) EXPECT() *MockWatcherConstructorMockRecorder {
   158  	return m.recorder
   159  }
   160  
   161  // EventType mocks base method.
   162  func (m *MockWatcherConstructor) EventType() string {
   163  	m.ctrl.T.Helper()
   164  	ret := m.ctrl.Call(m, "EventType")
   165  	ret0, _ := ret[0].(string)
   166  	return ret0
   167  }
   168  
   169  // EventType indicates an expected call of EventType.
   170  func (mr *MockWatcherConstructorMockRecorder) EventType() *gomock.Call {
   171  	mr.mock.ctrl.T.Helper()
   172  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EventType", reflect.TypeOf((*MockWatcherConstructor)(nil).EventType))
   173  }
   174  
   175  // New mocks base method.
   176  func (m *MockWatcherConstructor) New(arg0 Machine, arg1 string, arg2 []string, arg3, arg4, arg5 string, arg6 time.Duration, arg7 map[string]interface{}) (interface{}, error) {
   177  	m.ctrl.T.Helper()
   178  	ret := m.ctrl.Call(m, "New", arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
   179  	ret0, _ := ret[0].(interface{})
   180  	ret1, _ := ret[1].(error)
   181  	return ret0, ret1
   182  }
   183  
   184  // New indicates an expected call of New.
   185  func (mr *MockWatcherConstructorMockRecorder) New(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7 interface{}) *gomock.Call {
   186  	mr.mock.ctrl.T.Helper()
   187  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "New", reflect.TypeOf((*MockWatcherConstructor)(nil).New), arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
   188  }
   189  
   190  // Type mocks base method.
   191  func (m *MockWatcherConstructor) Type() string {
   192  	m.ctrl.T.Helper()
   193  	ret := m.ctrl.Call(m, "Type")
   194  	ret0, _ := ret[0].(string)
   195  	return ret0
   196  }
   197  
   198  // Type indicates an expected call of Type.
   199  func (mr *MockWatcherConstructorMockRecorder) Type() *gomock.Call {
   200  	mr.mock.ctrl.T.Helper()
   201  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Type", reflect.TypeOf((*MockWatcherConstructor)(nil).Type))
   202  }
   203  
   204  // UnmarshalNotification mocks base method.
   205  func (m *MockWatcherConstructor) UnmarshalNotification(arg0 []byte) (interface{}, error) {
   206  	m.ctrl.T.Helper()
   207  	ret := m.ctrl.Call(m, "UnmarshalNotification", arg0)
   208  	ret0, _ := ret[0].(interface{})
   209  	ret1, _ := ret[1].(error)
   210  	return ret0, ret1
   211  }
   212  
   213  // UnmarshalNotification indicates an expected call of UnmarshalNotification.
   214  func (mr *MockWatcherConstructorMockRecorder) UnmarshalNotification(arg0 interface{}) *gomock.Call {
   215  	mr.mock.ctrl.T.Helper()
   216  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnmarshalNotification", reflect.TypeOf((*MockWatcherConstructor)(nil).UnmarshalNotification), arg0)
   217  }
   218  
   219  // MockChoriaProvider is a mock of ChoriaProvider interface.
   220  type MockChoriaProvider struct {
   221  	ctrl     *gomock.Controller
   222  	recorder *MockChoriaProviderMockRecorder
   223  }
   224  
   225  // MockChoriaProviderMockRecorder is the mock recorder for MockChoriaProvider.
   226  type MockChoriaProviderMockRecorder struct {
   227  	mock *MockChoriaProvider
   228  }
   229  
   230  // NewMockChoriaProvider creates a new mock instance.
   231  func NewMockChoriaProvider(ctrl *gomock.Controller) *MockChoriaProvider {
   232  	mock := &MockChoriaProvider{ctrl: ctrl}
   233  	mock.recorder = &MockChoriaProviderMockRecorder{mock}
   234  	return mock
   235  }
   236  
   237  // EXPECT returns an object that allows the caller to indicate expected use.
   238  func (m *MockChoriaProvider) EXPECT() *MockChoriaProviderMockRecorder {
   239  	return m.recorder
   240  }
   241  
   242  // Connector mocks base method.
   243  func (m *MockChoriaProvider) Connector() inter.Connector {
   244  	m.ctrl.T.Helper()
   245  	ret := m.ctrl.Call(m, "Connector")
   246  	ret0, _ := ret[0].(inter.Connector)
   247  	return ret0
   248  }
   249  
   250  // Connector indicates an expected call of Connector.
   251  func (mr *MockChoriaProviderMockRecorder) Connector() *gomock.Call {
   252  	mr.mock.ctrl.T.Helper()
   253  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Connector", reflect.TypeOf((*MockChoriaProvider)(nil).Connector))
   254  }
   255  
   256  // Facts mocks base method.
   257  func (m *MockChoriaProvider) Facts() json.RawMessage {
   258  	m.ctrl.T.Helper()
   259  	ret := m.ctrl.Call(m, "Facts")
   260  	ret0, _ := ret[0].(json.RawMessage)
   261  	return ret0
   262  }
   263  
   264  // Facts indicates an expected call of Facts.
   265  func (mr *MockChoriaProviderMockRecorder) Facts() *gomock.Call {
   266  	mr.mock.ctrl.T.Helper()
   267  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Facts", reflect.TypeOf((*MockChoriaProvider)(nil).Facts))
   268  }
   269  
   270  // Identity mocks base method.
   271  func (m *MockChoriaProvider) Identity() string {
   272  	m.ctrl.T.Helper()
   273  	ret := m.ctrl.Call(m, "Identity")
   274  	ret0, _ := ret[0].(string)
   275  	return ret0
   276  }
   277  
   278  // Identity indicates an expected call of Identity.
   279  func (mr *MockChoriaProviderMockRecorder) Identity() *gomock.Call {
   280  	mr.mock.ctrl.T.Helper()
   281  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Identity", reflect.TypeOf((*MockChoriaProvider)(nil).Identity))
   282  }
   283  
   284  // Logger mocks base method.
   285  func (m *MockChoriaProvider) Logger(arg0 string) *logrus.Entry {
   286  	m.ctrl.T.Helper()
   287  	ret := m.ctrl.Call(m, "Logger", arg0)
   288  	ret0, _ := ret[0].(*logrus.Entry)
   289  	return ret0
   290  }
   291  
   292  // Logger indicates an expected call of Logger.
   293  func (mr *MockChoriaProviderMockRecorder) Logger(arg0 interface{}) *gomock.Call {
   294  	mr.mock.ctrl.T.Helper()
   295  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Logger", reflect.TypeOf((*MockChoriaProvider)(nil).Logger), arg0)
   296  }
   297  
   298  // MainCollective mocks base method.
   299  func (m *MockChoriaProvider) MainCollective() string {
   300  	m.ctrl.T.Helper()
   301  	ret := m.ctrl.Call(m, "MainCollective")
   302  	ret0, _ := ret[0].(string)
   303  	return ret0
   304  }
   305  
   306  // MainCollective indicates an expected call of MainCollective.
   307  func (mr *MockChoriaProviderMockRecorder) MainCollective() *gomock.Call {
   308  	mr.mock.ctrl.T.Helper()
   309  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MainCollective", reflect.TypeOf((*MockChoriaProvider)(nil).MainCollective))
   310  }
   311  
   312  // PrometheusTextFileDir mocks base method.
   313  func (m *MockChoriaProvider) PrometheusTextFileDir() string {
   314  	m.ctrl.T.Helper()
   315  	ret := m.ctrl.Call(m, "PrometheusTextFileDir")
   316  	ret0, _ := ret[0].(string)
   317  	return ret0
   318  }
   319  
   320  // PrometheusTextFileDir indicates an expected call of PrometheusTextFileDir.
   321  func (mr *MockChoriaProviderMockRecorder) PrometheusTextFileDir() *gomock.Call {
   322  	mr.mock.ctrl.T.Helper()
   323  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrometheusTextFileDir", reflect.TypeOf((*MockChoriaProvider)(nil).PrometheusTextFileDir))
   324  }
   325  
   326  // PublishRaw mocks base method.
   327  func (m *MockChoriaProvider) PublishRaw(arg0 string, arg1 []byte) error {
   328  	m.ctrl.T.Helper()
   329  	ret := m.ctrl.Call(m, "PublishRaw", arg0, arg1)
   330  	ret0, _ := ret[0].(error)
   331  	return ret0
   332  }
   333  
   334  // PublishRaw indicates an expected call of PublishRaw.
   335  func (mr *MockChoriaProviderMockRecorder) PublishRaw(arg0, arg1 interface{}) *gomock.Call {
   336  	mr.mock.ctrl.T.Helper()
   337  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishRaw", reflect.TypeOf((*MockChoriaProvider)(nil).PublishRaw), arg0, arg1)
   338  }
   339  
   340  // ScoutOverridesPath mocks base method.
   341  func (m *MockChoriaProvider) ScoutOverridesPath() string {
   342  	m.ctrl.T.Helper()
   343  	ret := m.ctrl.Call(m, "ScoutOverridesPath")
   344  	ret0, _ := ret[0].(string)
   345  	return ret0
   346  }
   347  
   348  // ScoutOverridesPath indicates an expected call of ScoutOverridesPath.
   349  func (mr *MockChoriaProviderMockRecorder) ScoutOverridesPath() *gomock.Call {
   350  	mr.mock.ctrl.T.Helper()
   351  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScoutOverridesPath", reflect.TypeOf((*MockChoriaProvider)(nil).ScoutOverridesPath))
   352  }
   353  
   354  // ServerStatusFile mocks base method.
   355  func (m *MockChoriaProvider) ServerStatusFile() (string, int) {
   356  	m.ctrl.T.Helper()
   357  	ret := m.ctrl.Call(m, "ServerStatusFile")
   358  	ret0, _ := ret[0].(string)
   359  	ret1, _ := ret[1].(int)
   360  	return ret0, ret1
   361  }
   362  
   363  // ServerStatusFile indicates an expected call of ServerStatusFile.
   364  func (mr *MockChoriaProviderMockRecorder) ServerStatusFile() *gomock.Call {
   365  	mr.mock.ctrl.T.Helper()
   366  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServerStatusFile", reflect.TypeOf((*MockChoriaProvider)(nil).ServerStatusFile))
   367  }
   368  
   369  // MockMachine is a mock of Machine interface.
   370  type MockMachine struct {
   371  	ctrl     *gomock.Controller
   372  	recorder *MockMachineMockRecorder
   373  }
   374  
   375  // MockMachineMockRecorder is the mock recorder for MockMachine.
   376  type MockMachineMockRecorder struct {
   377  	mock *MockMachine
   378  }
   379  
   380  // NewMockMachine creates a new mock instance.
   381  func NewMockMachine(ctrl *gomock.Controller) *MockMachine {
   382  	mock := &MockMachine{ctrl: ctrl}
   383  	mock.recorder = &MockMachineMockRecorder{mock}
   384  	return mock
   385  }
   386  
   387  // EXPECT returns an object that allows the caller to indicate expected use.
   388  func (m *MockMachine) EXPECT() *MockMachineMockRecorder {
   389  	return m.recorder
   390  }
   391  
   392  // ChoriaStatusFile mocks base method.
   393  func (m *MockMachine) ChoriaStatusFile() (string, int) {
   394  	m.ctrl.T.Helper()
   395  	ret := m.ctrl.Call(m, "ChoriaStatusFile")
   396  	ret0, _ := ret[0].(string)
   397  	ret1, _ := ret[1].(int)
   398  	return ret0, ret1
   399  }
   400  
   401  // ChoriaStatusFile indicates an expected call of ChoriaStatusFile.
   402  func (mr *MockMachineMockRecorder) ChoriaStatusFile() *gomock.Call {
   403  	mr.mock.ctrl.T.Helper()
   404  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChoriaStatusFile", reflect.TypeOf((*MockMachine)(nil).ChoriaStatusFile))
   405  }
   406  
   407  // Data mocks base method.
   408  func (m *MockMachine) Data() map[string]interface{} {
   409  	m.ctrl.T.Helper()
   410  	ret := m.ctrl.Call(m, "Data")
   411  	ret0, _ := ret[0].(map[string]interface{})
   412  	return ret0
   413  }
   414  
   415  // Data indicates an expected call of Data.
   416  func (mr *MockMachineMockRecorder) Data() *gomock.Call {
   417  	mr.mock.ctrl.T.Helper()
   418  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Data", reflect.TypeOf((*MockMachine)(nil).Data))
   419  }
   420  
   421  // DataDelete mocks base method.
   422  func (m *MockMachine) DataDelete(arg0 string) error {
   423  	m.ctrl.T.Helper()
   424  	ret := m.ctrl.Call(m, "DataDelete", arg0)
   425  	ret0, _ := ret[0].(error)
   426  	return ret0
   427  }
   428  
   429  // DataDelete indicates an expected call of DataDelete.
   430  func (mr *MockMachineMockRecorder) DataDelete(arg0 interface{}) *gomock.Call {
   431  	mr.mock.ctrl.T.Helper()
   432  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DataDelete", reflect.TypeOf((*MockMachine)(nil).DataDelete), arg0)
   433  }
   434  
   435  // DataGet mocks base method.
   436  func (m *MockMachine) DataGet(arg0 string) (interface{}, bool) {
   437  	m.ctrl.T.Helper()
   438  	ret := m.ctrl.Call(m, "DataGet", arg0)
   439  	ret0, _ := ret[0].(interface{})
   440  	ret1, _ := ret[1].(bool)
   441  	return ret0, ret1
   442  }
   443  
   444  // DataGet indicates an expected call of DataGet.
   445  func (mr *MockMachineMockRecorder) DataGet(arg0 interface{}) *gomock.Call {
   446  	mr.mock.ctrl.T.Helper()
   447  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DataGet", reflect.TypeOf((*MockMachine)(nil).DataGet), arg0)
   448  }
   449  
   450  // DataPut mocks base method.
   451  func (m *MockMachine) DataPut(arg0 string, arg1 interface{}) error {
   452  	m.ctrl.T.Helper()
   453  	ret := m.ctrl.Call(m, "DataPut", arg0, arg1)
   454  	ret0, _ := ret[0].(error)
   455  	return ret0
   456  }
   457  
   458  // DataPut indicates an expected call of DataPut.
   459  func (mr *MockMachineMockRecorder) DataPut(arg0, arg1 interface{}) *gomock.Call {
   460  	mr.mock.ctrl.T.Helper()
   461  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DataPut", reflect.TypeOf((*MockMachine)(nil).DataPut), arg0, arg1)
   462  }
   463  
   464  // Debugf mocks base method.
   465  func (m *MockMachine) Debugf(arg0, arg1 string, arg2 ...interface{}) {
   466  	m.ctrl.T.Helper()
   467  	varargs := []interface{}{arg0, arg1}
   468  	for _, a := range arg2 {
   469  		varargs = append(varargs, a)
   470  	}
   471  	m.ctrl.Call(m, "Debugf", varargs...)
   472  }
   473  
   474  // Debugf indicates an expected call of Debugf.
   475  func (mr *MockMachineMockRecorder) Debugf(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   476  	mr.mock.ctrl.T.Helper()
   477  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   478  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debugf", reflect.TypeOf((*MockMachine)(nil).Debugf), varargs...)
   479  }
   480  
   481  // Directory mocks base method.
   482  func (m *MockMachine) Directory() string {
   483  	m.ctrl.T.Helper()
   484  	ret := m.ctrl.Call(m, "Directory")
   485  	ret0, _ := ret[0].(string)
   486  	return ret0
   487  }
   488  
   489  // Directory indicates an expected call of Directory.
   490  func (mr *MockMachineMockRecorder) Directory() *gomock.Call {
   491  	mr.mock.ctrl.T.Helper()
   492  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Directory", reflect.TypeOf((*MockMachine)(nil).Directory))
   493  }
   494  
   495  // Errorf mocks base method.
   496  func (m *MockMachine) Errorf(arg0, arg1 string, arg2 ...interface{}) {
   497  	m.ctrl.T.Helper()
   498  	varargs := []interface{}{arg0, arg1}
   499  	for _, a := range arg2 {
   500  		varargs = append(varargs, a)
   501  	}
   502  	m.ctrl.Call(m, "Errorf", varargs...)
   503  }
   504  
   505  // Errorf indicates an expected call of Errorf.
   506  func (mr *MockMachineMockRecorder) Errorf(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   507  	mr.mock.ctrl.T.Helper()
   508  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   509  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Errorf", reflect.TypeOf((*MockMachine)(nil).Errorf), varargs...)
   510  }
   511  
   512  // Facts mocks base method.
   513  func (m *MockMachine) Facts() json.RawMessage {
   514  	m.ctrl.T.Helper()
   515  	ret := m.ctrl.Call(m, "Facts")
   516  	ret0, _ := ret[0].(json.RawMessage)
   517  	return ret0
   518  }
   519  
   520  // Facts indicates an expected call of Facts.
   521  func (mr *MockMachineMockRecorder) Facts() *gomock.Call {
   522  	mr.mock.ctrl.T.Helper()
   523  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Facts", reflect.TypeOf((*MockMachine)(nil).Facts))
   524  }
   525  
   526  // Identity mocks base method.
   527  func (m *MockMachine) Identity() string {
   528  	m.ctrl.T.Helper()
   529  	ret := m.ctrl.Call(m, "Identity")
   530  	ret0, _ := ret[0].(string)
   531  	return ret0
   532  }
   533  
   534  // Identity indicates an expected call of Identity.
   535  func (mr *MockMachineMockRecorder) Identity() *gomock.Call {
   536  	mr.mock.ctrl.T.Helper()
   537  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Identity", reflect.TypeOf((*MockMachine)(nil).Identity))
   538  }
   539  
   540  // Infof mocks base method.
   541  func (m *MockMachine) Infof(arg0, arg1 string, arg2 ...interface{}) {
   542  	m.ctrl.T.Helper()
   543  	varargs := []interface{}{arg0, arg1}
   544  	for _, a := range arg2 {
   545  		varargs = append(varargs, a)
   546  	}
   547  	m.ctrl.Call(m, "Infof", varargs...)
   548  }
   549  
   550  // Infof indicates an expected call of Infof.
   551  func (mr *MockMachineMockRecorder) Infof(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   552  	mr.mock.ctrl.T.Helper()
   553  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   554  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Infof", reflect.TypeOf((*MockMachine)(nil).Infof), varargs...)
   555  }
   556  
   557  // InstanceID mocks base method.
   558  func (m *MockMachine) InstanceID() string {
   559  	m.ctrl.T.Helper()
   560  	ret := m.ctrl.Call(m, "InstanceID")
   561  	ret0, _ := ret[0].(string)
   562  	return ret0
   563  }
   564  
   565  // InstanceID indicates an expected call of InstanceID.
   566  func (mr *MockMachineMockRecorder) InstanceID() *gomock.Call {
   567  	mr.mock.ctrl.T.Helper()
   568  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceID", reflect.TypeOf((*MockMachine)(nil).InstanceID))
   569  }
   570  
   571  // JetStreamConnection mocks base method.
   572  func (m *MockMachine) JetStreamConnection() (*jsm_go.Manager, error) {
   573  	m.ctrl.T.Helper()
   574  	ret := m.ctrl.Call(m, "JetStreamConnection")
   575  	ret0, _ := ret[0].(*jsm_go.Manager)
   576  	ret1, _ := ret[1].(error)
   577  	return ret0, ret1
   578  }
   579  
   580  // JetStreamConnection indicates an expected call of JetStreamConnection.
   581  func (mr *MockMachineMockRecorder) JetStreamConnection() *gomock.Call {
   582  	mr.mock.ctrl.T.Helper()
   583  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JetStreamConnection", reflect.TypeOf((*MockMachine)(nil).JetStreamConnection))
   584  }
   585  
   586  // MainCollective mocks base method.
   587  func (m *MockMachine) MainCollective() string {
   588  	m.ctrl.T.Helper()
   589  	ret := m.ctrl.Call(m, "MainCollective")
   590  	ret0, _ := ret[0].(string)
   591  	return ret0
   592  }
   593  
   594  // MainCollective indicates an expected call of MainCollective.
   595  func (mr *MockMachineMockRecorder) MainCollective() *gomock.Call {
   596  	mr.mock.ctrl.T.Helper()
   597  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MainCollective", reflect.TypeOf((*MockMachine)(nil).MainCollective))
   598  }
   599  
   600  // Name mocks base method.
   601  func (m *MockMachine) Name() string {
   602  	m.ctrl.T.Helper()
   603  	ret := m.ctrl.Call(m, "Name")
   604  	ret0, _ := ret[0].(string)
   605  	return ret0
   606  }
   607  
   608  // Name indicates an expected call of Name.
   609  func (mr *MockMachineMockRecorder) Name() *gomock.Call {
   610  	mr.mock.ctrl.T.Helper()
   611  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockMachine)(nil).Name))
   612  }
   613  
   614  // NotifyWatcherState mocks base method.
   615  func (m *MockMachine) NotifyWatcherState(arg0 string, arg1 interface{}) {
   616  	m.ctrl.T.Helper()
   617  	m.ctrl.Call(m, "NotifyWatcherState", arg0, arg1)
   618  }
   619  
   620  // NotifyWatcherState indicates an expected call of NotifyWatcherState.
   621  func (mr *MockMachineMockRecorder) NotifyWatcherState(arg0, arg1 interface{}) *gomock.Call {
   622  	mr.mock.ctrl.T.Helper()
   623  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyWatcherState", reflect.TypeOf((*MockMachine)(nil).NotifyWatcherState), arg0, arg1)
   624  }
   625  
   626  // OverrideData mocks base method.
   627  func (m *MockMachine) OverrideData() ([]byte, error) {
   628  	m.ctrl.T.Helper()
   629  	ret := m.ctrl.Call(m, "OverrideData")
   630  	ret0, _ := ret[0].([]byte)
   631  	ret1, _ := ret[1].(error)
   632  	return ret0, ret1
   633  }
   634  
   635  // OverrideData indicates an expected call of OverrideData.
   636  func (mr *MockMachineMockRecorder) OverrideData() *gomock.Call {
   637  	mr.mock.ctrl.T.Helper()
   638  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OverrideData", reflect.TypeOf((*MockMachine)(nil).OverrideData))
   639  }
   640  
   641  // PublishLifecycleEvent mocks base method.
   642  func (m *MockMachine) PublishLifecycleEvent(arg0 lifecycle.Type, arg1 ...lifecycle.Option) {
   643  	m.ctrl.T.Helper()
   644  	varargs := []interface{}{arg0}
   645  	for _, a := range arg1 {
   646  		varargs = append(varargs, a)
   647  	}
   648  	m.ctrl.Call(m, "PublishLifecycleEvent", varargs...)
   649  }
   650  
   651  // PublishLifecycleEvent indicates an expected call of PublishLifecycleEvent.
   652  func (mr *MockMachineMockRecorder) PublishLifecycleEvent(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
   653  	mr.mock.ctrl.T.Helper()
   654  	varargs := append([]interface{}{arg0}, arg1...)
   655  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishLifecycleEvent", reflect.TypeOf((*MockMachine)(nil).PublishLifecycleEvent), varargs...)
   656  }
   657  
   658  // SignerKey mocks base method.
   659  func (m *MockMachine) SignerKey() string {
   660  	m.ctrl.T.Helper()
   661  	ret := m.ctrl.Call(m, "SignerKey")
   662  	ret0, _ := ret[0].(string)
   663  	return ret0
   664  }
   665  
   666  // SignerKey indicates an expected call of SignerKey.
   667  func (mr *MockMachineMockRecorder) SignerKey() *gomock.Call {
   668  	mr.mock.ctrl.T.Helper()
   669  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignerKey", reflect.TypeOf((*MockMachine)(nil).SignerKey))
   670  }
   671  
   672  // State mocks base method.
   673  func (m *MockMachine) State() string {
   674  	m.ctrl.T.Helper()
   675  	ret := m.ctrl.Call(m, "State")
   676  	ret0, _ := ret[0].(string)
   677  	return ret0
   678  }
   679  
   680  // State indicates an expected call of State.
   681  func (mr *MockMachineMockRecorder) State() *gomock.Call {
   682  	mr.mock.ctrl.T.Helper()
   683  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "State", reflect.TypeOf((*MockMachine)(nil).State))
   684  }
   685  
   686  // TextFileDirectory mocks base method.
   687  func (m *MockMachine) TextFileDirectory() string {
   688  	m.ctrl.T.Helper()
   689  	ret := m.ctrl.Call(m, "TextFileDirectory")
   690  	ret0, _ := ret[0].(string)
   691  	return ret0
   692  }
   693  
   694  // TextFileDirectory indicates an expected call of TextFileDirectory.
   695  func (mr *MockMachineMockRecorder) TextFileDirectory() *gomock.Call {
   696  	mr.mock.ctrl.T.Helper()
   697  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TextFileDirectory", reflect.TypeOf((*MockMachine)(nil).TextFileDirectory))
   698  }
   699  
   700  // TimeStampSeconds mocks base method.
   701  func (m *MockMachine) TimeStampSeconds() int64 {
   702  	m.ctrl.T.Helper()
   703  	ret := m.ctrl.Call(m, "TimeStampSeconds")
   704  	ret0, _ := ret[0].(int64)
   705  	return ret0
   706  }
   707  
   708  // TimeStampSeconds indicates an expected call of TimeStampSeconds.
   709  func (mr *MockMachineMockRecorder) TimeStampSeconds() *gomock.Call {
   710  	mr.mock.ctrl.T.Helper()
   711  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TimeStampSeconds", reflect.TypeOf((*MockMachine)(nil).TimeStampSeconds))
   712  }
   713  
   714  // Transition mocks base method.
   715  func (m *MockMachine) Transition(arg0 string, arg1 ...interface{}) error {
   716  	m.ctrl.T.Helper()
   717  	varargs := []interface{}{arg0}
   718  	for _, a := range arg1 {
   719  		varargs = append(varargs, a)
   720  	}
   721  	ret := m.ctrl.Call(m, "Transition", varargs...)
   722  	ret0, _ := ret[0].(error)
   723  	return ret0
   724  }
   725  
   726  // Transition indicates an expected call of Transition.
   727  func (mr *MockMachineMockRecorder) Transition(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
   728  	mr.mock.ctrl.T.Helper()
   729  	varargs := append([]interface{}{arg0}, arg1...)
   730  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Transition", reflect.TypeOf((*MockMachine)(nil).Transition), varargs...)
   731  }
   732  
   733  // Version mocks base method.
   734  func (m *MockMachine) Version() string {
   735  	m.ctrl.T.Helper()
   736  	ret := m.ctrl.Call(m, "Version")
   737  	ret0, _ := ret[0].(string)
   738  	return ret0
   739  }
   740  
   741  // Version indicates an expected call of Version.
   742  func (mr *MockMachineMockRecorder) Version() *gomock.Call {
   743  	mr.mock.ctrl.T.Helper()
   744  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockMachine)(nil).Version))
   745  }
   746  
   747  // Warnf mocks base method.
   748  func (m *MockMachine) Warnf(arg0, arg1 string, arg2 ...interface{}) {
   749  	m.ctrl.T.Helper()
   750  	varargs := []interface{}{arg0, arg1}
   751  	for _, a := range arg2 {
   752  		varargs = append(varargs, a)
   753  	}
   754  	m.ctrl.Call(m, "Warnf", varargs...)
   755  }
   756  
   757  // Warnf indicates an expected call of Warnf.
   758  func (mr *MockMachineMockRecorder) Warnf(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
   759  	mr.mock.ctrl.T.Helper()
   760  	varargs := append([]interface{}{arg0, arg1}, arg2...)
   761  	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Warnf", reflect.TypeOf((*MockMachine)(nil).Warnf), varargs...)
   762  }