test

type Authorizer struct {
	// contains filtered or unexported fields
}

type Clock struct {
	CurrentTime time.Time
}

type Database struct {
	mock.Mock
	// contains filtered or unexported fields
}

type DatabaseCountExpectation struct {
	ExpectedResourceType resource.Type
	ExpectedFilters      []*query.Filter
	ReturnedResponse     int
	ReturnedError        error
}

type DatabaseCreateExpectation struct {
	ExpectedResourceType resource.Type
	ExpectedResource     interface{}
	ReturnedID           uuid.UUID
	ReturnedError        error
}

type DatabaseDeleteExpectation struct {
	ExpectedResourceType resource.Type
	ExpectedID           uuid.UUID
	ReturnedError        error
}

type DatabaseRetrieveByIDExpectation struct {
	ExpectedResourceType resource.Type
	ExpectedID           uuid.UUID
	ExpectedResource     interface{}
	ReturnedResource     interface{}
	ReturnedError        error
}

type DatabaseRetrieveByIDOrCodeExpectation struct {
	ExpectedResourceType resource.Type
	ExpectedIDOrCode     string
	ExpectedResource     interface{}
	ReturnedResource     interface{}
	ReturnedError        error
}

type DatabaseRetrieveManyExpectation struct {
	ExpectedResourceType resource.Type
	ExpectedQuery        *query.Query
	ExpectedResources    interface{}
	ReturnedResources    interface{}
	ReturnedError        error
}

type DatabaseRetrieveNamespaceChildrenIDsExpectation struct {
	ExpectedNamespaceIDs []uuid.UUID
	ReturnedNamespaceIDs []uuid.UUID
	ReturnedError        error
}

type DatabaseRetrieveNamespaceParentIDsExpectation struct {
	ExpectedNamespaceID  []uuid.UUID
	ReturnedNamespaceIDs uuid.UUID
	ReturnedError        error
}

type DatabaseUpdateExpectation struct {
	ExpectedResourceType resource.Type
	ExpectedID           uuid.UUID
	ExpectedResource     interface{}
	ReturnedError        error
}

type DeliveryAction struct {
	mock.Mock
	// contains filtered or unexported fields
}

type DeliveryActionCreateExpectation struct {
	ExpectedDelivery *resource.Delivery
	ReturnedDelivery *resource.Delivery
	ReturnedError    error
}

type DeliveryActionQueueRequestExpectation struct {
	ExpectedDeliveryID uuid.UUID
	ReturnedError      error
}

type DeliveryActionRetrieveByIDExpectation struct {
	ExpectedID       uuid.UUID
	ReturnedDelivery *resource.Delivery
	ReturnedError    error
}

type DeliveryActionRetrieveByMessageIDExpectation struct {
	ExpectedMessageID  uuid.UUID
	ReturnedDeliveries []*resource.Delivery
	ReturnedError      error
}

type DeliveryActionRetrieveManyExpectation struct {
	ExpectedQuery      *query.Query
	ReturnedDeliveries []*resource.Delivery
	ReturnedError      error
}

type DeliveryActionUpdateExpectation struct {
	ExpectedID       uuid.UUID
	ExpectedDelivery *resource.Delivery
	ReturnedDelivery *resource.Delivery
	ReturnedError    error
}

type DeliveryKindAction struct {
	mock.Mock
	// contains filtered or unexported fields
}

type DeliveryKindActionCreateExpectation struct {
	ExpectedDeliveryKind *resource.DeliveryKind
	ReturnedDeliveryKind *resource.DeliveryKind
	ReturnedError        error
}

type DeliveryKindActionDeleteExpectation struct {
	ExpectedID    uuid.UUID
	ReturnedError error
}

type DeliveryKindActionRetrieveByIDExpectation struct {
	ExpectedID           uuid.UUID
	ReturnedDeliveryKind *resource.DeliveryKind
	ReturnedError        error
}

type DeliveryKindActionRetrieveByIDOrCodeExpectation struct {
	ExpectedIDOrCode     string
	ReturnedDeliveryKind *resource.DeliveryKind
	ReturnedError        error
}

type DeliveryKindActionRetrieveManyExpectation struct {
	ExpectedQuery         *query.Query
	ReturnedDeliveryKinds []*resource.DeliveryKind
	ReturnedError         error
}

type DeliveryKindActionUpdateExpectation struct {
	ExpectedID           uuid.UUID
	ExpectedDeliveryKind *resource.DeliveryKind
	ReturnedDeliveryKind *resource.DeliveryKind
	ReturnedError        error
}

type ErrorExpectation struct {
	Error        error
	ErrorMessage string
}

type MSGQueue struct {
	mock.Mock
	// contains filtered or unexported fields
}

type MSGQueuePublishExpectation struct {
	ExpectedData  []byte
	ReturnedError error
}

type MSGQueueSubscribeExpectation struct {
	ExpectedHandler handler.MSGHandlerFunc
	ReturnedError   error
}

type MessageAction struct {
	mock.Mock
	// contains filtered or unexported fields
}

type MessageActionCreateExpectation struct {
	ExpectedMessage *resource.Message
	ReturnedMessage *resource.Message
	ReturnedError   error
}

type MessageActionDeleteExpectation struct {
	ExpectedID    uuid.UUID
	ReturnedError error
}

type MessageActionRetrieveByIDExpectation struct {
	ExpectedID      uuid.UUID
	ReturnedMessage *resource.Message
	ReturnedError   error
}

type MessageActionRetrieveByIDOrCodeExpectation struct {
	ExpectedIDOrCode string
	ReturnedMessage  *resource.Message
	ReturnedError    error
}

type MessageActionRetrieveManyExpectation struct {
	ExpectedQuery    *query.Query
	ReturnedMessages []*resource.Message
	ReturnedError    error
}

type MessageActionRetrievePotentiallyFailedExpectation struct {
	ExpectedSince    time.Duration
	ReturnedMessages []*resource.Message
	ReturnedError    error
}

type MessageActionUpdateExpectation struct {
	ExpectedID      uuid.UUID
	ExpectedMessage *resource.Message
	ReturnedMessage *resource.Message
	ReturnedError   error
}

type MessageKindAction struct {
	mock.Mock
	// contains filtered or unexported fields
}

type MessageKindActionCreateExpectation struct {
	ExpectedMessageKind *resource.MessageKind
	ReturnedMessageKind *resource.MessageKind
	ReturnedError       error
}

type MessageKindActionDeleteExpectation struct {
	ExpectedID    uuid.UUID
	ReturnedError error
}

type MessageKindActionRetrieveByIDExpectation struct {
	ExpectedID          uuid.UUID
	ReturnedMessageKind *resource.MessageKind
	ReturnedError       error
}

type MessageKindActionRetrieveByIDOrCodeExpectation struct {
	ExpectedIDOrCode    string
	ReturnedMessageKind *resource.MessageKind
	ReturnedError       error
}

type MessageKindActionRetrieveManyExpectation struct {
	ExpectedQuery        *query.Query
	ReturnedMessageKinds []*resource.MessageKind
	ReturnedError        error
}

type MessageKindActionUpdateExpectation struct {
	ExpectedID          uuid.UUID
	ExpectedMessageKind *resource.MessageKind
	ReturnedMessageKind *resource.MessageKind
	ReturnedError       error
}

type NamespaceAction struct {
	mock.Mock
	// contains filtered or unexported fields
}

type NamespaceActionCreateExpectation struct {
	ExpectedNamespace *resource.Namespace
	ReturnedNamespace *resource.Namespace
	ReturnedError     error
}

type NamespaceActionDeleteExpectation struct {
	ExpectedID    uuid.UUID
	ReturnedError error
}

type NamespaceActionRetrieveByIDExpectation struct {
	ExpectedID        uuid.UUID
	ReturnedNamespace *resource.Namespace
	ReturnedError     error
}

type NamespaceActionRetrieveByIDOrCodeExpectation struct {
	ExpectedIDOrCode  string
	ReturnedNamespace *resource.Namespace
	ReturnedError     error
}

type NamespaceActionRetrieveChildrenIDsExpectation struct {
	ExpectedIDs   []uuid.UUID
	ReturnedIDs   []uuid.UUID
	ReturnedError error
}

type NamespaceActionRetrieveManyExpectation struct {
	ExpectedQuery      *query.Query
	ReturnedNamespaces []*resource.Namespace
	ReturnedError      error
}

type NamespaceActionRetrieveParentIDsExpectation struct {
	ExpectedID    uuid.UUID
	ReturnedIDs   []uuid.UUID
	ReturnedError error
}

type NamespaceActionUpdateExpectation struct {
	ExpectedID        uuid.UUID
	ExpectedNamespace *resource.Namespace
	ReturnedNamespace *resource.Namespace
	ReturnedError     error
}

type Permission struct {
	NamespaceID  uuid.UUID
	ResourceType resource.Type
	Operation    string
}

type TemplateAction struct {
	mock.Mock
	// contains filtered or unexported fields
}

type TemplateActionCreateExpectation struct {
	ExpectedTemplate *resource.Template
	ReturnedTemplate *resource.Template
	ReturnedError    error
}

type TemplateActionDeleteExpectation struct {
	ExpectedID    uuid.UUID
	ReturnedError error
}

type TemplateActionRetrieveByIDExpectation struct {
	ExpectedID       uuid.UUID
	ReturnedTemplate *resource.Template
	ReturnedError    error
}

type TemplateActionRetrieveByIDOrCodeExpectation struct {
	ExpectedIDOrCode string
	ReturnedTemplate *resource.Template
	ReturnedError    error
}

type TemplateActionRetrieveManyExpectation struct {
	ExpectedQuery     *query.Query
	ReturnedTemplates []*resource.Template
	ReturnedError     error
}

type TemplateActionUpdateExpectation struct {
	ExpectedID       uuid.UUID
	ExpectedTemplate *resource.Template
	ReturnedTemplate *resource.Template
	ReturnedError    error
}

type TemplateKindAction struct {
	mock.Mock
	// contains filtered or unexported fields
}

type TemplateKindActionCreateExpectation struct {
	ExpectedTemplateKind *resource.TemplateKind
	ReturnedTemplateKind *resource.TemplateKind
	ReturnedError        error
}

type TemplateKindActionDeleteExpectation struct {
	ExpectedID    uuid.UUID
	ReturnedError error
}

type TemplateKindActionRetrieveByIDExpectation struct {
	ExpectedID           uuid.UUID
	ReturnedTemplateKind *resource.TemplateKind
	ReturnedError        error
}

type TemplateKindActionRetrieveByIDOrCodeExpectation struct {
	ExpectedIDOrCode     string
	ReturnedTemplateKind *resource.TemplateKind
	ReturnedError        error
}

type TemplateKindActionRetrieveManyExpectation struct {
	ExpectedQuery         *query.Query
	ReturnedTemplateKinds []*resource.TemplateKind
	ReturnedError         error
}

type TemplateKindActionUpdateExpectation struct {
	ExpectedID           uuid.UUID
	ExpectedTemplateKind *resource.TemplateKind
	ReturnedTemplateKind *resource.TemplateKind
	ReturnedError        error
}