diff --git a/api/controller/triggers.go b/api/controller/triggers.go index 42e4e9ece..7e65f4c26 100644 --- a/api/controller/triggers.go +++ b/api/controller/triggers.go @@ -2,6 +2,7 @@ package controller import ( "fmt" + "math" "github.com/gofrs/uuid" @@ -11,6 +12,8 @@ import ( "github.com/moira-alert/moira/database" ) +const pageSizeUnlimited = -1 + // CreateTrigger creates new trigger func CreateTrigger(dataBase moira.Database, trigger *dto.TriggerModel, timeSeriesNames map[string]bool) (*dto.SaveTriggerResponse, *api.ErrorResponse) { if trigger.ID == "" { @@ -57,10 +60,51 @@ func GetAllTriggers(database moira.Database) (*dto.TriggersList, *api.ErrorRespo } // SearchTriggers gets trigger page and filter trigger by tags and search request terms -func SearchTriggers(database moira.Database, searcher moira.Searcher, page int64, size int64, onlyErrors bool, filterTags []string, searchString string) (*dto.TriggersList, *api.ErrorResponse) { - searchResults, total, err := searcher.SearchTriggers(filterTags, searchString, onlyErrors, page, size) - if err != nil { - return nil, api.ErrorInternalServer(err) +func SearchTriggers(database moira.Database, searcher moira.Searcher, page int64, size int64, onlyErrors bool, filterTags []string, searchString string, createPager bool, pagerID string) (*dto.TriggersList, *api.ErrorResponse) { + var searchResults []*moira.SearchResult + var total int64 + pagerShouldExist := pagerID != "" + + if pagerShouldExist && searchString != "" { + return nil, api.ErrorInvalidRequest(fmt.Errorf("cannot handle request with both search string and pager ID set")) + } + if pagerShouldExist { + var err error + searchResults, total, err = database.GetTriggersSearchResults(pagerID, page, size) + if err != nil { + return nil, api.ErrorInternalServer(err) + } + if searchResults == nil { + return nil, api.ErrorNotFound("Pager not found") + } + } else { + var err error + var passSize = size + if createPager { + passSize = pageSizeUnlimited + } + searchResults, total, err = searcher.SearchTriggers(filterTags, searchString, onlyErrors, page, passSize) + if err != nil { + return nil, api.ErrorInternalServer(err) + } + } + + if createPager && !pagerShouldExist { + uuid4, err := uuid.NewV4() + if err != nil { + return nil, api.ErrorInternalServer(err) + } + pagerID = uuid4.String() + database.SaveTriggersSearchResults(pagerID, searchResults) + } + + if createPager { + var from, to int64 = 0, int64(len(searchResults)) + if size >= 0 { + from = int64(math.Min(float64(page*size), float64(len(searchResults)))) + to = int64(math.Min(float64(from+size), float64(len(searchResults)))) + } + searchResults = searchResults[from:to] } var triggerIDs []string @@ -72,11 +116,18 @@ func SearchTriggers(database moira.Database, searcher moira.Searcher, page int64 if err != nil { return nil, api.ErrorInternalServer(err) } + + var pagerIDPtr *string + if pagerID != "" { + pagerIDPtr = &pagerID + } + triggersList := dto.TriggersList{ List: make([]moira.TriggerCheck, 0), Total: &total, Page: &page, Size: &size, + Pager: pagerIDPtr, } for triggerCheckInd := range triggerChecks { diff --git a/api/controller/triggers_test.go b/api/controller/triggers_test.go index c6cee1529..479685628 100644 --- a/api/controller/triggers_test.go +++ b/api/controller/triggers_test.go @@ -159,7 +159,7 @@ func TestSearchTriggers(t *testing.T) { Convey("Page is bigger than triggers number", func() { mockIndex.EXPECT().SearchTriggers(tags, searchString, false, page, size).Return(triggerSearchResults, exp, nil) mockDatabase.EXPECT().GetTriggerChecks(triggerIDs).Return(triggersPointers, nil) - list, err := SearchTriggers(mockDatabase, mockIndex, page, size, false, tags, searchString) + list, err := SearchTriggers(mockDatabase, mockIndex, page, size, false, tags, searchString, false, "") So(err, ShouldBeNil) So(list, ShouldResemble, &dto.TriggersList{ List: triggerChecks, @@ -173,7 +173,7 @@ func TestSearchTriggers(t *testing.T) { size = -1 mockIndex.EXPECT().SearchTriggers(tags, searchString, false, page, size).Return(triggerSearchResults, exp, nil) mockDatabase.EXPECT().GetTriggerChecks(triggerIDs).Return(triggersPointers, nil) - list, err := SearchTriggers(mockDatabase, mockIndex, page, size, false, tags, searchString) + list, err := SearchTriggers(mockDatabase, mockIndex, page, size, false, tags, searchString, false, "") So(err, ShouldBeNil) So(list, ShouldResemble, &dto.TriggersList{ List: triggerChecks, @@ -187,7 +187,7 @@ func TestSearchTriggers(t *testing.T) { size = 10 mockIndex.EXPECT().SearchTriggers(tags, searchString, false, page, size).Return(triggerSearchResults[:10], exp, nil) mockDatabase.EXPECT().GetTriggerChecks(triggerIDs[:10]).Return(triggersPointers[:10], nil) - list, err := SearchTriggers(mockDatabase, mockIndex, page, size, false, tags, searchString) + list, err := SearchTriggers(mockDatabase, mockIndex, page, size, false, tags, searchString, false, "") So(err, ShouldBeNil) So(list, ShouldResemble, &dto.TriggersList{ List: triggerChecks[:10], @@ -200,7 +200,7 @@ func TestSearchTriggers(t *testing.T) { page = 1 mockIndex.EXPECT().SearchTriggers(tags, searchString, false, page, size).Return(triggerSearchResults[10:20], exp, nil) mockDatabase.EXPECT().GetTriggerChecks(triggerIDs[10:20]).Return(triggersPointers[10:20], nil) - list, err := SearchTriggers(mockDatabase, mockIndex, page, size, false, tags, searchString) + list, err := SearchTriggers(mockDatabase, mockIndex, page, size, false, tags, searchString, false, "") So(err, ShouldBeNil) So(list, ShouldResemble, &dto.TriggersList{ List: triggerChecks[10:20], @@ -220,7 +220,7 @@ func TestSearchTriggers(t *testing.T) { // superTrigger31 is the only trigger without errors mockIndex.EXPECT().SearchTriggers(tags, searchString, true, page, size).Return(triggerSearchResults[:10], exp, nil) mockDatabase.EXPECT().GetTriggerChecks(triggerIDs[:10]).Return(triggersPointers[:10], nil) - list, err := SearchTriggers(mockDatabase, mockIndex, page, size, true, tags, searchString) + list, err := SearchTriggers(mockDatabase, mockIndex, page, size, true, tags, searchString, false, "") So(err, ShouldBeNil) So(list, ShouldResemble, &dto.TriggersList{ List: triggerChecks[0:10], @@ -234,7 +234,7 @@ func TestSearchTriggers(t *testing.T) { exp = 2 mockIndex.EXPECT().SearchTriggers(tags, searchString, true, page, size).Return(triggerSearchResults[1:3], exp, nil) mockDatabase.EXPECT().GetTriggerChecks(triggerIDs[1:3]).Return(triggersPointers[1:3], nil) - list, err := SearchTriggers(mockDatabase, mockIndex, page, size, true, tags, searchString) + list, err := SearchTriggers(mockDatabase, mockIndex, page, size, true, tags, searchString, false, "") So(err, ShouldBeNil) So(list, ShouldResemble, &dto.TriggersList{ List: triggerChecks[1:3], @@ -249,7 +249,7 @@ func TestSearchTriggers(t *testing.T) { exp = 1 mockIndex.EXPECT().SearchTriggers(tags, searchString, true, page, size).Return(triggerSearchResults[2:3], exp, nil) mockDatabase.EXPECT().GetTriggerChecks(triggerIDs[2:3]).Return(triggersPointers[2:3], nil) - list, err := SearchTriggers(mockDatabase, mockIndex, page, size, true, tags, searchString) + list, err := SearchTriggers(mockDatabase, mockIndex, page, size, true, tags, searchString, false, "") So(err, ShouldBeNil) So(list, ShouldResemble, &dto.TriggersList{ List: triggerChecks[2:3], @@ -290,7 +290,7 @@ func TestSearchTriggers(t *testing.T) { mockIndex.EXPECT().SearchTriggers(tags, searchString, true, page, size).Return(deadlyTrapsSearchResults, exp, nil) mockDatabase.EXPECT().GetTriggerChecks(deadlyTrapsTriggerIDs).Return(deadlyTrapsPointers, nil) - list, err := SearchTriggers(mockDatabase, mockIndex, page, size, true, tags, searchString) + list, err := SearchTriggers(mockDatabase, mockIndex, page, size, true, tags, searchString, false, "") So(err, ShouldBeNil) So(list, ShouldResemble, &dto.TriggersList{ List: deadlyTraps, @@ -309,7 +309,7 @@ func TestSearchTriggers(t *testing.T) { Convey("Error from searcher", func() { searcherError := fmt.Errorf("very bad request") mockIndex.EXPECT().SearchTriggers(tags, searchString, false, page, size).Return(make([]*moira.SearchResult, 0), int64(0), searcherError) - list, err := SearchTriggers(mockDatabase, mockIndex, page, size, false, tags, searchString) + list, err := SearchTriggers(mockDatabase, mockIndex, page, size, false, tags, searchString, false, "") So(err, ShouldNotBeNil) So(list, ShouldBeNil) }) @@ -319,11 +319,73 @@ func TestSearchTriggers(t *testing.T) { searcherError := fmt.Errorf("very bad request") mockIndex.EXPECT().SearchTriggers(tags, searchString, false, page, size).Return(triggerSearchResults, exp, nil) mockDatabase.EXPECT().GetTriggerChecks(triggerIDs).Return(nil, searcherError) - list, err := SearchTriggers(mockDatabase, mockIndex, page, size, false, tags, searchString) + list, err := SearchTriggers(mockDatabase, mockIndex, page, size, false, tags, searchString, false, "") So(err, ShouldNotBeNil) So(list, ShouldBeNil) }) }) + + Convey("Search with pager", t, func() { + Convey("Create pager", func() { + pagerID := "" + var page int64 = 0 + var size int64 = -1 + var exp int64 = 31 + gomock.InOrder( + mockIndex.EXPECT().SearchTriggers(tags, searchString, false, page, int64(-1)).Return(triggerSearchResults, exp, nil), + mockDatabase.EXPECT().SaveTriggersSearchResults(gomock.Any(), triggerSearchResults).Return(nil).Do(func(pID string, _ interface{}) { + pagerID = pID + }), + mockDatabase.EXPECT().GetTriggerChecks(triggerIDs).Return(triggersPointers, nil), + ) + list, err := SearchTriggers(mockDatabase, mockIndex, page, size, false, tags, searchString, true, "") + So(err, ShouldBeNil) + So(list, ShouldResemble, &dto.TriggersList{ + List: triggerChecks, + Total: &exp, + Page: &page, + Size: &size, + Pager: &pagerID, + }) + }) + Convey("Use pager", func() { + pagerID := "TestPagerID" + var page int64 = 0 + var size int64 = -1 + var exp int64 = 31 + gomock.InOrder( + mockDatabase.EXPECT().GetTriggersSearchResults(pagerID, page, size).Return(triggerSearchResults, exp, nil), + mockDatabase.EXPECT().GetTriggerChecks(triggerIDs).Return(triggersPointers, nil), + ) + list, err := SearchTriggers(mockDatabase, mockIndex, page, size, false, tags, searchString, false, pagerID) + So(err, ShouldBeNil) + So(list, ShouldResemble, &dto.TriggersList{ + List: triggerChecks, + Total: &exp, + Page: &page, + Size: &size, + Pager: &pagerID, + }) + }) + Convey("Use pager and page size higher than amount of search results", func() { + pagerID := "TestPagerID" + var exp int64 = 2 + var size int64 = 10 + gomock.InOrder( + mockDatabase.EXPECT().GetTriggersSearchResults(pagerID, page, size).Return(triggerSearchResults[:2], exp, nil), + mockDatabase.EXPECT().GetTriggerChecks(triggerIDs[:2]).Return(triggersPointers[:2], nil), + ) + list, err := SearchTriggers(mockDatabase, mockIndex, page, size, false, tags, searchString, false, pagerID) + So(err, ShouldBeNil) + So(list, ShouldResemble, &dto.TriggersList{ + List: triggerChecks[:2], + Total: &exp, + Page: &page, + Size: &size, + Pager: &pagerID, + }) + }) + }) } var triggerChecks = []moira.TriggerCheck{ diff --git a/api/dto/triggers.go b/api/dto/triggers.go index 6f3ea2019..1d4fbb842 100644 --- a/api/dto/triggers.go +++ b/api/dto/triggers.go @@ -17,6 +17,7 @@ type TriggersList struct { Page *int64 `json:"page,omitempty"` Size *int64 `json:"size,omitempty"` Total *int64 `json:"total,omitempty"` + Pager *string `json:"pager,omitempty"` List []moira.TriggerCheck `json:"list"` } diff --git a/api/handler/triggers.go b/api/handler/triggers.go index 1f6cfd9e0..d31ff2dfa 100644 --- a/api/handler/triggers.go +++ b/api/handler/triggers.go @@ -27,7 +27,7 @@ func triggers(metricSourceProvider *metricSource.SourceProvider, searcher moira. router.Get("/", getAllTriggers) router.Put("/", createTrigger) router.Route("/{triggerId}", trigger) - router.With(middleware.Paginate(0, 10)).Get("/search", searchTriggers) + router.With(middleware.Paginate(0, 10)).With(middleware.Pager(false, "")).Get("/search", searchTriggers) // ToDo: DEPRECATED method. Remove in Moira 2.6 router.With(middleware.Paginate(0, 10)).Get("/page", searchTriggers) } @@ -85,7 +85,10 @@ func searchTriggers(writer http.ResponseWriter, request *http.Request) { page := middleware.GetPage(request) size := middleware.GetSize(request) - triggersList, errorResponse := controller.SearchTriggers(database, searchIndex, page, size, onlyErrors, filterTags, searchString) + createPager := middleware.GetCreatePager(request) + pagerID := middleware.GetPagerID(request) + + triggersList, errorResponse := controller.SearchTriggers(database, searchIndex, page, size, onlyErrors, filterTags, searchString, createPager, pagerID) if errorResponse != nil { render.Render(writer, request, errorResponse) return diff --git a/api/middleware/context.go b/api/middleware/context.go index 92855d7c4..8c3d8ca2d 100644 --- a/api/middleware/context.go +++ b/api/middleware/context.go @@ -124,6 +124,27 @@ func Paginate(defaultPage, defaultSize int64) func(next http.Handler) http.Handl } } +// Pager is a function that takes pager id from query +func Pager(defaultCreatePager bool, defaultPagerID string) func(next http.Handler) http.Handler { + return func(next http.Handler) http.Handler { + return http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) { + pagerID := request.URL.Query().Get("pagerID") + if pagerID == "" { + pagerID = defaultPagerID + } + + createPager, err := strconv.ParseBool(request.URL.Query().Get("createPager")) + if err != nil { + createPager = defaultCreatePager + } + + ctxPager := context.WithValue(request.Context(), pagerIDKey, pagerID) + ctxSize := context.WithValue(ctxPager, createPagerKey, createPager) + next.ServeHTTP(writer, request.WithContext(ctxSize)) + }) + } +} + // DateRange gets from and to values from URI query and set it to request context. If query has not values sets given values func DateRange(defaultFrom, defaultTo string) func(next http.Handler) http.Handler { return func(next http.Handler) http.Handler { diff --git a/api/middleware/middleware.go b/api/middleware/middleware.go index 1682e94c3..f802d0b14 100644 --- a/api/middleware/middleware.go +++ b/api/middleware/middleware.go @@ -24,6 +24,8 @@ var ( subscriptionIDKey ContextKey = "subscriptionID" pageKey ContextKey = "page" sizeKey ContextKey = "size" + pagerIDKey ContextKey = "pagerID" + createPagerKey ContextKey = "createPager" fromKey ContextKey = "from" toKey ContextKey = "to" loginKey ContextKey = "login" @@ -71,6 +73,16 @@ func GetSize(request *http.Request) int64 { return request.Context().Value(sizeKey).(int64) } +// GetPagerID is a function that gets pagerID value from request context, which was sets in Pager middleware +func GetPagerID(request *http.Request) string { + return request.Context().Value(pagerIDKey).(string) +} + +// GetCreatePager is a function that gets createPager value from request context, which was sets in Pager middleware +func GetCreatePager(request *http.Request) bool { + return request.Context().Value(createPagerKey).(bool) +} + // GetFromStr gets 'from' value from request context, which was sets in DateRange middleware func GetFromStr(request *http.Request) string { return request.Context().Value(fromKey).(string) diff --git a/database/redis/reply/search_result.go b/database/redis/reply/search_result.go new file mode 100644 index 000000000..f312e8fe6 --- /dev/null +++ b/database/redis/reply/search_result.go @@ -0,0 +1,97 @@ +package reply + +import ( + "encoding/json" + "fmt" + + "github.com/gomodule/redigo/redis" + "github.com/moira-alert/moira" + "github.com/moira-alert/moira/database" +) + +type searchHighlightStorageElement struct { + Field string `json:"field"` + Value string `json:"value"` +} + +type searchResultStorageElement struct { + ObjectID string `json:"object_id"` + Highlights []searchHighlightStorageElement `json:"highlights"` +} + +func toSearchResultStorageElement(searchResult moira.SearchResult) searchResultStorageElement { + result := searchResultStorageElement{ + ObjectID: searchResult.ObjectID, + Highlights: make([]searchHighlightStorageElement, 0, len(searchResult.Highlights)), + } + for _, highlight := range searchResult.Highlights { + result.Highlights = append(result.Highlights, searchHighlightStorageElement{ + Field: highlight.Field, + Value: highlight.Value, + }) + } + return result +} + +// GetSearchResultBytes is a function that takes a search result converts it to a storage structure and marshal it to JSON. +func GetSearchResultBytes(searchResult moira.SearchResult) ([]byte, error) { + storageElement := toSearchResultStorageElement(searchResult) + return json.Marshal(storageElement) +} + +func toSearchResult(storageElement searchResultStorageElement) moira.SearchResult { + result := moira.SearchResult{ + ObjectID: storageElement.ObjectID, + Highlights: make([]moira.SearchHighlight, 0, len(storageElement.Highlights)), + } + for _, highlight := range storageElement.Highlights { + result.Highlights = append(result.Highlights, moira.SearchHighlight{ + Field: highlight.Field, + Value: highlight.Value, + }) + } + return result +} + +// SearchResult is a function that converts redis reply to SearchResult. +func SearchResult(rep interface{}, err error) (moira.SearchResult, error) { + var searchResult moira.SearchResult + storageElement := searchResultStorageElement{} + bytes, err := redis.Bytes(rep, err) + if err != nil { + if err == redis.ErrNil { + return searchResult, database.ErrNil + } + return searchResult, fmt.Errorf("failed to read searchResult: %w", err) + } + err = json.Unmarshal(bytes, &storageElement) + if err != nil { + return searchResult, fmt.Errorf("failed to parse searchResult json %s: %w", string(bytes), err) + } + searchResult = toSearchResult(storageElement) + return searchResult, nil +} + +// SearchResults is a function that converts redis reply to slice of SearchResults. +func SearchResults(rep interface{}, repTotal interface{}, err error) ([]*moira.SearchResult, int64, error) { + total := repTotal.(int64) + values, err := redis.Values(rep, err) + if err != nil { + if err == redis.ErrNil { + return make([]*moira.SearchResult, 0), 0, nil + } + return nil, 0, fmt.Errorf("failed to read SearchResults: %w", err) + } + searchResults := make([]*moira.SearchResult, len(values)) + for i, value := range values { + searchResult, err2 := SearchResult(value, err) + if err2 != nil && err2 != database.ErrNil { + return nil, 0, err2 + } else if err2 == database.ErrNil { + searchResults[i] = nil + } else { + searchResults[i] = &searchResult + } + } + return searchResults, total, nil +} diff --git a/database/redis/triggers_search_results.go b/database/redis/triggers_search_results.go new file mode 100644 index 000000000..4c108529d --- /dev/null +++ b/database/redis/triggers_search_results.go @@ -0,0 +1,71 @@ +package redis + +import ( + "fmt" + + "github.com/gomodule/redigo/redis" + "github.com/moira-alert/moira" + "github.com/moira-alert/moira/database/redis/reply" +) + +const triggersSearchResultsExpireTime = 1800 + +// SaveTriggersSearchResults is a function that takes an ID of pager and saves it to redis +func (connector *DbConnector) SaveTriggersSearchResults(searchResultsID string, searchResults []*moira.SearchResult) error { + c := connector.pool.Get() + defer c.Close() + + resultsID := triggersSearchResultsKey(searchResultsID) + if err := c.Send("MULTI"); err != nil { + return fmt.Errorf("failed to MULTI: %w", err) + } + for _, searchResult := range searchResults { + var marshalled []byte + marshalled, err := reply.GetSearchResultBytes(*searchResult) + if err != nil { + return fmt.Errorf("marshall error: %w", err) + } + if err := c.Send("RPUSH", resultsID, marshalled); err != nil { + return fmt.Errorf("failed to PUSH: %w", err) + } + } + if err := c.Send("EXPIRE", resultsID, triggersSearchResultsExpireTime); err != nil { + return fmt.Errorf("failed to set expire time: %w", err) + } + response, err := c.Do("EXEC") + if err != nil { + return fmt.Errorf("failed to EXEC: %w", err) + } + connector.logger.Debugf("EXEC response: %v", response) + return nil +} + +// GetTriggersSearchResults is a function that receives a saved pager from redis +func (connector *DbConnector) GetTriggersSearchResults(searchResultsID string, page, size int64) ([]*moira.SearchResult, int64, error) { + c := connector.pool.Get() + defer c.Close() + + var from, to int64 = 0, -1 + if size > 0 { + from = page * size + to = from + size + } + + resultsID := triggersSearchResultsKey(searchResultsID) + + c.Send("MULTI") + c.Send("LRANGE", resultsID, from, to) + c.Send("LLEN", resultsID) + response, err := redis.Values(c.Do("EXEC")) + if err != nil { + return nil, 0, fmt.Errorf("failed to EXEC: %w", err) + } + if len(response) == 0 { + return make([]*moira.SearchResult, 0), 0, nil + } + return reply.SearchResults(response[0], response[1], nil) +} + +func triggersSearchResultsKey(searchResultsID string) string { + return fmt.Sprintf("moira-triggersSearchResults:%s", searchResultsID) +} diff --git a/database/redis/triggers_search_results_test.go b/database/redis/triggers_search_results_test.go new file mode 100644 index 000000000..ca0ca3be2 --- /dev/null +++ b/database/redis/triggers_search_results_test.go @@ -0,0 +1,106 @@ +package redis + +import ( + "fmt" + "log" + "strings" + "testing" + + "github.com/moira-alert/moira" + "github.com/op/go-logging" + . "github.com/smartystreets/goconvey/convey" +) + +var searchResults = []*moira.SearchResult{ + { + ObjectID: "TestTrigger1", + Highlights: []moira.SearchHighlight{ + { + Field: "Name", + Value: "Test", + }, + }, + }, + { + ObjectID: "TestTrigger2", + Highlights: []moira.SearchHighlight{ + { + Field: "Name", + Value: "Test1", + }, + }, + }, +} + +const searchResultsID = "Test" + +func TestTriggersSearchResultsStoring(t *testing.T) { + if testing.Short() { + t.Skip("Skipping database test in short mode") + } + logger, _ := logging.GetLogger("dataBase") + dataBase := newTestDatabase(logger, config) + dataBase.flush() + defer dataBase.flush() + + Convey("Search Results Manipulation", t, func() { + err := dataBase.SaveTriggersSearchResults(searchResultsID, searchResults) + So(err, ShouldBeNil) + + actual, total, err := dataBase.GetTriggersSearchResults(searchResultsID, 0, -1) + So(err, ShouldBeNil) + So(actual, ShouldResemble, searchResults) + So(total, ShouldResemble, int64(2)) + + actual, total, err = dataBase.GetTriggersSearchResults(searchResultsID, 0, 10) + So(err, ShouldBeNil) + So(actual, ShouldResemble, searchResults) + So(total, ShouldResemble, int64(2)) + + actual, total, err = dataBase.GetTriggersSearchResults(searchResultsID, 10, 20) + So(err, ShouldBeNil) + So(actual, ShouldBeEmpty) + So(total, ShouldResemble, int64(2)) + }) +} + +func BenchmarkSaveTriggersSearchResults(b *testing.B) { + logger, _ := logging.GetLogger("dataBase") + logging.SetBackend(logging.NewLogBackend(&strings.Builder{}, "", log.LstdFlags)) + + dataBase := newTestDatabase(logger, config) + dataBase.flush() + defer dataBase.flush() + + b.ReportAllocs() + limits := []int{10, 100, 1000, 10000, 100000} + for _, limit := range limits { + data := make([]*moira.SearchResult, limit) + for i := 0; i < limit; i++ { + data[i] = &moira.SearchResult{ + ObjectID: "test", + Highlights: []moira.SearchHighlight{ + { + Field: "field1", + Value: "Value1", + }, + { + Field: "field2", + Value: "Value2", + }, + { + Field: "field3", + Value: "Value3", + }, + }, + } + } + dataBase.flush() + b.Run(fmt.Sprintf("Benchmark%d", limit), func(b *testing.B) { + for n := 0; n < b.N; n++ { + dataBase.SaveTriggersSearchResults(fmt.Sprintf("test_%d_%d", limit, n), data) + } + }) + + } +} diff --git a/go.mod b/go.mod index f1aa256de..a114b90b3 100644 --- a/go.mod +++ b/go.mod @@ -10,6 +10,7 @@ require ( github.com/PagerDuty/go-pagerduty v0.0.0-20190503230806-cf1437c7c8d6 github.com/RoaringBitmap/roaring v0.4.21 // indirect github.com/aclements/go-moremath v0.0.0-20190830160640-d16893ddf098 // indirect + github.com/alecthomas/jsonschema v0.0.0-20200217214135-7152f22193c9 github.com/aws/aws-sdk-go v1.20.15-0.20190702192017-e1b61fed9fc0 github.com/beevee/go-chart v2.0.2-0.20190523110126-273a59e48bcc+incompatible github.com/blend/go-sdk v2.0.0+incompatible // indirect diff --git a/go.sum b/go.sum index 5ee18c15e..705d97f5f 100644 --- a/go.sum +++ b/go.sum @@ -19,6 +19,8 @@ github.com/RoaringBitmap/roaring v0.4.21/go.mod h1:D0gp8kJQgE1A4LQ5wFLggQEyvDi06 github.com/StackExchange/wmi v0.0.0-20180116203802-5d049714c4a6/go.mod h1:3eOhrUMpNV+6aFIbp5/iudMxNCF27Vw2OZgy4xEx0Fg= github.com/aclements/go-moremath v0.0.0-20190830160640-d16893ddf098 h1:a7+Y8VlXRC2VX5ue6tpCutr4PsrkRkWWVZv4zqfaHuc= github.com/aclements/go-moremath v0.0.0-20190830160640-d16893ddf098/go.mod h1:idZL3yvz4kzx1dsBOAC+oYv6L92P1oFEhUXUB1A/lwQ= +github.com/alecthomas/jsonschema v0.0.0-20200217214135-7152f22193c9 h1:h+KAZEUnNceFhqyH46BgwH4lk8m6pdR/3x3h7IPn7VA= +github.com/alecthomas/jsonschema v0.0.0-20200217214135-7152f22193c9/go.mod h1:/n6+1/DWPltRLWL/VKyUxg6tzsl5kHUCcraimt4vr60= github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= @@ -204,6 +206,8 @@ github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4= github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI= github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= +github.com/iancoleman/orderedmap v0.0.0-20190318233801-ac98e3ecb4b0 h1:i462o439ZjprVSFSZLZxcsoAe592sZB1rci2Z8j4wdk= +github.com/iancoleman/orderedmap v0.0.0-20190318233801-ac98e3ecb4b0/go.mod h1:N0Wam8K1arqPXNWjMo21EXnBPOPp36vB07FNRdD2geA= github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM= github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8= github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af h1:pmfjZENx5imkbgOkpRUYLnmbU7UEFbjtDA2hxJ1ichM= @@ -377,6 +381,7 @@ github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoH github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w= github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.3.1-0.20190311161405-34c6fa2dc709/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk= github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= github.com/stvp/tempredis v0.0.0-20181119212430-b82af8480203 h1:QVqDTf3h2WHt08YuiTGPZLls0Wq99X9bWd0Q5ZSBesM= diff --git a/interfaces.go b/interfaces.go index 51b5ef4a5..9aaddcf83 100644 --- a/interfaces.go +++ b/interfaces.go @@ -40,6 +40,10 @@ type Database interface { GetPatternTriggerIDs(pattern string) ([]string, error) RemovePatternTriggerIDs(pattern string) error + // SearchResult storing + GetTriggersSearchResults(searchResultsID string, page, size int64) ([]*SearchResult, int64, error) + SaveTriggersSearchResults(searchResultsID string, searchResults []*SearchResult) error + // Throttling GetTriggerThrottling(triggerID string) (time.Time, time.Time) SetTriggerThrottling(triggerID string, next time.Time) error diff --git a/mock/moira-alert/database.go b/mock/moira-alert/database.go index 613f3a247..321fc4bfd 100644 --- a/mock/moira-alert/database.go +++ b/mock/moira-alert/database.go @@ -5,12 +5,11 @@ package mock_moira_alert import ( - reflect "reflect" - time "time" - gomock "github.com/golang/mock/gomock" moira "github.com/moira-alert/moira" - tomb_v2 "gopkg.in/tomb.v2" + tomb "gopkg.in/tomb.v2" + reflect "reflect" + time "time" ) // MockDatabase is a mock of Database interface @@ -38,6 +37,7 @@ func (m *MockDatabase) EXPECT() *MockDatabaseMockRecorder { // AcquireTriggerCheckLock mocks base method func (m *MockDatabase) AcquireTriggerCheckLock(arg0 string, arg1 int) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AcquireTriggerCheckLock", arg0, arg1) ret0, _ := ret[0].(error) return ret0 @@ -45,11 +45,13 @@ func (m *MockDatabase) AcquireTriggerCheckLock(arg0 string, arg1 int) error { // AcquireTriggerCheckLock indicates an expected call of AcquireTriggerCheckLock func (mr *MockDatabaseMockRecorder) AcquireTriggerCheckLock(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcquireTriggerCheckLock", reflect.TypeOf((*MockDatabase)(nil).AcquireTriggerCheckLock), arg0, arg1) } // AddLocalTriggersToCheck mocks base method func (m *MockDatabase) AddLocalTriggersToCheck(arg0 []string) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AddLocalTriggersToCheck", arg0) ret0, _ := ret[0].(error) return ret0 @@ -57,11 +59,13 @@ func (m *MockDatabase) AddLocalTriggersToCheck(arg0 []string) error { // AddLocalTriggersToCheck indicates an expected call of AddLocalTriggersToCheck func (mr *MockDatabaseMockRecorder) AddLocalTriggersToCheck(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddLocalTriggersToCheck", reflect.TypeOf((*MockDatabase)(nil).AddLocalTriggersToCheck), arg0) } // AddNotification mocks base method func (m *MockDatabase) AddNotification(arg0 *moira.ScheduledNotification) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AddNotification", arg0) ret0, _ := ret[0].(error) return ret0 @@ -69,11 +73,13 @@ func (m *MockDatabase) AddNotification(arg0 *moira.ScheduledNotification) error // AddNotification indicates an expected call of AddNotification func (mr *MockDatabaseMockRecorder) AddNotification(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddNotification", reflect.TypeOf((*MockDatabase)(nil).AddNotification), arg0) } // AddNotifications mocks base method func (m *MockDatabase) AddNotifications(arg0 []*moira.ScheduledNotification, arg1 int64) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AddNotifications", arg0, arg1) ret0, _ := ret[0].(error) return ret0 @@ -81,11 +87,13 @@ func (m *MockDatabase) AddNotifications(arg0 []*moira.ScheduledNotification, arg // AddNotifications indicates an expected call of AddNotifications func (mr *MockDatabaseMockRecorder) AddNotifications(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddNotifications", reflect.TypeOf((*MockDatabase)(nil).AddNotifications), arg0, arg1) } // AddPatternMetric mocks base method func (m *MockDatabase) AddPatternMetric(arg0, arg1 string) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AddPatternMetric", arg0, arg1) ret0, _ := ret[0].(error) return ret0 @@ -93,11 +101,13 @@ func (m *MockDatabase) AddPatternMetric(arg0, arg1 string) error { // AddPatternMetric indicates an expected call of AddPatternMetric func (mr *MockDatabaseMockRecorder) AddPatternMetric(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPatternMetric", reflect.TypeOf((*MockDatabase)(nil).AddPatternMetric), arg0, arg1) } // AddRemoteTriggersToCheck mocks base method func (m *MockDatabase) AddRemoteTriggersToCheck(arg0 []string) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AddRemoteTriggersToCheck", arg0) ret0, _ := ret[0].(error) return ret0 @@ -105,11 +115,13 @@ func (m *MockDatabase) AddRemoteTriggersToCheck(arg0 []string) error { // AddRemoteTriggersToCheck indicates an expected call of AddRemoteTriggersToCheck func (mr *MockDatabaseMockRecorder) AddRemoteTriggersToCheck(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRemoteTriggersToCheck", reflect.TypeOf((*MockDatabase)(nil).AddRemoteTriggersToCheck), arg0) } // DeleteTriggerCheckLock mocks base method func (m *MockDatabase) DeleteTriggerCheckLock(arg0 string) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteTriggerCheckLock", arg0) ret0, _ := ret[0].(error) return ret0 @@ -117,11 +129,13 @@ func (m *MockDatabase) DeleteTriggerCheckLock(arg0 string) error { // DeleteTriggerCheckLock indicates an expected call of DeleteTriggerCheckLock func (mr *MockDatabaseMockRecorder) DeleteTriggerCheckLock(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTriggerCheckLock", reflect.TypeOf((*MockDatabase)(nil).DeleteTriggerCheckLock), arg0) } // DeleteTriggerThrottling mocks base method func (m *MockDatabase) DeleteTriggerThrottling(arg0 string) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteTriggerThrottling", arg0) ret0, _ := ret[0].(error) return ret0 @@ -129,11 +143,13 @@ func (m *MockDatabase) DeleteTriggerThrottling(arg0 string) error { // DeleteTriggerThrottling indicates an expected call of DeleteTriggerThrottling func (mr *MockDatabaseMockRecorder) DeleteTriggerThrottling(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTriggerThrottling", reflect.TypeOf((*MockDatabase)(nil).DeleteTriggerThrottling), arg0) } // FetchNotificationEvent mocks base method func (m *MockDatabase) FetchNotificationEvent() (moira.NotificationEvent, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "FetchNotificationEvent") ret0, _ := ret[0].(moira.NotificationEvent) ret1, _ := ret[1].(error) @@ -142,11 +158,13 @@ func (m *MockDatabase) FetchNotificationEvent() (moira.NotificationEvent, error) // FetchNotificationEvent indicates an expected call of FetchNotificationEvent func (mr *MockDatabaseMockRecorder) FetchNotificationEvent() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchNotificationEvent", reflect.TypeOf((*MockDatabase)(nil).FetchNotificationEvent)) } // FetchNotifications mocks base method func (m *MockDatabase) FetchNotifications(arg0 int64) ([]*moira.ScheduledNotification, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "FetchNotifications", arg0) ret0, _ := ret[0].([]*moira.ScheduledNotification) ret1, _ := ret[1].(error) @@ -155,11 +173,13 @@ func (m *MockDatabase) FetchNotifications(arg0 int64) ([]*moira.ScheduledNotific // FetchNotifications indicates an expected call of FetchNotifications func (mr *MockDatabaseMockRecorder) FetchNotifications(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchNotifications", reflect.TypeOf((*MockDatabase)(nil).FetchNotifications), arg0) } // FetchTriggersToReindex mocks base method func (m *MockDatabase) FetchTriggersToReindex(arg0 int64) ([]string, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "FetchTriggersToReindex", arg0) ret0, _ := ret[0].([]string) ret1, _ := ret[1].(error) @@ -168,11 +188,13 @@ func (m *MockDatabase) FetchTriggersToReindex(arg0 int64) ([]string, error) { // FetchTriggersToReindex indicates an expected call of FetchTriggersToReindex func (mr *MockDatabaseMockRecorder) FetchTriggersToReindex(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchTriggersToReindex", reflect.TypeOf((*MockDatabase)(nil).FetchTriggersToReindex), arg0) } // GetAllContacts mocks base method func (m *MockDatabase) GetAllContacts() ([]*moira.ContactData, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetAllContacts") ret0, _ := ret[0].([]*moira.ContactData) ret1, _ := ret[1].(error) @@ -181,11 +203,13 @@ func (m *MockDatabase) GetAllContacts() ([]*moira.ContactData, error) { // GetAllContacts indicates an expected call of GetAllContacts func (mr *MockDatabaseMockRecorder) GetAllContacts() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllContacts", reflect.TypeOf((*MockDatabase)(nil).GetAllContacts)) } // GetAllTriggerIDs mocks base method func (m *MockDatabase) GetAllTriggerIDs() ([]string, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetAllTriggerIDs") ret0, _ := ret[0].([]string) ret1, _ := ret[1].(error) @@ -194,11 +218,13 @@ func (m *MockDatabase) GetAllTriggerIDs() ([]string, error) { // GetAllTriggerIDs indicates an expected call of GetAllTriggerIDs func (mr *MockDatabaseMockRecorder) GetAllTriggerIDs() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllTriggerIDs", reflect.TypeOf((*MockDatabase)(nil).GetAllTriggerIDs)) } // GetChecksUpdatesCount mocks base method func (m *MockDatabase) GetChecksUpdatesCount() (int64, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetChecksUpdatesCount") ret0, _ := ret[0].(int64) ret1, _ := ret[1].(error) @@ -207,11 +233,13 @@ func (m *MockDatabase) GetChecksUpdatesCount() (int64, error) { // GetChecksUpdatesCount indicates an expected call of GetChecksUpdatesCount func (mr *MockDatabaseMockRecorder) GetChecksUpdatesCount() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChecksUpdatesCount", reflect.TypeOf((*MockDatabase)(nil).GetChecksUpdatesCount)) } // GetContact mocks base method func (m *MockDatabase) GetContact(arg0 string) (moira.ContactData, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetContact", arg0) ret0, _ := ret[0].(moira.ContactData) ret1, _ := ret[1].(error) @@ -220,11 +248,13 @@ func (m *MockDatabase) GetContact(arg0 string) (moira.ContactData, error) { // GetContact indicates an expected call of GetContact func (mr *MockDatabaseMockRecorder) GetContact(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContact", reflect.TypeOf((*MockDatabase)(nil).GetContact), arg0) } // GetContacts mocks base method func (m *MockDatabase) GetContacts(arg0 []string) ([]*moira.ContactData, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetContacts", arg0) ret0, _ := ret[0].([]*moira.ContactData) ret1, _ := ret[1].(error) @@ -233,11 +263,13 @@ func (m *MockDatabase) GetContacts(arg0 []string) ([]*moira.ContactData, error) // GetContacts indicates an expected call of GetContacts func (mr *MockDatabaseMockRecorder) GetContacts(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContacts", reflect.TypeOf((*MockDatabase)(nil).GetContacts), arg0) } // GetIDByUsername mocks base method func (m *MockDatabase) GetIDByUsername(arg0, arg1 string) (string, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetIDByUsername", arg0, arg1) ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) @@ -246,11 +278,13 @@ func (m *MockDatabase) GetIDByUsername(arg0, arg1 string) (string, error) { // GetIDByUsername indicates an expected call of GetIDByUsername func (mr *MockDatabaseMockRecorder) GetIDByUsername(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIDByUsername", reflect.TypeOf((*MockDatabase)(nil).GetIDByUsername), arg0, arg1) } // GetLocalTriggerIDs mocks base method func (m *MockDatabase) GetLocalTriggerIDs() ([]string, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetLocalTriggerIDs") ret0, _ := ret[0].([]string) ret1, _ := ret[1].(error) @@ -259,11 +293,13 @@ func (m *MockDatabase) GetLocalTriggerIDs() ([]string, error) { // GetLocalTriggerIDs indicates an expected call of GetLocalTriggerIDs func (mr *MockDatabaseMockRecorder) GetLocalTriggerIDs() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLocalTriggerIDs", reflect.TypeOf((*MockDatabase)(nil).GetLocalTriggerIDs)) } // GetLocalTriggersToCheck mocks base method func (m *MockDatabase) GetLocalTriggersToCheck(arg0 int) ([]string, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetLocalTriggersToCheck", arg0) ret0, _ := ret[0].([]string) ret1, _ := ret[1].(error) @@ -272,11 +308,13 @@ func (m *MockDatabase) GetLocalTriggersToCheck(arg0 int) ([]string, error) { // GetLocalTriggersToCheck indicates an expected call of GetLocalTriggersToCheck func (mr *MockDatabaseMockRecorder) GetLocalTriggersToCheck(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLocalTriggersToCheck", reflect.TypeOf((*MockDatabase)(nil).GetLocalTriggersToCheck), arg0) } // GetLocalTriggersToCheckCount mocks base method func (m *MockDatabase) GetLocalTriggersToCheckCount() (int64, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetLocalTriggersToCheckCount") ret0, _ := ret[0].(int64) ret1, _ := ret[1].(error) @@ -285,11 +323,13 @@ func (m *MockDatabase) GetLocalTriggersToCheckCount() (int64, error) { // GetLocalTriggersToCheckCount indicates an expected call of GetLocalTriggersToCheckCount func (mr *MockDatabaseMockRecorder) GetLocalTriggersToCheckCount() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLocalTriggersToCheckCount", reflect.TypeOf((*MockDatabase)(nil).GetLocalTriggersToCheckCount)) } // GetMetricRetention mocks base method func (m *MockDatabase) GetMetricRetention(arg0 string) (int64, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetMetricRetention", arg0) ret0, _ := ret[0].(int64) ret1, _ := ret[1].(error) @@ -298,11 +338,13 @@ func (m *MockDatabase) GetMetricRetention(arg0 string) (int64, error) { // GetMetricRetention indicates an expected call of GetMetricRetention func (mr *MockDatabaseMockRecorder) GetMetricRetention(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetricRetention", reflect.TypeOf((*MockDatabase)(nil).GetMetricRetention), arg0) } // GetMetricsUpdatesCount mocks base method func (m *MockDatabase) GetMetricsUpdatesCount() (int64, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetMetricsUpdatesCount") ret0, _ := ret[0].(int64) ret1, _ := ret[1].(error) @@ -311,11 +353,13 @@ func (m *MockDatabase) GetMetricsUpdatesCount() (int64, error) { // GetMetricsUpdatesCount indicates an expected call of GetMetricsUpdatesCount func (mr *MockDatabaseMockRecorder) GetMetricsUpdatesCount() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetricsUpdatesCount", reflect.TypeOf((*MockDatabase)(nil).GetMetricsUpdatesCount)) } // GetMetricsValues mocks base method func (m *MockDatabase) GetMetricsValues(arg0 []string, arg1, arg2 int64) (map[string][]*moira.MetricValue, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetMetricsValues", arg0, arg1, arg2) ret0, _ := ret[0].(map[string][]*moira.MetricValue) ret1, _ := ret[1].(error) @@ -324,11 +368,13 @@ func (m *MockDatabase) GetMetricsValues(arg0 []string, arg1, arg2 int64) (map[st // GetMetricsValues indicates an expected call of GetMetricsValues func (mr *MockDatabaseMockRecorder) GetMetricsValues(arg0, arg1, arg2 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMetricsValues", reflect.TypeOf((*MockDatabase)(nil).GetMetricsValues), arg0, arg1, arg2) } // GetNotificationEventCount mocks base method func (m *MockDatabase) GetNotificationEventCount(arg0 string, arg1 int64) int64 { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetNotificationEventCount", arg0, arg1) ret0, _ := ret[0].(int64) return ret0 @@ -336,11 +382,13 @@ func (m *MockDatabase) GetNotificationEventCount(arg0 string, arg1 int64) int64 // GetNotificationEventCount indicates an expected call of GetNotificationEventCount func (mr *MockDatabaseMockRecorder) GetNotificationEventCount(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNotificationEventCount", reflect.TypeOf((*MockDatabase)(nil).GetNotificationEventCount), arg0, arg1) } // GetNotificationEvents mocks base method func (m *MockDatabase) GetNotificationEvents(arg0 string, arg1, arg2 int64) ([]*moira.NotificationEvent, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetNotificationEvents", arg0, arg1, arg2) ret0, _ := ret[0].([]*moira.NotificationEvent) ret1, _ := ret[1].(error) @@ -349,11 +397,13 @@ func (m *MockDatabase) GetNotificationEvents(arg0 string, arg1, arg2 int64) ([]* // GetNotificationEvents indicates an expected call of GetNotificationEvents func (mr *MockDatabaseMockRecorder) GetNotificationEvents(arg0, arg1, arg2 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNotificationEvents", reflect.TypeOf((*MockDatabase)(nil).GetNotificationEvents), arg0, arg1, arg2) } // GetNotifications mocks base method func (m *MockDatabase) GetNotifications(arg0, arg1 int64) ([]*moira.ScheduledNotification, int64, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetNotifications", arg0, arg1) ret0, _ := ret[0].([]*moira.ScheduledNotification) ret1, _ := ret[1].(int64) @@ -363,11 +413,13 @@ func (m *MockDatabase) GetNotifications(arg0, arg1 int64) ([]*moira.ScheduledNot // GetNotifications indicates an expected call of GetNotifications func (mr *MockDatabaseMockRecorder) GetNotifications(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNotifications", reflect.TypeOf((*MockDatabase)(nil).GetNotifications), arg0, arg1) } // GetNotifierState mocks base method func (m *MockDatabase) GetNotifierState() (string, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetNotifierState") ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) @@ -376,11 +428,13 @@ func (m *MockDatabase) GetNotifierState() (string, error) { // GetNotifierState indicates an expected call of GetNotifierState func (mr *MockDatabaseMockRecorder) GetNotifierState() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNotifierState", reflect.TypeOf((*MockDatabase)(nil).GetNotifierState)) } // GetPatternMetrics mocks base method func (m *MockDatabase) GetPatternMetrics(arg0 string) ([]string, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetPatternMetrics", arg0) ret0, _ := ret[0].([]string) ret1, _ := ret[1].(error) @@ -389,11 +443,13 @@ func (m *MockDatabase) GetPatternMetrics(arg0 string) ([]string, error) { // GetPatternMetrics indicates an expected call of GetPatternMetrics func (mr *MockDatabaseMockRecorder) GetPatternMetrics(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPatternMetrics", reflect.TypeOf((*MockDatabase)(nil).GetPatternMetrics), arg0) } // GetPatternTriggerIDs mocks base method func (m *MockDatabase) GetPatternTriggerIDs(arg0 string) ([]string, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetPatternTriggerIDs", arg0) ret0, _ := ret[0].([]string) ret1, _ := ret[1].(error) @@ -402,11 +458,13 @@ func (m *MockDatabase) GetPatternTriggerIDs(arg0 string) ([]string, error) { // GetPatternTriggerIDs indicates an expected call of GetPatternTriggerIDs func (mr *MockDatabaseMockRecorder) GetPatternTriggerIDs(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPatternTriggerIDs", reflect.TypeOf((*MockDatabase)(nil).GetPatternTriggerIDs), arg0) } // GetPatterns mocks base method func (m *MockDatabase) GetPatterns() ([]string, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetPatterns") ret0, _ := ret[0].([]string) ret1, _ := ret[1].(error) @@ -415,11 +473,13 @@ func (m *MockDatabase) GetPatterns() ([]string, error) { // GetPatterns indicates an expected call of GetPatterns func (mr *MockDatabaseMockRecorder) GetPatterns() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPatterns", reflect.TypeOf((*MockDatabase)(nil).GetPatterns)) } // GetRemoteChecksUpdatesCount mocks base method func (m *MockDatabase) GetRemoteChecksUpdatesCount() (int64, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetRemoteChecksUpdatesCount") ret0, _ := ret[0].(int64) ret1, _ := ret[1].(error) @@ -428,11 +488,13 @@ func (m *MockDatabase) GetRemoteChecksUpdatesCount() (int64, error) { // GetRemoteChecksUpdatesCount indicates an expected call of GetRemoteChecksUpdatesCount func (mr *MockDatabaseMockRecorder) GetRemoteChecksUpdatesCount() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRemoteChecksUpdatesCount", reflect.TypeOf((*MockDatabase)(nil).GetRemoteChecksUpdatesCount)) } // GetRemoteTriggerIDs mocks base method func (m *MockDatabase) GetRemoteTriggerIDs() ([]string, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetRemoteTriggerIDs") ret0, _ := ret[0].([]string) ret1, _ := ret[1].(error) @@ -441,11 +503,13 @@ func (m *MockDatabase) GetRemoteTriggerIDs() ([]string, error) { // GetRemoteTriggerIDs indicates an expected call of GetRemoteTriggerIDs func (mr *MockDatabaseMockRecorder) GetRemoteTriggerIDs() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRemoteTriggerIDs", reflect.TypeOf((*MockDatabase)(nil).GetRemoteTriggerIDs)) } // GetRemoteTriggersToCheck mocks base method func (m *MockDatabase) GetRemoteTriggersToCheck(arg0 int) ([]string, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetRemoteTriggersToCheck", arg0) ret0, _ := ret[0].([]string) ret1, _ := ret[1].(error) @@ -454,11 +518,13 @@ func (m *MockDatabase) GetRemoteTriggersToCheck(arg0 int) ([]string, error) { // GetRemoteTriggersToCheck indicates an expected call of GetRemoteTriggersToCheck func (mr *MockDatabaseMockRecorder) GetRemoteTriggersToCheck(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRemoteTriggersToCheck", reflect.TypeOf((*MockDatabase)(nil).GetRemoteTriggersToCheck), arg0) } // GetRemoteTriggersToCheckCount mocks base method func (m *MockDatabase) GetRemoteTriggersToCheckCount() (int64, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetRemoteTriggersToCheckCount") ret0, _ := ret[0].(int64) ret1, _ := ret[1].(error) @@ -467,11 +533,13 @@ func (m *MockDatabase) GetRemoteTriggersToCheckCount() (int64, error) { // GetRemoteTriggersToCheckCount indicates an expected call of GetRemoteTriggersToCheckCount func (mr *MockDatabaseMockRecorder) GetRemoteTriggersToCheckCount() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRemoteTriggersToCheckCount", reflect.TypeOf((*MockDatabase)(nil).GetRemoteTriggersToCheckCount)) } // GetSubscription mocks base method func (m *MockDatabase) GetSubscription(arg0 string) (moira.SubscriptionData, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetSubscription", arg0) ret0, _ := ret[0].(moira.SubscriptionData) ret1, _ := ret[1].(error) @@ -480,11 +548,13 @@ func (m *MockDatabase) GetSubscription(arg0 string) (moira.SubscriptionData, err // GetSubscription indicates an expected call of GetSubscription func (mr *MockDatabaseMockRecorder) GetSubscription(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubscription", reflect.TypeOf((*MockDatabase)(nil).GetSubscription), arg0) } // GetSubscriptions mocks base method func (m *MockDatabase) GetSubscriptions(arg0 []string) ([]*moira.SubscriptionData, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetSubscriptions", arg0) ret0, _ := ret[0].([]*moira.SubscriptionData) ret1, _ := ret[1].(error) @@ -493,11 +563,13 @@ func (m *MockDatabase) GetSubscriptions(arg0 []string) ([]*moira.SubscriptionDat // GetSubscriptions indicates an expected call of GetSubscriptions func (mr *MockDatabaseMockRecorder) GetSubscriptions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubscriptions", reflect.TypeOf((*MockDatabase)(nil).GetSubscriptions), arg0) } // GetTagNames mocks base method func (m *MockDatabase) GetTagNames() ([]string, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetTagNames") ret0, _ := ret[0].([]string) ret1, _ := ret[1].(error) @@ -506,11 +578,13 @@ func (m *MockDatabase) GetTagNames() ([]string, error) { // GetTagNames indicates an expected call of GetTagNames func (mr *MockDatabaseMockRecorder) GetTagNames() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTagNames", reflect.TypeOf((*MockDatabase)(nil).GetTagNames)) } // GetTagTriggerIDs mocks base method func (m *MockDatabase) GetTagTriggerIDs(arg0 string) ([]string, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetTagTriggerIDs", arg0) ret0, _ := ret[0].([]string) ret1, _ := ret[1].(error) @@ -519,11 +593,13 @@ func (m *MockDatabase) GetTagTriggerIDs(arg0 string) ([]string, error) { // GetTagTriggerIDs indicates an expected call of GetTagTriggerIDs func (mr *MockDatabaseMockRecorder) GetTagTriggerIDs(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTagTriggerIDs", reflect.TypeOf((*MockDatabase)(nil).GetTagTriggerIDs), arg0) } // GetTagsSubscriptions mocks base method func (m *MockDatabase) GetTagsSubscriptions(arg0 []string) ([]*moira.SubscriptionData, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetTagsSubscriptions", arg0) ret0, _ := ret[0].([]*moira.SubscriptionData) ret1, _ := ret[1].(error) @@ -532,11 +608,13 @@ func (m *MockDatabase) GetTagsSubscriptions(arg0 []string) ([]*moira.Subscriptio // GetTagsSubscriptions indicates an expected call of GetTagsSubscriptions func (mr *MockDatabaseMockRecorder) GetTagsSubscriptions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTagsSubscriptions", reflect.TypeOf((*MockDatabase)(nil).GetTagsSubscriptions), arg0) } // GetTrigger mocks base method func (m *MockDatabase) GetTrigger(arg0 string) (moira.Trigger, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetTrigger", arg0) ret0, _ := ret[0].(moira.Trigger) ret1, _ := ret[1].(error) @@ -545,11 +623,13 @@ func (m *MockDatabase) GetTrigger(arg0 string) (moira.Trigger, error) { // GetTrigger indicates an expected call of GetTrigger func (mr *MockDatabaseMockRecorder) GetTrigger(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrigger", reflect.TypeOf((*MockDatabase)(nil).GetTrigger), arg0) } // GetTriggerChecks mocks base method func (m *MockDatabase) GetTriggerChecks(arg0 []string) ([]*moira.TriggerCheck, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetTriggerChecks", arg0) ret0, _ := ret[0].([]*moira.TriggerCheck) ret1, _ := ret[1].(error) @@ -558,11 +638,13 @@ func (m *MockDatabase) GetTriggerChecks(arg0 []string) ([]*moira.TriggerCheck, e // GetTriggerChecks indicates an expected call of GetTriggerChecks func (mr *MockDatabaseMockRecorder) GetTriggerChecks(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTriggerChecks", reflect.TypeOf((*MockDatabase)(nil).GetTriggerChecks), arg0) } // GetTriggerLastCheck mocks base method func (m *MockDatabase) GetTriggerLastCheck(arg0 string) (moira.CheckData, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetTriggerLastCheck", arg0) ret0, _ := ret[0].(moira.CheckData) ret1, _ := ret[1].(error) @@ -571,11 +653,13 @@ func (m *MockDatabase) GetTriggerLastCheck(arg0 string) (moira.CheckData, error) // GetTriggerLastCheck indicates an expected call of GetTriggerLastCheck func (mr *MockDatabaseMockRecorder) GetTriggerLastCheck(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTriggerLastCheck", reflect.TypeOf((*MockDatabase)(nil).GetTriggerLastCheck), arg0) } // GetTriggerThrottling mocks base method func (m *MockDatabase) GetTriggerThrottling(arg0 string) (time.Time, time.Time) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetTriggerThrottling", arg0) ret0, _ := ret[0].(time.Time) ret1, _ := ret[1].(time.Time) @@ -584,11 +668,13 @@ func (m *MockDatabase) GetTriggerThrottling(arg0 string) (time.Time, time.Time) // GetTriggerThrottling indicates an expected call of GetTriggerThrottling func (mr *MockDatabaseMockRecorder) GetTriggerThrottling(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTriggerThrottling", reflect.TypeOf((*MockDatabase)(nil).GetTriggerThrottling), arg0) } // GetTriggers mocks base method func (m *MockDatabase) GetTriggers(arg0 []string) ([]*moira.Trigger, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetTriggers", arg0) ret0, _ := ret[0].([]*moira.Trigger) ret1, _ := ret[1].(error) @@ -597,11 +683,29 @@ func (m *MockDatabase) GetTriggers(arg0 []string) ([]*moira.Trigger, error) { // GetTriggers indicates an expected call of GetTriggers func (mr *MockDatabaseMockRecorder) GetTriggers(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTriggers", reflect.TypeOf((*MockDatabase)(nil).GetTriggers), arg0) } +// GetTriggersSearchResults mocks base method +func (m *MockDatabase) GetTriggersSearchResults(arg0 string, arg1, arg2 int64) ([]*moira.SearchResult, int64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTriggersSearchResults", arg0, arg1, arg2) + ret0, _ := ret[0].([]*moira.SearchResult) + ret1, _ := ret[1].(int64) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// GetTriggersSearchResults indicates an expected call of GetTriggersSearchResults +func (mr *MockDatabaseMockRecorder) GetTriggersSearchResults(arg0, arg1, arg2 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTriggersSearchResults", reflect.TypeOf((*MockDatabase)(nil).GetTriggersSearchResults), arg0, arg1, arg2) +} + // GetUnusedTriggerIDs mocks base method func (m *MockDatabase) GetUnusedTriggerIDs() ([]string, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetUnusedTriggerIDs") ret0, _ := ret[0].([]string) ret1, _ := ret[1].(error) @@ -610,11 +714,13 @@ func (m *MockDatabase) GetUnusedTriggerIDs() ([]string, error) { // GetUnusedTriggerIDs indicates an expected call of GetUnusedTriggerIDs func (mr *MockDatabaseMockRecorder) GetUnusedTriggerIDs() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUnusedTriggerIDs", reflect.TypeOf((*MockDatabase)(nil).GetUnusedTriggerIDs)) } // GetUserContactIDs mocks base method func (m *MockDatabase) GetUserContactIDs(arg0 string) ([]string, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetUserContactIDs", arg0) ret0, _ := ret[0].([]string) ret1, _ := ret[1].(error) @@ -623,11 +729,13 @@ func (m *MockDatabase) GetUserContactIDs(arg0 string) ([]string, error) { // GetUserContactIDs indicates an expected call of GetUserContactIDs func (mr *MockDatabaseMockRecorder) GetUserContactIDs(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserContactIDs", reflect.TypeOf((*MockDatabase)(nil).GetUserContactIDs), arg0) } // GetUserSubscriptionIDs mocks base method func (m *MockDatabase) GetUserSubscriptionIDs(arg0 string) ([]string, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetUserSubscriptionIDs", arg0) ret0, _ := ret[0].([]string) ret1, _ := ret[1].(error) @@ -636,11 +744,13 @@ func (m *MockDatabase) GetUserSubscriptionIDs(arg0 string) ([]string, error) { // GetUserSubscriptionIDs indicates an expected call of GetUserSubscriptionIDs func (mr *MockDatabaseMockRecorder) GetUserSubscriptionIDs(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserSubscriptionIDs", reflect.TypeOf((*MockDatabase)(nil).GetUserSubscriptionIDs), arg0) } // MarkTriggersAsUnused mocks base method func (m *MockDatabase) MarkTriggersAsUnused(arg0 ...string) error { + m.ctrl.T.Helper() varargs := []interface{}{} for _, a := range arg0 { varargs = append(varargs, a) @@ -652,11 +762,13 @@ func (m *MockDatabase) MarkTriggersAsUnused(arg0 ...string) error { // MarkTriggersAsUnused indicates an expected call of MarkTriggersAsUnused func (mr *MockDatabaseMockRecorder) MarkTriggersAsUnused(arg0 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkTriggersAsUnused", reflect.TypeOf((*MockDatabase)(nil).MarkTriggersAsUnused), arg0...) } // MarkTriggersAsUsed mocks base method func (m *MockDatabase) MarkTriggersAsUsed(arg0 ...string) error { + m.ctrl.T.Helper() varargs := []interface{}{} for _, a := range arg0 { varargs = append(varargs, a) @@ -668,11 +780,13 @@ func (m *MockDatabase) MarkTriggersAsUsed(arg0 ...string) error { // MarkTriggersAsUsed indicates an expected call of MarkTriggersAsUsed func (mr *MockDatabaseMockRecorder) MarkTriggersAsUsed(arg0 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkTriggersAsUsed", reflect.TypeOf((*MockDatabase)(nil).MarkTriggersAsUsed), arg0...) } // NewLock mocks base method func (m *MockDatabase) NewLock(arg0 string, arg1 time.Duration) moira.Lock { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "NewLock", arg0, arg1) ret0, _ := ret[0].(moira.Lock) return ret0 @@ -680,11 +794,13 @@ func (m *MockDatabase) NewLock(arg0 string, arg1 time.Duration) moira.Lock { // NewLock indicates an expected call of NewLock func (mr *MockDatabaseMockRecorder) NewLock(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewLock", reflect.TypeOf((*MockDatabase)(nil).NewLock), arg0, arg1) } // PushNotificationEvent mocks base method func (m *MockDatabase) PushNotificationEvent(arg0 *moira.NotificationEvent, arg1 bool) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "PushNotificationEvent", arg0, arg1) ret0, _ := ret[0].(error) return ret0 @@ -692,11 +808,13 @@ func (m *MockDatabase) PushNotificationEvent(arg0 *moira.NotificationEvent, arg1 // PushNotificationEvent indicates an expected call of PushNotificationEvent func (mr *MockDatabaseMockRecorder) PushNotificationEvent(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PushNotificationEvent", reflect.TypeOf((*MockDatabase)(nil).PushNotificationEvent), arg0, arg1) } // RemoveAllNotificationEvents mocks base method func (m *MockDatabase) RemoveAllNotificationEvents() error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RemoveAllNotificationEvents") ret0, _ := ret[0].(error) return ret0 @@ -704,11 +822,13 @@ func (m *MockDatabase) RemoveAllNotificationEvents() error { // RemoveAllNotificationEvents indicates an expected call of RemoveAllNotificationEvents func (mr *MockDatabaseMockRecorder) RemoveAllNotificationEvents() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveAllNotificationEvents", reflect.TypeOf((*MockDatabase)(nil).RemoveAllNotificationEvents)) } // RemoveAllNotifications mocks base method func (m *MockDatabase) RemoveAllNotifications() error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RemoveAllNotifications") ret0, _ := ret[0].(error) return ret0 @@ -716,11 +836,13 @@ func (m *MockDatabase) RemoveAllNotifications() error { // RemoveAllNotifications indicates an expected call of RemoveAllNotifications func (mr *MockDatabaseMockRecorder) RemoveAllNotifications() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveAllNotifications", reflect.TypeOf((*MockDatabase)(nil).RemoveAllNotifications)) } // RemoveContact mocks base method func (m *MockDatabase) RemoveContact(arg0 string) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RemoveContact", arg0) ret0, _ := ret[0].(error) return ret0 @@ -728,11 +850,13 @@ func (m *MockDatabase) RemoveContact(arg0 string) error { // RemoveContact indicates an expected call of RemoveContact func (mr *MockDatabaseMockRecorder) RemoveContact(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveContact", reflect.TypeOf((*MockDatabase)(nil).RemoveContact), arg0) } // RemoveMetricValues mocks base method func (m *MockDatabase) RemoveMetricValues(arg0 string, arg1 int64) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RemoveMetricValues", arg0, arg1) ret0, _ := ret[0].(error) return ret0 @@ -740,11 +864,13 @@ func (m *MockDatabase) RemoveMetricValues(arg0 string, arg1 int64) error { // RemoveMetricValues indicates an expected call of RemoveMetricValues func (mr *MockDatabaseMockRecorder) RemoveMetricValues(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveMetricValues", reflect.TypeOf((*MockDatabase)(nil).RemoveMetricValues), arg0, arg1) } // RemoveMetricsValues mocks base method func (m *MockDatabase) RemoveMetricsValues(arg0 []string, arg1 int64) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RemoveMetricsValues", arg0, arg1) ret0, _ := ret[0].(error) return ret0 @@ -752,11 +878,13 @@ func (m *MockDatabase) RemoveMetricsValues(arg0 []string, arg1 int64) error { // RemoveMetricsValues indicates an expected call of RemoveMetricsValues func (mr *MockDatabaseMockRecorder) RemoveMetricsValues(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveMetricsValues", reflect.TypeOf((*MockDatabase)(nil).RemoveMetricsValues), arg0, arg1) } // RemoveNotification mocks base method func (m *MockDatabase) RemoveNotification(arg0 string) (int64, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RemoveNotification", arg0) ret0, _ := ret[0].(int64) ret1, _ := ret[1].(error) @@ -765,11 +893,13 @@ func (m *MockDatabase) RemoveNotification(arg0 string) (int64, error) { // RemoveNotification indicates an expected call of RemoveNotification func (mr *MockDatabaseMockRecorder) RemoveNotification(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveNotification", reflect.TypeOf((*MockDatabase)(nil).RemoveNotification), arg0) } // RemovePattern mocks base method func (m *MockDatabase) RemovePattern(arg0 string) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RemovePattern", arg0) ret0, _ := ret[0].(error) return ret0 @@ -777,11 +907,13 @@ func (m *MockDatabase) RemovePattern(arg0 string) error { // RemovePattern indicates an expected call of RemovePattern func (mr *MockDatabaseMockRecorder) RemovePattern(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePattern", reflect.TypeOf((*MockDatabase)(nil).RemovePattern), arg0) } // RemovePatternTriggerIDs mocks base method func (m *MockDatabase) RemovePatternTriggerIDs(arg0 string) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RemovePatternTriggerIDs", arg0) ret0, _ := ret[0].(error) return ret0 @@ -789,11 +921,13 @@ func (m *MockDatabase) RemovePatternTriggerIDs(arg0 string) error { // RemovePatternTriggerIDs indicates an expected call of RemovePatternTriggerIDs func (mr *MockDatabaseMockRecorder) RemovePatternTriggerIDs(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePatternTriggerIDs", reflect.TypeOf((*MockDatabase)(nil).RemovePatternTriggerIDs), arg0) } // RemovePatternWithMetrics mocks base method func (m *MockDatabase) RemovePatternWithMetrics(arg0 string) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RemovePatternWithMetrics", arg0) ret0, _ := ret[0].(error) return ret0 @@ -801,11 +935,13 @@ func (m *MockDatabase) RemovePatternWithMetrics(arg0 string) error { // RemovePatternWithMetrics indicates an expected call of RemovePatternWithMetrics func (mr *MockDatabaseMockRecorder) RemovePatternWithMetrics(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePatternWithMetrics", reflect.TypeOf((*MockDatabase)(nil).RemovePatternWithMetrics), arg0) } // RemovePatternsMetrics mocks base method func (m *MockDatabase) RemovePatternsMetrics(arg0 []string) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RemovePatternsMetrics", arg0) ret0, _ := ret[0].(error) return ret0 @@ -813,11 +949,13 @@ func (m *MockDatabase) RemovePatternsMetrics(arg0 []string) error { // RemovePatternsMetrics indicates an expected call of RemovePatternsMetrics func (mr *MockDatabaseMockRecorder) RemovePatternsMetrics(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePatternsMetrics", reflect.TypeOf((*MockDatabase)(nil).RemovePatternsMetrics), arg0) } // RemoveSubscription mocks base method func (m *MockDatabase) RemoveSubscription(arg0 string) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RemoveSubscription", arg0) ret0, _ := ret[0].(error) return ret0 @@ -825,11 +963,13 @@ func (m *MockDatabase) RemoveSubscription(arg0 string) error { // RemoveSubscription indicates an expected call of RemoveSubscription func (mr *MockDatabaseMockRecorder) RemoveSubscription(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveSubscription", reflect.TypeOf((*MockDatabase)(nil).RemoveSubscription), arg0) } // RemoveTag mocks base method func (m *MockDatabase) RemoveTag(arg0 string) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RemoveTag", arg0) ret0, _ := ret[0].(error) return ret0 @@ -837,11 +977,13 @@ func (m *MockDatabase) RemoveTag(arg0 string) error { // RemoveTag indicates an expected call of RemoveTag func (mr *MockDatabaseMockRecorder) RemoveTag(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTag", reflect.TypeOf((*MockDatabase)(nil).RemoveTag), arg0) } // RemoveTrigger mocks base method func (m *MockDatabase) RemoveTrigger(arg0 string) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RemoveTrigger", arg0) ret0, _ := ret[0].(error) return ret0 @@ -849,11 +991,13 @@ func (m *MockDatabase) RemoveTrigger(arg0 string) error { // RemoveTrigger indicates an expected call of RemoveTrigger func (mr *MockDatabaseMockRecorder) RemoveTrigger(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTrigger", reflect.TypeOf((*MockDatabase)(nil).RemoveTrigger), arg0) } // RemoveTriggerLastCheck mocks base method func (m *MockDatabase) RemoveTriggerLastCheck(arg0 string) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RemoveTriggerLastCheck", arg0) ret0, _ := ret[0].(error) return ret0 @@ -861,11 +1005,13 @@ func (m *MockDatabase) RemoveTriggerLastCheck(arg0 string) error { // RemoveTriggerLastCheck indicates an expected call of RemoveTriggerLastCheck func (mr *MockDatabaseMockRecorder) RemoveTriggerLastCheck(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTriggerLastCheck", reflect.TypeOf((*MockDatabase)(nil).RemoveTriggerLastCheck), arg0) } // RemoveTriggersToReindex mocks base method func (m *MockDatabase) RemoveTriggersToReindex(arg0 int64) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RemoveTriggersToReindex", arg0) ret0, _ := ret[0].(error) return ret0 @@ -873,11 +1019,13 @@ func (m *MockDatabase) RemoveTriggersToReindex(arg0 int64) error { // RemoveTriggersToReindex indicates an expected call of RemoveTriggersToReindex func (mr *MockDatabaseMockRecorder) RemoveTriggersToReindex(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTriggersToReindex", reflect.TypeOf((*MockDatabase)(nil).RemoveTriggersToReindex), arg0) } // RemoveUser mocks base method func (m *MockDatabase) RemoveUser(arg0, arg1 string) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RemoveUser", arg0, arg1) ret0, _ := ret[0].(error) return ret0 @@ -885,11 +1033,13 @@ func (m *MockDatabase) RemoveUser(arg0, arg1 string) error { // RemoveUser indicates an expected call of RemoveUser func (mr *MockDatabaseMockRecorder) RemoveUser(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveUser", reflect.TypeOf((*MockDatabase)(nil).RemoveUser), arg0, arg1) } // SaveContact mocks base method func (m *MockDatabase) SaveContact(arg0 *moira.ContactData) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SaveContact", arg0) ret0, _ := ret[0].(error) return ret0 @@ -897,11 +1047,13 @@ func (m *MockDatabase) SaveContact(arg0 *moira.ContactData) error { // SaveContact indicates an expected call of SaveContact func (mr *MockDatabaseMockRecorder) SaveContact(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveContact", reflect.TypeOf((*MockDatabase)(nil).SaveContact), arg0) } // SaveMetrics mocks base method func (m *MockDatabase) SaveMetrics(arg0 map[string]*moira.MatchedMetric) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SaveMetrics", arg0) ret0, _ := ret[0].(error) return ret0 @@ -909,11 +1061,13 @@ func (m *MockDatabase) SaveMetrics(arg0 map[string]*moira.MatchedMetric) error { // SaveMetrics indicates an expected call of SaveMetrics func (mr *MockDatabaseMockRecorder) SaveMetrics(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveMetrics", reflect.TypeOf((*MockDatabase)(nil).SaveMetrics), arg0) } // SaveSubscription mocks base method func (m *MockDatabase) SaveSubscription(arg0 *moira.SubscriptionData) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SaveSubscription", arg0) ret0, _ := ret[0].(error) return ret0 @@ -921,11 +1075,13 @@ func (m *MockDatabase) SaveSubscription(arg0 *moira.SubscriptionData) error { // SaveSubscription indicates an expected call of SaveSubscription func (mr *MockDatabaseMockRecorder) SaveSubscription(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveSubscription", reflect.TypeOf((*MockDatabase)(nil).SaveSubscription), arg0) } // SaveSubscriptions mocks base method func (m *MockDatabase) SaveSubscriptions(arg0 []*moira.SubscriptionData) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SaveSubscriptions", arg0) ret0, _ := ret[0].(error) return ret0 @@ -933,11 +1089,13 @@ func (m *MockDatabase) SaveSubscriptions(arg0 []*moira.SubscriptionData) error { // SaveSubscriptions indicates an expected call of SaveSubscriptions func (mr *MockDatabaseMockRecorder) SaveSubscriptions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveSubscriptions", reflect.TypeOf((*MockDatabase)(nil).SaveSubscriptions), arg0) } // SaveTrigger mocks base method func (m *MockDatabase) SaveTrigger(arg0 string, arg1 *moira.Trigger) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SaveTrigger", arg0, arg1) ret0, _ := ret[0].(error) return ret0 @@ -945,11 +1103,27 @@ func (m *MockDatabase) SaveTrigger(arg0 string, arg1 *moira.Trigger) error { // SaveTrigger indicates an expected call of SaveTrigger func (mr *MockDatabaseMockRecorder) SaveTrigger(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveTrigger", reflect.TypeOf((*MockDatabase)(nil).SaveTrigger), arg0, arg1) } +// SaveTriggersSearchResults mocks base method +func (m *MockDatabase) SaveTriggersSearchResults(arg0 string, arg1 []*moira.SearchResult) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SaveTriggersSearchResults", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// SaveTriggersSearchResults indicates an expected call of SaveTriggersSearchResults +func (mr *MockDatabaseMockRecorder) SaveTriggersSearchResults(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveTriggersSearchResults", reflect.TypeOf((*MockDatabase)(nil).SaveTriggersSearchResults), arg0, arg1) +} + // SetNotifierState mocks base method func (m *MockDatabase) SetNotifierState(arg0 string) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SetNotifierState", arg0) ret0, _ := ret[0].(error) return ret0 @@ -957,11 +1131,13 @@ func (m *MockDatabase) SetNotifierState(arg0 string) error { // SetNotifierState indicates an expected call of SetNotifierState func (mr *MockDatabaseMockRecorder) SetNotifierState(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNotifierState", reflect.TypeOf((*MockDatabase)(nil).SetNotifierState), arg0) } // SetTriggerCheckLock mocks base method func (m *MockDatabase) SetTriggerCheckLock(arg0 string) (bool, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SetTriggerCheckLock", arg0) ret0, _ := ret[0].(bool) ret1, _ := ret[1].(error) @@ -970,11 +1146,13 @@ func (m *MockDatabase) SetTriggerCheckLock(arg0 string) (bool, error) { // SetTriggerCheckLock indicates an expected call of SetTriggerCheckLock func (mr *MockDatabaseMockRecorder) SetTriggerCheckLock(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTriggerCheckLock", reflect.TypeOf((*MockDatabase)(nil).SetTriggerCheckLock), arg0) } // SetTriggerCheckMaintenance mocks base method func (m *MockDatabase) SetTriggerCheckMaintenance(arg0 string, arg1 map[string]int64, arg2 *int64, arg3 string, arg4 int64) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SetTriggerCheckMaintenance", arg0, arg1, arg2, arg3, arg4) ret0, _ := ret[0].(error) return ret0 @@ -982,11 +1160,13 @@ func (m *MockDatabase) SetTriggerCheckMaintenance(arg0 string, arg1 map[string]i // SetTriggerCheckMaintenance indicates an expected call of SetTriggerCheckMaintenance func (mr *MockDatabaseMockRecorder) SetTriggerCheckMaintenance(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTriggerCheckMaintenance", reflect.TypeOf((*MockDatabase)(nil).SetTriggerCheckMaintenance), arg0, arg1, arg2, arg3, arg4) } // SetTriggerLastCheck mocks base method func (m *MockDatabase) SetTriggerLastCheck(arg0 string, arg1 *moira.CheckData, arg2 bool) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SetTriggerLastCheck", arg0, arg1, arg2) ret0, _ := ret[0].(error) return ret0 @@ -994,11 +1174,13 @@ func (m *MockDatabase) SetTriggerLastCheck(arg0 string, arg1 *moira.CheckData, a // SetTriggerLastCheck indicates an expected call of SetTriggerLastCheck func (mr *MockDatabaseMockRecorder) SetTriggerLastCheck(arg0, arg1, arg2 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTriggerLastCheck", reflect.TypeOf((*MockDatabase)(nil).SetTriggerLastCheck), arg0, arg1, arg2) } // SetTriggerThrottling mocks base method func (m *MockDatabase) SetTriggerThrottling(arg0 string, arg1 time.Time) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SetTriggerThrottling", arg0, arg1) ret0, _ := ret[0].(error) return ret0 @@ -1006,11 +1188,13 @@ func (m *MockDatabase) SetTriggerThrottling(arg0 string, arg1 time.Time) error { // SetTriggerThrottling indicates an expected call of SetTriggerThrottling func (mr *MockDatabaseMockRecorder) SetTriggerThrottling(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTriggerThrottling", reflect.TypeOf((*MockDatabase)(nil).SetTriggerThrottling), arg0, arg1) } // SetUsernameID mocks base method func (m *MockDatabase) SetUsernameID(arg0, arg1, arg2 string) error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SetUsernameID", arg0, arg1, arg2) ret0, _ := ret[0].(error) return ret0 @@ -1018,11 +1202,13 @@ func (m *MockDatabase) SetUsernameID(arg0, arg1, arg2 string) error { // SetUsernameID indicates an expected call of SetUsernameID func (mr *MockDatabaseMockRecorder) SetUsernameID(arg0, arg1, arg2 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUsernameID", reflect.TypeOf((*MockDatabase)(nil).SetUsernameID), arg0, arg1, arg2) } // SubscribeMetricEvents mocks base method -func (m *MockDatabase) SubscribeMetricEvents(arg0 *tomb_v2.Tomb) (<-chan *moira.MetricEvent, error) { +func (m *MockDatabase) SubscribeMetricEvents(arg0 *tomb.Tomb) (<-chan *moira.MetricEvent, error) { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "SubscribeMetricEvents", arg0) ret0, _ := ret[0].(<-chan *moira.MetricEvent) ret1, _ := ret[1].(error) @@ -1031,11 +1217,13 @@ func (m *MockDatabase) SubscribeMetricEvents(arg0 *tomb_v2.Tomb) (<-chan *moira. // SubscribeMetricEvents indicates an expected call of SubscribeMetricEvents func (mr *MockDatabaseMockRecorder) SubscribeMetricEvents(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubscribeMetricEvents", reflect.TypeOf((*MockDatabase)(nil).SubscribeMetricEvents), arg0) } // UpdateMetricsHeartbeat mocks base method func (m *MockDatabase) UpdateMetricsHeartbeat() error { + m.ctrl.T.Helper() ret := m.ctrl.Call(m, "UpdateMetricsHeartbeat") ret0, _ := ret[0].(error) return ret0 @@ -1043,5 +1231,6 @@ func (m *MockDatabase) UpdateMetricsHeartbeat() error { // UpdateMetricsHeartbeat indicates an expected call of UpdateMetricsHeartbeat func (mr *MockDatabaseMockRecorder) UpdateMetricsHeartbeat() *gomock.Call { + mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMetricsHeartbeat", reflect.TypeOf((*MockDatabase)(nil).UpdateMetricsHeartbeat)) }