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 }