homethings/internal/repositories/mocks/thing_notification_repository_minimock.go

package mocks

// Code generated by http://github.com/gojuno/minimock (dev). DO NOT EDIT.

//go:generate minimock -i git.dmitriygnatenko.ru/dima/homethings/internal/interfaces.ThingNotificationRepository -o ./mocks/thing_notification_repository_minimock.go -n ThingNotificationRepositoryMock

import (
	"context"
	"database/sql"
	"sync"
	mm_atomic "sync/atomic"
	mm_time "time"

	"git.dmitriygnatenko.ru/dima/homethings/internal/models"
	"github.com/gojuno/minimock/v3"
)

// ThingNotificationRepositoryMock implements interfaces.ThingNotificationRepository
type ThingNotificationRepositoryMock struct {
	t minimock.Tester

	funcAdd          func(ctx context.Context, req models.AddThingNotificationRequest, tx *sql.Tx) (err error)
	inspectFuncAdd   func(ctx context.Context, req models.AddThingNotificationRequest, tx *sql.Tx)
	afterAddCounter  uint64
	beforeAddCounter uint64
	AddMock          mThingNotificationRepositoryMockAdd

	funcDelete          func(ctx context.Context, thingID int, tx *sql.Tx) (err error)
	inspectFuncDelete   func(ctx context.Context, thingID int, tx *sql.Tx)
	afterDeleteCounter  uint64
	beforeDeleteCounter uint64
	DeleteMock          mThingNotificationRepositoryMockDelete

	funcGet          func(ctx context.Context, thingID int) (tp1 *models.ThingNotification, err error)
	inspectFuncGet   func(ctx context.Context, thingID int)
	afterGetCounter  uint64
	beforeGetCounter uint64
	GetMock          mThingNotificationRepositoryMockGet

	funcGetExpired          func(ctx context.Context) (ea1 []models.ExtThingNotification, err error)
	inspectFuncGetExpired   func(ctx context.Context)
	afterGetExpiredCounter  uint64
	beforeGetExpiredCounter uint64
	GetExpiredMock          mThingNotificationRepositoryMockGetExpired

	funcUpdate          func(ctx context.Context, req models.UpdateThingNotificationRequest, tx *sql.Tx) (err error)
	inspectFuncUpdate   func(ctx context.Context, req models.UpdateThingNotificationRequest, tx *sql.Tx)
	afterUpdateCounter  uint64
	beforeUpdateCounter uint64
	UpdateMock          mThingNotificationRepositoryMockUpdate
}

// NewThingNotificationRepositoryMock returns a mock for interfaces.ThingNotificationRepository
func NewThingNotificationRepositoryMock(t minimock.Tester) *ThingNotificationRepositoryMock {
	m := &ThingNotificationRepositoryMock{t: t}
	if controller, ok := t.(minimock.MockController); ok {
		controller.RegisterMocker(m)
	}

	m.AddMock = mThingNotificationRepositoryMockAdd{mock: m}
	m.AddMock.callArgs = []*ThingNotificationRepositoryMockAddParams{}

	m.DeleteMock = mThingNotificationRepositoryMockDelete{mock: m}
	m.DeleteMock.callArgs = []*ThingNotificationRepositoryMockDeleteParams{}

	m.GetMock = mThingNotificationRepositoryMockGet{mock: m}
	m.GetMock.callArgs = []*ThingNotificationRepositoryMockGetParams{}

	m.GetExpiredMock = mThingNotificationRepositoryMockGetExpired{mock: m}
	m.GetExpiredMock.callArgs = []*ThingNotificationRepositoryMockGetExpiredParams{}

	m.UpdateMock = mThingNotificationRepositoryMockUpdate{mock: m}
	m.UpdateMock.callArgs = []*ThingNotificationRepositoryMockUpdateParams{}

	return m
}

type mThingNotificationRepositoryMockAdd struct {
	mock               *ThingNotificationRepositoryMock
	defaultExpectation *ThingNotificationRepositoryMockAddExpectation
	expectations       []*ThingNotificationRepositoryMockAddExpectation

	callArgs []*ThingNotificationRepositoryMockAddParams
	mutex    sync.RWMutex
}

// ThingNotificationRepositoryMockAddExpectation specifies expectation struct of the ThingNotificationRepository.Add
type ThingNotificationRepositoryMockAddExpectation struct {
	mock    *ThingNotificationRepositoryMock
	params  *ThingNotificationRepositoryMockAddParams
	results *ThingNotificationRepositoryMockAddResults
	Counter uint64
}

// ThingNotificationRepositoryMockAddParams contains parameters of the ThingNotificationRepository.Add
type ThingNotificationRepositoryMockAddParams struct {
	ctx context.Context
	req models.AddThingNotificationRequest
	tx  *sql.Tx
}

// ThingNotificationRepositoryMockAddResults contains results of the ThingNotificationRepository.Add
type ThingNotificationRepositoryMockAddResults struct {
	err error
}

// Expect sets up expected params for ThingNotificationRepository.Add
func (mmAdd *mThingNotificationRepositoryMockAdd) Expect(ctx context.Context, req models.AddThingNotificationRequest, tx *sql.Tx) *mThingNotificationRepositoryMockAdd {
	if mmAdd.mock.funcAdd != nil {
		mmAdd.mock.t.Fatalf("ThingNotificationRepositoryMock.Add mock is already set by Set")
	}

	if mmAdd.defaultExpectation == nil {
		mmAdd.defaultExpectation = &ThingNotificationRepositoryMockAddExpectation{}
	}

	mmAdd.defaultExpectation.params = &ThingNotificationRepositoryMockAddParams{ctx, req, tx}
	for _, e := range mmAdd.expectations {
		if minimock.Equal(e.params, mmAdd.defaultExpectation.params) {
			mmAdd.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmAdd.defaultExpectation.params)
		}
	}

	return mmAdd
}

// Inspect accepts an inspector function that has same arguments as the ThingNotificationRepository.Add
func (mmAdd *mThingNotificationRepositoryMockAdd) Inspect(f func(ctx context.Context, req models.AddThingNotificationRequest, tx *sql.Tx)) *mThingNotificationRepositoryMockAdd {
	if mmAdd.mock.inspectFuncAdd != nil {
		mmAdd.mock.t.Fatalf("Inspect function is already set for ThingNotificationRepositoryMock.Add")
	}

	mmAdd.mock.inspectFuncAdd = f

	return mmAdd
}

// Return sets up results that will be returned by ThingNotificationRepository.Add
func (mmAdd *mThingNotificationRepositoryMockAdd) Return(err error) *ThingNotificationRepositoryMock {
	if mmAdd.mock.funcAdd != nil {
		mmAdd.mock.t.Fatalf("ThingNotificationRepositoryMock.Add mock is already set by Set")
	}

	if mmAdd.defaultExpectation == nil {
		mmAdd.defaultExpectation = &ThingNotificationRepositoryMockAddExpectation{mock: mmAdd.mock}
	}
	mmAdd.defaultExpectation.results = &ThingNotificationRepositoryMockAddResults{err}
	return mmAdd.mock
}

//Set uses given function f to mock the ThingNotificationRepository.Add method
func (mmAdd *mThingNotificationRepositoryMockAdd) Set(f func(ctx context.Context, req models.AddThingNotificationRequest, tx *sql.Tx) (err error)) *ThingNotificationRepositoryMock {
	if mmAdd.defaultExpectation != nil {
		mmAdd.mock.t.Fatalf("Default expectation is already set for the ThingNotificationRepository.Add method")
	}

	if len(mmAdd.expectations) > 0 {
		mmAdd.mock.t.Fatalf("Some expectations are already set for the ThingNotificationRepository.Add method")
	}

	mmAdd.mock.funcAdd = f
	return mmAdd.mock
}

// When sets expectation for the ThingNotificationRepository.Add which will trigger the result defined by the following
// Then helper
func (mmAdd *mThingNotificationRepositoryMockAdd) When(ctx context.Context, req models.AddThingNotificationRequest, tx *sql.Tx) *ThingNotificationRepositoryMockAddExpectation {
	if mmAdd.mock.funcAdd != nil {
		mmAdd.mock.t.Fatalf("ThingNotificationRepositoryMock.Add mock is already set by Set")
	}

	expectation := &ThingNotificationRepositoryMockAddExpectation{
		mock:   mmAdd.mock,
		params: &ThingNotificationRepositoryMockAddParams{ctx, req, tx},
	}
	mmAdd.expectations = append(mmAdd.expectations, expectation)
	return expectation
}

// Then sets up ThingNotificationRepository.Add return parameters for the expectation previously defined by the When method
func (e *ThingNotificationRepositoryMockAddExpectation) Then(err error) *ThingNotificationRepositoryMock {
	e.results = &ThingNotificationRepositoryMockAddResults{err}
	return e.mock
}

// Add implements interfaces.ThingNotificationRepository
func (mmAdd *ThingNotificationRepositoryMock) Add(ctx context.Context, req models.AddThingNotificationRequest, tx *sql.Tx) (err error) {
	mm_atomic.AddUint64(&mmAdd.beforeAddCounter, 1)
	defer mm_atomic.AddUint64(&mmAdd.afterAddCounter, 1)

	if mmAdd.inspectFuncAdd != nil {
		mmAdd.inspectFuncAdd(ctx, req, tx)
	}

	mm_params := &ThingNotificationRepositoryMockAddParams{ctx, req, tx}

	// Record call args
	mmAdd.AddMock.mutex.Lock()
	mmAdd.AddMock.callArgs = append(mmAdd.AddMock.callArgs, mm_params)
	mmAdd.AddMock.mutex.Unlock()

	for _, e := range mmAdd.AddMock.expectations {
		if minimock.Equal(e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return e.results.err
		}
	}

	if mmAdd.AddMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmAdd.AddMock.defaultExpectation.Counter, 1)
		mm_want := mmAdd.AddMock.defaultExpectation.params
		mm_got := ThingNotificationRepositoryMockAddParams{ctx, req, tx}
		if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmAdd.t.Errorf("ThingNotificationRepositoryMock.Add got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}

		mm_results := mmAdd.AddMock.defaultExpectation.results
		if mm_results == nil {
			mmAdd.t.Fatal("No results are set for the ThingNotificationRepositoryMock.Add")
		}
		return (*mm_results).err
	}
	if mmAdd.funcAdd != nil {
		return mmAdd.funcAdd(ctx, req, tx)
	}
	mmAdd.t.Fatalf("Unexpected call to ThingNotificationRepositoryMock.Add. %v %v %v", ctx, req, tx)
	return
}

// AddAfterCounter returns a count of finished ThingNotificationRepositoryMock.Add invocations
func (mmAdd *ThingNotificationRepositoryMock) AddAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmAdd.afterAddCounter)
}

// AddBeforeCounter returns a count of ThingNotificationRepositoryMock.Add invocations
func (mmAdd *ThingNotificationRepositoryMock) AddBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmAdd.beforeAddCounter)
}

// Calls returns a list of arguments used in each call to ThingNotificationRepositoryMock.Add.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmAdd *mThingNotificationRepositoryMockAdd) Calls() []*ThingNotificationRepositoryMockAddParams {
	mmAdd.mutex.RLock()

	argCopy := make([]*ThingNotificationRepositoryMockAddParams, len(mmAdd.callArgs))
	copy(argCopy, mmAdd.callArgs)

	mmAdd.mutex.RUnlock()

	return argCopy
}

// MinimockAddDone returns true if the count of the Add invocations corresponds
// the number of defined expectations
func (m *ThingNotificationRepositoryMock) MinimockAddDone() bool {
	for _, e := range m.AddMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}

	// if default expectation was set then invocations count should be greater than zero
	if m.AddMock.defaultExpectation != nil && mm_atomic.LoadUint64(&m.afterAddCounter) < 1 {
		return false
	}
	// if func was set then invocations count should be greater than zero
	if m.funcAdd != nil && mm_atomic.LoadUint64(&m.afterAddCounter) < 1 {
		return false
	}
	return true
}

// MinimockAddInspect logs each unmet expectation
func (m *ThingNotificationRepositoryMock) MinimockAddInspect() {
	for _, e := range m.AddMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to ThingNotificationRepositoryMock.Add with params: %#v", *e.params)
		}
	}

	// if default expectation was set then invocations count should be greater than zero
	if m.AddMock.defaultExpectation != nil && mm_atomic.LoadUint64(&m.afterAddCounter) < 1 {
		if m.AddMock.defaultExpectation.params == nil {
			m.t.Error("Expected call to ThingNotificationRepositoryMock.Add")
		} else {
			m.t.Errorf("Expected call to ThingNotificationRepositoryMock.Add with params: %#v", *m.AddMock.defaultExpectation.params)
		}
	}
	// if func was set then invocations count should be greater than zero
	if m.funcAdd != nil && mm_atomic.LoadUint64(&m.afterAddCounter) < 1 {
		m.t.Error("Expected call to ThingNotificationRepositoryMock.Add")
	}
}

type mThingNotificationRepositoryMockDelete struct {
	mock               *ThingNotificationRepositoryMock
	defaultExpectation *ThingNotificationRepositoryMockDeleteExpectation
	expectations       []*ThingNotificationRepositoryMockDeleteExpectation

	callArgs []*ThingNotificationRepositoryMockDeleteParams
	mutex    sync.RWMutex
}

// ThingNotificationRepositoryMockDeleteExpectation specifies expectation struct of the ThingNotificationRepository.Delete
type ThingNotificationRepositoryMockDeleteExpectation struct {
	mock    *ThingNotificationRepositoryMock
	params  *ThingNotificationRepositoryMockDeleteParams
	results *ThingNotificationRepositoryMockDeleteResults
	Counter uint64
}

// ThingNotificationRepositoryMockDeleteParams contains parameters of the ThingNotificationRepository.Delete
type ThingNotificationRepositoryMockDeleteParams struct {
	ctx     context.Context
	thingID int
	tx      *sql.Tx
}

// ThingNotificationRepositoryMockDeleteResults contains results of the ThingNotificationRepository.Delete
type ThingNotificationRepositoryMockDeleteResults struct {
	err error
}

// Expect sets up expected params for ThingNotificationRepository.Delete
func (mmDelete *mThingNotificationRepositoryMockDelete) Expect(ctx context.Context, thingID int, tx *sql.Tx) *mThingNotificationRepositoryMockDelete {
	if mmDelete.mock.funcDelete != nil {
		mmDelete.mock.t.Fatalf("ThingNotificationRepositoryMock.Delete mock is already set by Set")
	}

	if mmDelete.defaultExpectation == nil {
		mmDelete.defaultExpectation = &ThingNotificationRepositoryMockDeleteExpectation{}
	}

	mmDelete.defaultExpectation.params = &ThingNotificationRepositoryMockDeleteParams{ctx, thingID, tx}
	for _, e := range mmDelete.expectations {
		if minimock.Equal(e.params, mmDelete.defaultExpectation.params) {
			mmDelete.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmDelete.defaultExpectation.params)
		}
	}

	return mmDelete
}

// Inspect accepts an inspector function that has same arguments as the ThingNotificationRepository.Delete
func (mmDelete *mThingNotificationRepositoryMockDelete) Inspect(f func(ctx context.Context, thingID int, tx *sql.Tx)) *mThingNotificationRepositoryMockDelete {
	if mmDelete.mock.inspectFuncDelete != nil {
		mmDelete.mock.t.Fatalf("Inspect function is already set for ThingNotificationRepositoryMock.Delete")
	}

	mmDelete.mock.inspectFuncDelete = f

	return mmDelete
}

// Return sets up results that will be returned by ThingNotificationRepository.Delete
func (mmDelete *mThingNotificationRepositoryMockDelete) Return(err error) *ThingNotificationRepositoryMock {
	if mmDelete.mock.funcDelete != nil {
		mmDelete.mock.t.Fatalf("ThingNotificationRepositoryMock.Delete mock is already set by Set")
	}

	if mmDelete.defaultExpectation == nil {
		mmDelete.defaultExpectation = &ThingNotificationRepositoryMockDeleteExpectation{mock: mmDelete.mock}
	}
	mmDelete.defaultExpectation.results = &ThingNotificationRepositoryMockDeleteResults{err}
	return mmDelete.mock
}

//Set uses given function f to mock the ThingNotificationRepository.Delete method
func (mmDelete *mThingNotificationRepositoryMockDelete) Set(f func(ctx context.Context, thingID int, tx *sql.Tx) (err error)) *ThingNotificationRepositoryMock {
	if mmDelete.defaultExpectation != nil {
		mmDelete.mock.t.Fatalf("Default expectation is already set for the ThingNotificationRepository.Delete method")
	}

	if len(mmDelete.expectations) > 0 {
		mmDelete.mock.t.Fatalf("Some expectations are already set for the ThingNotificationRepository.Delete method")
	}

	mmDelete.mock.funcDelete = f
	return mmDelete.mock
}

// When sets expectation for the ThingNotificationRepository.Delete which will trigger the result defined by the following
// Then helper
func (mmDelete *mThingNotificationRepositoryMockDelete) When(ctx context.Context, thingID int, tx *sql.Tx) *ThingNotificationRepositoryMockDeleteExpectation {
	if mmDelete.mock.funcDelete != nil {
		mmDelete.mock.t.Fatalf("ThingNotificationRepositoryMock.Delete mock is already set by Set")
	}

	expectation := &ThingNotificationRepositoryMockDeleteExpectation{
		mock:   mmDelete.mock,
		params: &ThingNotificationRepositoryMockDeleteParams{ctx, thingID, tx},
	}
	mmDelete.expectations = append(mmDelete.expectations, expectation)
	return expectation
}

// Then sets up ThingNotificationRepository.Delete return parameters for the expectation previously defined by the When method
func (e *ThingNotificationRepositoryMockDeleteExpectation) Then(err error) *ThingNotificationRepositoryMock {
	e.results = &ThingNotificationRepositoryMockDeleteResults{err}
	return e.mock
}

// Delete implements interfaces.ThingNotificationRepository
func (mmDelete *ThingNotificationRepositoryMock) Delete(ctx context.Context, thingID int, tx *sql.Tx) (err error) {
	mm_atomic.AddUint64(&mmDelete.beforeDeleteCounter, 1)
	defer mm_atomic.AddUint64(&mmDelete.afterDeleteCounter, 1)

	if mmDelete.inspectFuncDelete != nil {
		mmDelete.inspectFuncDelete(ctx, thingID, tx)
	}

	mm_params := &ThingNotificationRepositoryMockDeleteParams{ctx, thingID, tx}

	// Record call args
	mmDelete.DeleteMock.mutex.Lock()
	mmDelete.DeleteMock.callArgs = append(mmDelete.DeleteMock.callArgs, mm_params)
	mmDelete.DeleteMock.mutex.Unlock()

	for _, e := range mmDelete.DeleteMock.expectations {
		if minimock.Equal(e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return e.results.err
		}
	}

	if mmDelete.DeleteMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmDelete.DeleteMock.defaultExpectation.Counter, 1)
		mm_want := mmDelete.DeleteMock.defaultExpectation.params
		mm_got := ThingNotificationRepositoryMockDeleteParams{ctx, thingID, tx}
		if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmDelete.t.Errorf("ThingNotificationRepositoryMock.Delete got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}

		mm_results := mmDelete.DeleteMock.defaultExpectation.results
		if mm_results == nil {
			mmDelete.t.Fatal("No results are set for the ThingNotificationRepositoryMock.Delete")
		}
		return (*mm_results).err
	}
	if mmDelete.funcDelete != nil {
		return mmDelete.funcDelete(ctx, thingID, tx)
	}
	mmDelete.t.Fatalf("Unexpected call to ThingNotificationRepositoryMock.Delete. %v %v %v", ctx, thingID, tx)
	return
}

// DeleteAfterCounter returns a count of finished ThingNotificationRepositoryMock.Delete invocations
func (mmDelete *ThingNotificationRepositoryMock) DeleteAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmDelete.afterDeleteCounter)
}

// DeleteBeforeCounter returns a count of ThingNotificationRepositoryMock.Delete invocations
func (mmDelete *ThingNotificationRepositoryMock) DeleteBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmDelete.beforeDeleteCounter)
}

// Calls returns a list of arguments used in each call to ThingNotificationRepositoryMock.Delete.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmDelete *mThingNotificationRepositoryMockDelete) Calls() []*ThingNotificationRepositoryMockDeleteParams {
	mmDelete.mutex.RLock()

	argCopy := make([]*ThingNotificationRepositoryMockDeleteParams, len(mmDelete.callArgs))
	copy(argCopy, mmDelete.callArgs)

	mmDelete.mutex.RUnlock()

	return argCopy
}

// MinimockDeleteDone returns true if the count of the Delete invocations corresponds
// the number of defined expectations
func (m *ThingNotificationRepositoryMock) MinimockDeleteDone() bool {
	for _, e := range m.DeleteMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}

	// if default expectation was set then invocations count should be greater than zero
	if m.DeleteMock.defaultExpectation != nil && mm_atomic.LoadUint64(&m.afterDeleteCounter) < 1 {
		return false
	}
	// if func was set then invocations count should be greater than zero
	if m.funcDelete != nil && mm_atomic.LoadUint64(&m.afterDeleteCounter) < 1 {
		return false
	}
	return true
}

// MinimockDeleteInspect logs each unmet expectation
func (m *ThingNotificationRepositoryMock) MinimockDeleteInspect() {
	for _, e := range m.DeleteMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to ThingNotificationRepositoryMock.Delete with params: %#v", *e.params)
		}
	}

	// if default expectation was set then invocations count should be greater than zero
	if m.DeleteMock.defaultExpectation != nil && mm_atomic.LoadUint64(&m.afterDeleteCounter) < 1 {
		if m.DeleteMock.defaultExpectation.params == nil {
			m.t.Error("Expected call to ThingNotificationRepositoryMock.Delete")
		} else {
			m.t.Errorf("Expected call to ThingNotificationRepositoryMock.Delete with params: %#v", *m.DeleteMock.defaultExpectation.params)
		}
	}
	// if func was set then invocations count should be greater than zero
	if m.funcDelete != nil && mm_atomic.LoadUint64(&m.afterDeleteCounter) < 1 {
		m.t.Error("Expected call to ThingNotificationRepositoryMock.Delete")
	}
}

type mThingNotificationRepositoryMockGet struct {
	mock               *ThingNotificationRepositoryMock
	defaultExpectation *ThingNotificationRepositoryMockGetExpectation
	expectations       []*ThingNotificationRepositoryMockGetExpectation

	callArgs []*ThingNotificationRepositoryMockGetParams
	mutex    sync.RWMutex
}

// ThingNotificationRepositoryMockGetExpectation specifies expectation struct of the ThingNotificationRepository.Get
type ThingNotificationRepositoryMockGetExpectation struct {
	mock    *ThingNotificationRepositoryMock
	params  *ThingNotificationRepositoryMockGetParams
	results *ThingNotificationRepositoryMockGetResults
	Counter uint64
}

// ThingNotificationRepositoryMockGetParams contains parameters of the ThingNotificationRepository.Get
type ThingNotificationRepositoryMockGetParams struct {
	ctx     context.Context
	thingID int
}

// ThingNotificationRepositoryMockGetResults contains results of the ThingNotificationRepository.Get
type ThingNotificationRepositoryMockGetResults struct {
	tp1 *models.ThingNotification
	err error
}

// Expect sets up expected params for ThingNotificationRepository.Get
func (mmGet *mThingNotificationRepositoryMockGet) Expect(ctx context.Context, thingID int) *mThingNotificationRepositoryMockGet {
	if mmGet.mock.funcGet != nil {
		mmGet.mock.t.Fatalf("ThingNotificationRepositoryMock.Get mock is already set by Set")
	}

	if mmGet.defaultExpectation == nil {
		mmGet.defaultExpectation = &ThingNotificationRepositoryMockGetExpectation{}
	}

	mmGet.defaultExpectation.params = &ThingNotificationRepositoryMockGetParams{ctx, thingID}
	for _, e := range mmGet.expectations {
		if minimock.Equal(e.params, mmGet.defaultExpectation.params) {
			mmGet.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGet.defaultExpectation.params)
		}
	}

	return mmGet
}

// Inspect accepts an inspector function that has same arguments as the ThingNotificationRepository.Get
func (mmGet *mThingNotificationRepositoryMockGet) Inspect(f func(ctx context.Context, thingID int)) *mThingNotificationRepositoryMockGet {
	if mmGet.mock.inspectFuncGet != nil {
		mmGet.mock.t.Fatalf("Inspect function is already set for ThingNotificationRepositoryMock.Get")
	}

	mmGet.mock.inspectFuncGet = f

	return mmGet
}

// Return sets up results that will be returned by ThingNotificationRepository.Get
func (mmGet *mThingNotificationRepositoryMockGet) Return(tp1 *models.ThingNotification, err error) *ThingNotificationRepositoryMock {
	if mmGet.mock.funcGet != nil {
		mmGet.mock.t.Fatalf("ThingNotificationRepositoryMock.Get mock is already set by Set")
	}

	if mmGet.defaultExpectation == nil {
		mmGet.defaultExpectation = &ThingNotificationRepositoryMockGetExpectation{mock: mmGet.mock}
	}
	mmGet.defaultExpectation.results = &ThingNotificationRepositoryMockGetResults{tp1, err}
	return mmGet.mock
}

//Set uses given function f to mock the ThingNotificationRepository.Get method
func (mmGet *mThingNotificationRepositoryMockGet) Set(f func(ctx context.Context, thingID int) (tp1 *models.ThingNotification, err error)) *ThingNotificationRepositoryMock {
	if mmGet.defaultExpectation != nil {
		mmGet.mock.t.Fatalf("Default expectation is already set for the ThingNotificationRepository.Get method")
	}

	if len(mmGet.expectations) > 0 {
		mmGet.mock.t.Fatalf("Some expectations are already set for the ThingNotificationRepository.Get method")
	}

	mmGet.mock.funcGet = f
	return mmGet.mock
}

// When sets expectation for the ThingNotificationRepository.Get which will trigger the result defined by the following
// Then helper
func (mmGet *mThingNotificationRepositoryMockGet) When(ctx context.Context, thingID int) *ThingNotificationRepositoryMockGetExpectation {
	if mmGet.mock.funcGet != nil {
		mmGet.mock.t.Fatalf("ThingNotificationRepositoryMock.Get mock is already set by Set")
	}

	expectation := &ThingNotificationRepositoryMockGetExpectation{
		mock:   mmGet.mock,
		params: &ThingNotificationRepositoryMockGetParams{ctx, thingID},
	}
	mmGet.expectations = append(mmGet.expectations, expectation)
	return expectation
}

// Then sets up ThingNotificationRepository.Get return parameters for the expectation previously defined by the When method
func (e *ThingNotificationRepositoryMockGetExpectation) Then(tp1 *models.ThingNotification, err error) *ThingNotificationRepositoryMock {
	e.results = &ThingNotificationRepositoryMockGetResults{tp1, err}
	return e.mock
}

// Get implements interfaces.ThingNotificationRepository
func (mmGet *ThingNotificationRepositoryMock) Get(ctx context.Context, thingID int) (tp1 *models.ThingNotification, err error) {
	mm_atomic.AddUint64(&mmGet.beforeGetCounter, 1)
	defer mm_atomic.AddUint64(&mmGet.afterGetCounter, 1)

	if mmGet.inspectFuncGet != nil {
		mmGet.inspectFuncGet(ctx, thingID)
	}

	mm_params := &ThingNotificationRepositoryMockGetParams{ctx, thingID}

	// Record call args
	mmGet.GetMock.mutex.Lock()
	mmGet.GetMock.callArgs = append(mmGet.GetMock.callArgs, mm_params)
	mmGet.GetMock.mutex.Unlock()

	for _, e := range mmGet.GetMock.expectations {
		if minimock.Equal(e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return e.results.tp1, e.results.err
		}
	}

	if mmGet.GetMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmGet.GetMock.defaultExpectation.Counter, 1)
		mm_want := mmGet.GetMock.defaultExpectation.params
		mm_got := ThingNotificationRepositoryMockGetParams{ctx, thingID}
		if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmGet.t.Errorf("ThingNotificationRepositoryMock.Get got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}

		mm_results := mmGet.GetMock.defaultExpectation.results
		if mm_results == nil {
			mmGet.t.Fatal("No results are set for the ThingNotificationRepositoryMock.Get")
		}
		return (*mm_results).tp1, (*mm_results).err
	}
	if mmGet.funcGet != nil {
		return mmGet.funcGet(ctx, thingID)
	}
	mmGet.t.Fatalf("Unexpected call to ThingNotificationRepositoryMock.Get. %v %v", ctx, thingID)
	return
}

// GetAfterCounter returns a count of finished ThingNotificationRepositoryMock.Get invocations
func (mmGet *ThingNotificationRepositoryMock) GetAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmGet.afterGetCounter)
}

// GetBeforeCounter returns a count of ThingNotificationRepositoryMock.Get invocations
func (mmGet *ThingNotificationRepositoryMock) GetBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmGet.beforeGetCounter)
}

// Calls returns a list of arguments used in each call to ThingNotificationRepositoryMock.Get.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmGet *mThingNotificationRepositoryMockGet) Calls() []*ThingNotificationRepositoryMockGetParams {
	mmGet.mutex.RLock()

	argCopy := make([]*ThingNotificationRepositoryMockGetParams, len(mmGet.callArgs))
	copy(argCopy, mmGet.callArgs)

	mmGet.mutex.RUnlock()

	return argCopy
}

// MinimockGetDone returns true if the count of the Get invocations corresponds
// the number of defined expectations
func (m *ThingNotificationRepositoryMock) MinimockGetDone() bool {
	for _, e := range m.GetMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}

	// if default expectation was set then invocations count should be greater than zero
	if m.GetMock.defaultExpectation != nil && mm_atomic.LoadUint64(&m.afterGetCounter) < 1 {
		return false
	}
	// if func was set then invocations count should be greater than zero
	if m.funcGet != nil && mm_atomic.LoadUint64(&m.afterGetCounter) < 1 {
		return false
	}
	return true
}

// MinimockGetInspect logs each unmet expectation
func (m *ThingNotificationRepositoryMock) MinimockGetInspect() {
	for _, e := range m.GetMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to ThingNotificationRepositoryMock.Get with params: %#v", *e.params)
		}
	}

	// if default expectation was set then invocations count should be greater than zero
	if m.GetMock.defaultExpectation != nil && mm_atomic.LoadUint64(&m.afterGetCounter) < 1 {
		if m.GetMock.defaultExpectation.params == nil {
			m.t.Error("Expected call to ThingNotificationRepositoryMock.Get")
		} else {
			m.t.Errorf("Expected call to ThingNotificationRepositoryMock.Get with params: %#v", *m.GetMock.defaultExpectation.params)
		}
	}
	// if func was set then invocations count should be greater than zero
	if m.funcGet != nil && mm_atomic.LoadUint64(&m.afterGetCounter) < 1 {
		m.t.Error("Expected call to ThingNotificationRepositoryMock.Get")
	}
}

type mThingNotificationRepositoryMockGetExpired struct {
	mock               *ThingNotificationRepositoryMock
	defaultExpectation *ThingNotificationRepositoryMockGetExpiredExpectation
	expectations       []*ThingNotificationRepositoryMockGetExpiredExpectation

	callArgs []*ThingNotificationRepositoryMockGetExpiredParams
	mutex    sync.RWMutex
}

// ThingNotificationRepositoryMockGetExpiredExpectation specifies expectation struct of the ThingNotificationRepository.GetExpired
type ThingNotificationRepositoryMockGetExpiredExpectation struct {
	mock    *ThingNotificationRepositoryMock
	params  *ThingNotificationRepositoryMockGetExpiredParams
	results *ThingNotificationRepositoryMockGetExpiredResults
	Counter uint64
}

// ThingNotificationRepositoryMockGetExpiredParams contains parameters of the ThingNotificationRepository.GetExpired
type ThingNotificationRepositoryMockGetExpiredParams struct {
	ctx context.Context
}

// ThingNotificationRepositoryMockGetExpiredResults contains results of the ThingNotificationRepository.GetExpired
type ThingNotificationRepositoryMockGetExpiredResults struct {
	ea1 []models.ExtThingNotification
	err error
}

// Expect sets up expected params for ThingNotificationRepository.GetExpired
func (mmGetExpired *mThingNotificationRepositoryMockGetExpired) Expect(ctx context.Context) *mThingNotificationRepositoryMockGetExpired {
	if mmGetExpired.mock.funcGetExpired != nil {
		mmGetExpired.mock.t.Fatalf("ThingNotificationRepositoryMock.GetExpired mock is already set by Set")
	}

	if mmGetExpired.defaultExpectation == nil {
		mmGetExpired.defaultExpectation = &ThingNotificationRepositoryMockGetExpiredExpectation{}
	}

	mmGetExpired.defaultExpectation.params = &ThingNotificationRepositoryMockGetExpiredParams{ctx}
	for _, e := range mmGetExpired.expectations {
		if minimock.Equal(e.params, mmGetExpired.defaultExpectation.params) {
			mmGetExpired.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmGetExpired.defaultExpectation.params)
		}
	}

	return mmGetExpired
}

// Inspect accepts an inspector function that has same arguments as the ThingNotificationRepository.GetExpired
func (mmGetExpired *mThingNotificationRepositoryMockGetExpired) Inspect(f func(ctx context.Context)) *mThingNotificationRepositoryMockGetExpired {
	if mmGetExpired.mock.inspectFuncGetExpired != nil {
		mmGetExpired.mock.t.Fatalf("Inspect function is already set for ThingNotificationRepositoryMock.GetExpired")
	}

	mmGetExpired.mock.inspectFuncGetExpired = f

	return mmGetExpired
}

// Return sets up results that will be returned by ThingNotificationRepository.GetExpired
func (mmGetExpired *mThingNotificationRepositoryMockGetExpired) Return(ea1 []models.ExtThingNotification, err error) *ThingNotificationRepositoryMock {
	if mmGetExpired.mock.funcGetExpired != nil {
		mmGetExpired.mock.t.Fatalf("ThingNotificationRepositoryMock.GetExpired mock is already set by Set")
	}

	if mmGetExpired.defaultExpectation == nil {
		mmGetExpired.defaultExpectation = &ThingNotificationRepositoryMockGetExpiredExpectation{mock: mmGetExpired.mock}
	}
	mmGetExpired.defaultExpectation.results = &ThingNotificationRepositoryMockGetExpiredResults{ea1, err}
	return mmGetExpired.mock
}

//Set uses given function f to mock the ThingNotificationRepository.GetExpired method
func (mmGetExpired *mThingNotificationRepositoryMockGetExpired) Set(f func(ctx context.Context) (ea1 []models.ExtThingNotification, err error)) *ThingNotificationRepositoryMock {
	if mmGetExpired.defaultExpectation != nil {
		mmGetExpired.mock.t.Fatalf("Default expectation is already set for the ThingNotificationRepository.GetExpired method")
	}

	if len(mmGetExpired.expectations) > 0 {
		mmGetExpired.mock.t.Fatalf("Some expectations are already set for the ThingNotificationRepository.GetExpired method")
	}

	mmGetExpired.mock.funcGetExpired = f
	return mmGetExpired.mock
}

// When sets expectation for the ThingNotificationRepository.GetExpired which will trigger the result defined by the following
// Then helper
func (mmGetExpired *mThingNotificationRepositoryMockGetExpired) When(ctx context.Context) *ThingNotificationRepositoryMockGetExpiredExpectation {
	if mmGetExpired.mock.funcGetExpired != nil {
		mmGetExpired.mock.t.Fatalf("ThingNotificationRepositoryMock.GetExpired mock is already set by Set")
	}

	expectation := &ThingNotificationRepositoryMockGetExpiredExpectation{
		mock:   mmGetExpired.mock,
		params: &ThingNotificationRepositoryMockGetExpiredParams{ctx},
	}
	mmGetExpired.expectations = append(mmGetExpired.expectations, expectation)
	return expectation
}

// Then sets up ThingNotificationRepository.GetExpired return parameters for the expectation previously defined by the When method
func (e *ThingNotificationRepositoryMockGetExpiredExpectation) Then(ea1 []models.ExtThingNotification, err error) *ThingNotificationRepositoryMock {
	e.results = &ThingNotificationRepositoryMockGetExpiredResults{ea1, err}
	return e.mock
}

// GetExpired implements interfaces.ThingNotificationRepository
func (mmGetExpired *ThingNotificationRepositoryMock) GetExpired(ctx context.Context) (ea1 []models.ExtThingNotification, err error) {
	mm_atomic.AddUint64(&mmGetExpired.beforeGetExpiredCounter, 1)
	defer mm_atomic.AddUint64(&mmGetExpired.afterGetExpiredCounter, 1)

	if mmGetExpired.inspectFuncGetExpired != nil {
		mmGetExpired.inspectFuncGetExpired(ctx)
	}

	mm_params := &ThingNotificationRepositoryMockGetExpiredParams{ctx}

	// Record call args
	mmGetExpired.GetExpiredMock.mutex.Lock()
	mmGetExpired.GetExpiredMock.callArgs = append(mmGetExpired.GetExpiredMock.callArgs, mm_params)
	mmGetExpired.GetExpiredMock.mutex.Unlock()

	for _, e := range mmGetExpired.GetExpiredMock.expectations {
		if minimock.Equal(e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return e.results.ea1, e.results.err
		}
	}

	if mmGetExpired.GetExpiredMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmGetExpired.GetExpiredMock.defaultExpectation.Counter, 1)
		mm_want := mmGetExpired.GetExpiredMock.defaultExpectation.params
		mm_got := ThingNotificationRepositoryMockGetExpiredParams{ctx}
		if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmGetExpired.t.Errorf("ThingNotificationRepositoryMock.GetExpired got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}

		mm_results := mmGetExpired.GetExpiredMock.defaultExpectation.results
		if mm_results == nil {
			mmGetExpired.t.Fatal("No results are set for the ThingNotificationRepositoryMock.GetExpired")
		}
		return (*mm_results).ea1, (*mm_results).err
	}
	if mmGetExpired.funcGetExpired != nil {
		return mmGetExpired.funcGetExpired(ctx)
	}
	mmGetExpired.t.Fatalf("Unexpected call to ThingNotificationRepositoryMock.GetExpired. %v", ctx)
	return
}

// GetExpiredAfterCounter returns a count of finished ThingNotificationRepositoryMock.GetExpired invocations
func (mmGetExpired *ThingNotificationRepositoryMock) GetExpiredAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmGetExpired.afterGetExpiredCounter)
}

// GetExpiredBeforeCounter returns a count of ThingNotificationRepositoryMock.GetExpired invocations
func (mmGetExpired *ThingNotificationRepositoryMock) GetExpiredBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmGetExpired.beforeGetExpiredCounter)
}

// Calls returns a list of arguments used in each call to ThingNotificationRepositoryMock.GetExpired.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmGetExpired *mThingNotificationRepositoryMockGetExpired) Calls() []*ThingNotificationRepositoryMockGetExpiredParams {
	mmGetExpired.mutex.RLock()

	argCopy := make([]*ThingNotificationRepositoryMockGetExpiredParams, len(mmGetExpired.callArgs))
	copy(argCopy, mmGetExpired.callArgs)

	mmGetExpired.mutex.RUnlock()

	return argCopy
}

// MinimockGetExpiredDone returns true if the count of the GetExpired invocations corresponds
// the number of defined expectations
func (m *ThingNotificationRepositoryMock) MinimockGetExpiredDone() bool {
	for _, e := range m.GetExpiredMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}

	// if default expectation was set then invocations count should be greater than zero
	if m.GetExpiredMock.defaultExpectation != nil && mm_atomic.LoadUint64(&m.afterGetExpiredCounter) < 1 {
		return false
	}
	// if func was set then invocations count should be greater than zero
	if m.funcGetExpired != nil && mm_atomic.LoadUint64(&m.afterGetExpiredCounter) < 1 {
		return false
	}
	return true
}

// MinimockGetExpiredInspect logs each unmet expectation
func (m *ThingNotificationRepositoryMock) MinimockGetExpiredInspect() {
	for _, e := range m.GetExpiredMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to ThingNotificationRepositoryMock.GetExpired with params: %#v", *e.params)
		}
	}

	// if default expectation was set then invocations count should be greater than zero
	if m.GetExpiredMock.defaultExpectation != nil && mm_atomic.LoadUint64(&m.afterGetExpiredCounter) < 1 {
		if m.GetExpiredMock.defaultExpectation.params == nil {
			m.t.Error("Expected call to ThingNotificationRepositoryMock.GetExpired")
		} else {
			m.t.Errorf("Expected call to ThingNotificationRepositoryMock.GetExpired with params: %#v", *m.GetExpiredMock.defaultExpectation.params)
		}
	}
	// if func was set then invocations count should be greater than zero
	if m.funcGetExpired != nil && mm_atomic.LoadUint64(&m.afterGetExpiredCounter) < 1 {
		m.t.Error("Expected call to ThingNotificationRepositoryMock.GetExpired")
	}
}

type mThingNotificationRepositoryMockUpdate struct {
	mock               *ThingNotificationRepositoryMock
	defaultExpectation *ThingNotificationRepositoryMockUpdateExpectation
	expectations       []*ThingNotificationRepositoryMockUpdateExpectation

	callArgs []*ThingNotificationRepositoryMockUpdateParams
	mutex    sync.RWMutex
}

// ThingNotificationRepositoryMockUpdateExpectation specifies expectation struct of the ThingNotificationRepository.Update
type ThingNotificationRepositoryMockUpdateExpectation struct {
	mock    *ThingNotificationRepositoryMock
	params  *ThingNotificationRepositoryMockUpdateParams
	results *ThingNotificationRepositoryMockUpdateResults
	Counter uint64
}

// ThingNotificationRepositoryMockUpdateParams contains parameters of the ThingNotificationRepository.Update
type ThingNotificationRepositoryMockUpdateParams struct {
	ctx context.Context
	req models.UpdateThingNotificationRequest
	tx  *sql.Tx
}

// ThingNotificationRepositoryMockUpdateResults contains results of the ThingNotificationRepository.Update
type ThingNotificationRepositoryMockUpdateResults struct {
	err error
}

// Expect sets up expected params for ThingNotificationRepository.Update
func (mmUpdate *mThingNotificationRepositoryMockUpdate) Expect(ctx context.Context, req models.UpdateThingNotificationRequest, tx *sql.Tx) *mThingNotificationRepositoryMockUpdate {
	if mmUpdate.mock.funcUpdate != nil {
		mmUpdate.mock.t.Fatalf("ThingNotificationRepositoryMock.Update mock is already set by Set")
	}

	if mmUpdate.defaultExpectation == nil {
		mmUpdate.defaultExpectation = &ThingNotificationRepositoryMockUpdateExpectation{}
	}

	mmUpdate.defaultExpectation.params = &ThingNotificationRepositoryMockUpdateParams{ctx, req, tx}
	for _, e := range mmUpdate.expectations {
		if minimock.Equal(e.params, mmUpdate.defaultExpectation.params) {
			mmUpdate.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmUpdate.defaultExpectation.params)
		}
	}

	return mmUpdate
}

// Inspect accepts an inspector function that has same arguments as the ThingNotificationRepository.Update
func (mmUpdate *mThingNotificationRepositoryMockUpdate) Inspect(f func(ctx context.Context, req models.UpdateThingNotificationRequest, tx *sql.Tx)) *mThingNotificationRepositoryMockUpdate {
	if mmUpdate.mock.inspectFuncUpdate != nil {
		mmUpdate.mock.t.Fatalf("Inspect function is already set for ThingNotificationRepositoryMock.Update")
	}

	mmUpdate.mock.inspectFuncUpdate = f

	return mmUpdate
}

// Return sets up results that will be returned by ThingNotificationRepository.Update
func (mmUpdate *mThingNotificationRepositoryMockUpdate) Return(err error) *ThingNotificationRepositoryMock {
	if mmUpdate.mock.funcUpdate != nil {
		mmUpdate.mock.t.Fatalf("ThingNotificationRepositoryMock.Update mock is already set by Set")
	}

	if mmUpdate.defaultExpectation == nil {
		mmUpdate.defaultExpectation = &ThingNotificationRepositoryMockUpdateExpectation{mock: mmUpdate.mock}
	}
	mmUpdate.defaultExpectation.results = &ThingNotificationRepositoryMockUpdateResults{err}
	return mmUpdate.mock
}

//Set uses given function f to mock the ThingNotificationRepository.Update method
func (mmUpdate *mThingNotificationRepositoryMockUpdate) Set(f func(ctx context.Context, req models.UpdateThingNotificationRequest, tx *sql.Tx) (err error)) *ThingNotificationRepositoryMock {
	if mmUpdate.defaultExpectation != nil {
		mmUpdate.mock.t.Fatalf("Default expectation is already set for the ThingNotificationRepository.Update method")
	}

	if len(mmUpdate.expectations) > 0 {
		mmUpdate.mock.t.Fatalf("Some expectations are already set for the ThingNotificationRepository.Update method")
	}

	mmUpdate.mock.funcUpdate = f
	return mmUpdate.mock
}

// When sets expectation for the ThingNotificationRepository.Update which will trigger the result defined by the following
// Then helper
func (mmUpdate *mThingNotificationRepositoryMockUpdate) When(ctx context.Context, req models.UpdateThingNotificationRequest, tx *sql.Tx) *ThingNotificationRepositoryMockUpdateExpectation {
	if mmUpdate.mock.funcUpdate != nil {
		mmUpdate.mock.t.Fatalf("ThingNotificationRepositoryMock.Update mock is already set by Set")
	}

	expectation := &ThingNotificationRepositoryMockUpdateExpectation{
		mock:   mmUpdate.mock,
		params: &ThingNotificationRepositoryMockUpdateParams{ctx, req, tx},
	}
	mmUpdate.expectations = append(mmUpdate.expectations, expectation)
	return expectation
}

// Then sets up ThingNotificationRepository.Update return parameters for the expectation previously defined by the When method
func (e *ThingNotificationRepositoryMockUpdateExpectation) Then(err error) *ThingNotificationRepositoryMock {
	e.results = &ThingNotificationRepositoryMockUpdateResults{err}
	return e.mock
}

// Update implements interfaces.ThingNotificationRepository
func (mmUpdate *ThingNotificationRepositoryMock) Update(ctx context.Context, req models.UpdateThingNotificationRequest, tx *sql.Tx) (err error) {
	mm_atomic.AddUint64(&mmUpdate.beforeUpdateCounter, 1)
	defer mm_atomic.AddUint64(&mmUpdate.afterUpdateCounter, 1)

	if mmUpdate.inspectFuncUpdate != nil {
		mmUpdate.inspectFuncUpdate(ctx, req, tx)
	}

	mm_params := &ThingNotificationRepositoryMockUpdateParams{ctx, req, tx}

	// Record call args
	mmUpdate.UpdateMock.mutex.Lock()
	mmUpdate.UpdateMock.callArgs = append(mmUpdate.UpdateMock.callArgs, mm_params)
	mmUpdate.UpdateMock.mutex.Unlock()

	for _, e := range mmUpdate.UpdateMock.expectations {
		if minimock.Equal(e.params, mm_params) {
			mm_atomic.AddUint64(&e.Counter, 1)
			return e.results.err
		}
	}

	if mmUpdate.UpdateMock.defaultExpectation != nil {
		mm_atomic.AddUint64(&mmUpdate.UpdateMock.defaultExpectation.Counter, 1)
		mm_want := mmUpdate.UpdateMock.defaultExpectation.params
		mm_got := ThingNotificationRepositoryMockUpdateParams{ctx, req, tx}
		if mm_want != nil && !minimock.Equal(*mm_want, mm_got) {
			mmUpdate.t.Errorf("ThingNotificationRepositoryMock.Update got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got))
		}

		mm_results := mmUpdate.UpdateMock.defaultExpectation.results
		if mm_results == nil {
			mmUpdate.t.Fatal("No results are set for the ThingNotificationRepositoryMock.Update")
		}
		return (*mm_results).err
	}
	if mmUpdate.funcUpdate != nil {
		return mmUpdate.funcUpdate(ctx, req, tx)
	}
	mmUpdate.t.Fatalf("Unexpected call to ThingNotificationRepositoryMock.Update. %v %v %v", ctx, req, tx)
	return
}

// UpdateAfterCounter returns a count of finished ThingNotificationRepositoryMock.Update invocations
func (mmUpdate *ThingNotificationRepositoryMock) UpdateAfterCounter() uint64 {
	return mm_atomic.LoadUint64(&mmUpdate.afterUpdateCounter)
}

// UpdateBeforeCounter returns a count of ThingNotificationRepositoryMock.Update invocations
func (mmUpdate *ThingNotificationRepositoryMock) UpdateBeforeCounter() uint64 {
	return mm_atomic.LoadUint64(&mmUpdate.beforeUpdateCounter)
}

// Calls returns a list of arguments used in each call to ThingNotificationRepositoryMock.Update.
// The list is in the same order as the calls were made (i.e. recent calls have a higher index)
func (mmUpdate *mThingNotificationRepositoryMockUpdate) Calls() []*ThingNotificationRepositoryMockUpdateParams {
	mmUpdate.mutex.RLock()

	argCopy := make([]*ThingNotificationRepositoryMockUpdateParams, len(mmUpdate.callArgs))
	copy(argCopy, mmUpdate.callArgs)

	mmUpdate.mutex.RUnlock()

	return argCopy
}

// MinimockUpdateDone returns true if the count of the Update invocations corresponds
// the number of defined expectations
func (m *ThingNotificationRepositoryMock) MinimockUpdateDone() bool {
	for _, e := range m.UpdateMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			return false
		}
	}

	// if default expectation was set then invocations count should be greater than zero
	if m.UpdateMock.defaultExpectation != nil && mm_atomic.LoadUint64(&m.afterUpdateCounter) < 1 {
		return false
	}
	// if func was set then invocations count should be greater than zero
	if m.funcUpdate != nil && mm_atomic.LoadUint64(&m.afterUpdateCounter) < 1 {
		return false
	}
	return true
}

// MinimockUpdateInspect logs each unmet expectation
func (m *ThingNotificationRepositoryMock) MinimockUpdateInspect() {
	for _, e := range m.UpdateMock.expectations {
		if mm_atomic.LoadUint64(&e.Counter) < 1 {
			m.t.Errorf("Expected call to ThingNotificationRepositoryMock.Update with params: %#v", *e.params)
		}
	}

	// if default expectation was set then invocations count should be greater than zero
	if m.UpdateMock.defaultExpectation != nil && mm_atomic.LoadUint64(&m.afterUpdateCounter) < 1 {
		if m.UpdateMock.defaultExpectation.params == nil {
			m.t.Error("Expected call to ThingNotificationRepositoryMock.Update")
		} else {
			m.t.Errorf("Expected call to ThingNotificationRepositoryMock.Update with params: %#v", *m.UpdateMock.defaultExpectation.params)
		}
	}
	// if func was set then invocations count should be greater than zero
	if m.funcUpdate != nil && mm_atomic.LoadUint64(&m.afterUpdateCounter) < 1 {
		m.t.Error("Expected call to ThingNotificationRepositoryMock.Update")
	}
}

// MinimockFinish checks that all mocked methods have been called the expected number of times
func (m *ThingNotificationRepositoryMock) MinimockFinish() {
	if !m.minimockDone() {
		m.MinimockAddInspect()

		m.MinimockDeleteInspect()

		m.MinimockGetInspect()

		m.MinimockGetExpiredInspect()

		m.MinimockUpdateInspect()
		m.t.FailNow()
	}
}

// MinimockWait waits for all mocked methods to be called the expected number of times
func (m *ThingNotificationRepositoryMock) MinimockWait(timeout mm_time.Duration) {
	timeoutCh := mm_time.After(timeout)
	for {
		if m.minimockDone() {
			return
		}
		select {
		case <-timeoutCh:
			m.MinimockFinish()
			return
		case <-mm_time.After(10 * mm_time.Millisecond):
		}
	}
}

func (m *ThingNotificationRepositoryMock) minimockDone() bool {
	done := true
	return done &&
		m.MinimockAddDone() &&
		m.MinimockDeleteDone() &&
		m.MinimockGetDone() &&
		m.MinimockGetExpiredDone() &&
		m.MinimockUpdateDone()
}